Diario de aprendizaje de GNU-linux

W1NS3R · 24 Mayo, 2026 21:21

Día 31 Variables Locales y Variables de Entorno

Variables Locales: Estas son variables que perteneces unicamente a la instancia de la terminal, se guardan en la memoria ram por lo que al cerrar la pestaña desaparece
Variables de Entorno: Son variables que permiten al sistema operativo inyectar en la memoria de un programa en el momento exacto de su inicio para darle contexto operativo, ejemplo: PATH, HOME, USER
su sintaxis de creación es con el comando export, ejemplo export VARIABLE=valor
aunque tiene alcance con ostros programas o scripst por ejemplo en una segunda pestaña no cambia los valores uno de otro, es decir al usar una variable de entorno los datos se clonan.
Su persistencia es temporal pues tambien se almacena en memoria RAM
El archivo .bashrc: Para poder usar una variable de entorno de manera persistense se usa un escript en archivos .bashrc es texto plano que reside el sistema de ficheros

W1NS3R · 25 Mayo, 2026 18:58

Día 32 Operadores nivel de bit en bash

Por defecto bash trata todo como caracteres o cadenas de caracteres, es por eso que si queremos hacer una operación aritmetica tenemos que ponerlo entre doble parentesis, ejemplo echo $((5 + 5)).
El simbolo $ o operador de expanción es en esencia un orden de intercambio o de extraccion, es decir, basicamente le dice a bash “no leas esto como texto litar; ve a mirar que hay dentro, resuelve lo que falta y entregame al resultado aqui mismo” si ago echo 5 + 5 bash me devolvera eso como texto plano, pero con el operador de expanción y los parentesis dobles bash entiende que es lo que se pretende hacer.
para entender los operadores bit a bit antes hay que entender como funciona el sisstema binario en hardware, asumiento que ya se entiende a nivel basico como funciona el sistema binario
conteo posicional: al igual que en el sistema decimal se cuenta de derecha a izquierda
Bits: un bit es la unidad minima de información que una computadora puede leer 0 o 1 cuando hablamos de computadoras de 8 16 32 o 64 bits nos referimos a la cantidad maxima de información que una computadora puede leer o procesar de la memoria RAM, por ejemplo si yo creo un numero en sistema binario ejemplo 0101 que en sistema decimal seria el 5, la computadora no lo lee solo como 0101 si no dependiendo del tipo de procesador, lo leera como un total de 64 digitos (en caso de que el procesador sea de 64 bits) cuyos primeros 4 digitos a la derecha del todo son 0101 y el resto de digitos se quedaran en 0.
¿Por que es importante saber esto? al operar con bits en una computadora pueden pasar cosas extrañas si no se entiende bien esto, por ejemplo ¿como se representan numeros negativos en una computadora si solo entiende de 0 y 1? esto lo veremos mas adelante
Operadores bit a bit:
- Nota: para poder decirle a bash en que sistema numerico estamos es necesario aclarandolo con # ejemplo ((2#)) es decir sistema base 2, en decimal por ejemplo de esta forma bash entiende en que sistema numerico queremos usasr
- AND (intersección): El simblo para AND logico en bash es “&” echo $((2#0101 & 2#0011)) esto nos devolveria 1, puesto que la condición and necesita que hambas condiciones sean verdaderas para 1 y que solo 1 o hambas sean falsas para 0, si operamos los bits veremos que solo el primer digito de hambos operandos son 1, mientras en el resto son incompatibles, por lo tanto el resultado seria 0001 que en sistema decimal seria 1
- OR(Unión): El simbolo para OR logico en bash es “|” echo $((2#0101 | 2#0011)) esto nos devolveria 7, puesto que al operar los bits vemos que almenos 1 de los primeros 3 digitos de hambos operandos son 1, por lo que el resultado seria 0111 que en sistema decimal seria 7
- XOR(OR exclusivo): El simbolo para XOR logico es “^” echo $((2#0101 ^ 2#0011)) esto nos devolveria 6 puesto que el tercer digito del primer operando y el segundo digito del segundo operando tiene 1 y al operarse con el mismo digito del otro operando es 0, recordemos que XOR da como verdadero las condiciones cuya opciones solo 1 es verdadera y la otra falsa
- NOT (Negación): El simbolo para NOT logico es “~” echo $((~2#0011)) esto nos devolveria -4 ¿por que? si lo logico seria pensar que sus operadores al negarse daria 1100 cuyo valor en sistema decimal es 12, esto sucede por lo que explique al principio, una computadora siempre creara el valor de un numero con la cantidad de digitos en bits que soporte su procesador, independientemente si yo ago 0011 el procesador por ejemplo de 64 bits creara 64 digitos cuyos primeros 4 a su derecha son 0011 y el resto serán 0 al negar cada digito no solo estoy negando el 0011 si no tambien el resto de digitos que estan en 0 a su izquienda, ¿pero entonces por que esos 1 no se suman y da un valor negativo? esto es por el complemento a dos
- << (Desplazamiento a la izquierda): echo $((2#0011<<2)) esto desplaza los 2 primeros bits a la izquierda, en este caso 11, por lo que el resultado es 1100 que en decimal seria 12
- >> (Desplazamiento a la derecha): echo $((2#1100>>2)) esto desplaza los 2 primeros bits a la derecha, en este caso 11 por lo que el resultado es 0011 que en decimal seria 3
complemento a dos:
El complemento a dos resuelve un problema, y es que las computadoras solo entienden de 0 y 1, no pueden entender un signo como el “-” para representar numeros negativos, por lo tanto el primer bit a la izquienda del todo es el que decide si un numero es positivo o negativo, si es 0 es positivo, si es 1 es negativo.
Aquí pasa algo muy interesante, y es que si el primer digito a la izquierda es 1, los 0 pasan a ser los valores positivos y los 1 los valores negativos, esto ademas de que se lee al reves, a la derecha estan los digitos mas grandes y a la izquierda los mas pequeños, por lo tanto si tengo ~2#0011 la computadora lo lee como 11111111…** cuyos primeros 4 digitos a su derecha son 1100, recordemos que ahora se lee de derecha a izquierda, por lo tanto los 1 son numeros negativos y los 0 son numeros positivos, eso significa que si restamos los 2 00 positivos a la derecha del todo con el resto de 1 el resultado es -4

W1NS3R · 28 Mayo, 2026 22:48

Día 33 Expanciones

como ya vimos el comando $((2 + 2)) es una expanción, esto significa que bash no lee directamente el comando, si no que resuelve antes lo que esta dentro de la expanción y luego dicho resultado es que el toma
Expanciones de llaves:
- Las expanciones por llaves son muy utiles, nos permiten generar cadenas de caracteres con distintas convinaciones, ejemplo:
- echo {a,b,c}{1,2,3}
- esto nos devolveria: a1 a2 a3 b1 b2 b3 c1 c2 c3
- en esencia se podria decir que genera un producto cartesiano de los elementos separados por comas
- ejemplo de uso:
- ```
	  mkdir {grupoA,grupoB,grupoC}{01,02,03}
```
- ```
	  rmdir {grupoA,grupoB,grupoC}{01,02,03}
```
Expanciones Aritmeticas:
- Las expanciones aritmeticas, son basicamente operaciones aritmeticas de toda la vida, como ya dijimos para que bash no lea el comando directamente si no que primero resuelva una operación y luego dicho resultado sea el que nos devuelva se usa la expanción $((1 + 2)) si simplemente escribimos 1 + 1 0 ((1 + 2)) bash lo interpretara como texto simpelmente
- Ejemplo de uso:
- ```
	  echo $((1 + 2))
```
División de palabras:
La división de palabras hace justo lo que su nombre indica, para entender mejor esto pongamos un ejemplo: lista="manzana,pera,fresa" si vemos lo que hay dentro de la lista nos devolvera todos los valores juntos, las comas no serviran como separadores, seran parte del texto ejemplo:

  lista="manzanas,peras,fresas"
  printf $lista
  ~$  manzanas,peras,fresa

Para que las comas sirvan como separadores hacemos uso de una variable interna de bash llamada IFS (Internal Field Separador) esta variable solo almecena dentro un espacio o una tabulación, de esta forma si le asignamos otro signo como por ejemplo una coma esa coma funcionara como separador ejemplo:
```
  IFS=","
  ~$  printf $lista
```

Expansión de nombre de ficheros:

Este tipo de expansión hace uso de (*) ([]) (?) para tratar las palabras como patrones, ejemplo:

	  $ ls
	  fichero1 fichero11 fichero2
	   fichero3
	   LÉEME
	   script.sh
	  $ ls fichero?
	  fichero1 fichero2 fichero3
	  $ ls *[1-2]
	  fichero1 fichero11 fichero2
	  $ ls *[^1-2]
	  fichero3 LEEME script.sh
	  $ ls s*
	  script.sh

W1NS3R · 24 Junio, 2026 19:50

Día 34 Arrays

Un array (arreglo) es una estructura de datos que nos permite almacenar varios valores a los que se accede a partir de un índice
Inicialización:
- ```
	  array=(a b c)
```
- Los índice del array en bash empiezan en 0, en este ejemplo la posición 0 contiene el dato ‘a’ y la posición 1 el dato ‘b’
- nota: los array pueden tener el nombre que se quiera siempre y cuando no contenga espacios en blanco
- También podemos inicializar un array posición por posición
- ```
	  array[0]='a'
	  array[1]='b'
	  array[2]='c'
```
Eliminación:
- con el comando unset podemos eliminar el array, o elementos especificos del array
- ```
	  unset array
```
- ```
	  unset array [2]
	  echo ${array[@]}
	  a b
```
Reasignación:
- podemos reasignar haciendo uso del indice
- ```
	  array[1]='2'
	  echo ${array[@]}
	  a b 2
```
Expanciones en array:
- Las expanciones nos permiten acceder de distintas maneras a los datos del array.
- Muestra todos los datos del array:
- ```
	  echo ${array[@]}
	  a b c 
	  echo ${array[*]}
	  a b c 
```
- la diferencia entre ‘@’ o ‘*’ en medio de los corchetes es sutil pero importante, el @ trata los elementos de forma separada, ‘a’ ‘b’ ‘c’ mientras que * trata los elementos como uno solo, ‘a b c’
- Acceso individual a cada elemento:
- ```
	  echo ${array[2]}
	  c
```
- como vemos podemos acceder atravez del indice a un elemento especifico del array, en este caso el tercer elemento, recordemos que el indice empieza en 0
- Cantidad de elementos del array:
- ```
	  echo ${#array[@]}
	  3
```
- Podemos ver la cantidad de elementos que contiene el array de esa manera
- Añadir varios elementos a la vez:
- ```
	  array= (${array[@]} d e)
	  echo ${array[@]}
	  a b c d e
```
- Mostrar elementos de una posición hasta otra posición:
- ```
	  echo ${array=[@]:1:3}
	  b c d
```
- Mostrar ultimo elemento:
- ```
	  echo ${array=[@]: -1}
	  e
```
- Sustituir 1 o varios elementos iguales:
- ```
	  echo ${array=[@]/b/c}
	  a c c d e f
```

W1NS3R · 25 Junio, 2026 17:58

Día 35 Funciones y Códigos de estado

Las funciones son bloques de código que realizan determinadas acciones y pueden ser llamadas desde otras partes del código las veces que se quiera, facilitando así la ejecución de esas acciones sin tener que reescribirlas constantemente
Declaración: Existen 2 maneras de declarar una función
- se puede declarar con la palabra reservada function
- ```
	  function hola() { echo "hola mundo"; }
```
- las funciones son sensibles a los espacios, los parentesis cumplen una función meramente visual, y no funcional como ocurre en otros lenguajes, las llaves es donde se ejecutan las instrucciones de la función, recordar siempre separarlas por punto y coma y dejar un espacio al principio y al final de las llaves.
- Tambien se puede declarar sin el comando function.
- ```
	  hola() { echo "hola mundo" }
```
- Podemos ejecutar la función simplemente escribiendo su nombre
- ```
	  hola
	  hola mundo
```
Paso de parámetros: El paso de parámetros es posicional y se hace durante su llamamiento
- Ejemplo: Aquí podemos ver como pasamos el valor de una variable en este caso la “h” a “$1” recordemos que las expanciones nos permiten ver lo que hay dentro de un comando o operación como añadir dentro de un comando o operación ciertos parametros, cuando luego de eso ejecutamos la funcion le asignamos su parametro a la primer parte del “echo” y la segunda es tomada por el ““mundo”” puesto que recordemos el paso por parametros es posicional
- ```
	  h="hola"
	  hola() { echo "$1 $2"; }
	  hola $h "mundo"
```
Expanciones, parametros, variables y algo mas:
- En bash podemos definir variables de ámbito local.
- En este ejemplo muy poco intuitivo podemos analizar varias cosas, lo primero es que con punto y coma separo distintas proposiciones dentro de la funcion, lo segundo es que para poder nombrar una variable sin que bash muestre su resultado necesito de “” y por ultimo FUNCNAME el cual no es solo un comando, es un array que en pocas palabras guarda el orden en que se ejecutan las funciones, recordemos que los array tiene un indice que empieza en “0” lo que ${FUNCNAME[0]} hace es buscar en la primer posición del array que guarda las funciones en ejecución, en este caso la función “f”
- ```
	  f() { local v=2; echo "el valor de la variable \v desde la función ${FUNCNAME[0]} es: $v"; }
	  f
	  el valor de la variable \v desde la función f es: 2
	  
```
Códigos de estado:
- Los códigos de estado son numeros enteros del 0 al 255 que sirven para indicar, generalmente, si el resultado de un comando (o función) se ha ejecutado con éxito o no.
- Cuando un comando retorna un código de estado diferente de cero, significa que a ocurrido algún error de ejecución, si el código de estado retornado es cero significa que se ha ejecutado con exito
- ```
	  ls
	  Descargas  Documentos  Imágenes  Plantillas  Vídeos
	  echo $?
	  0
```
- con el comando “$?” podemos ver los códigos de estado.
- No existe un estandar sobre que códigos deben significar que tipo de errores, eso depende del desarrollador de cada scrip, pero por norma general, cualquier numero que no sea “0” sera un error
Funciones con código de estado:
- Si bien no es obligatorio crear un código de estado para las funciones, pues bash puede procesar correctamente si se ejecuto con exito o no, podemos crear nuestros propios códigos de estado con el comando return
- Ejemplo:
- ```
	  f() { return 1 }
	  f
	  echo $?
	  1
```
Paso de parametros de una función a fuera de la función:
- Aquí estamos haciendo que un valor dentro de una función se pase a una variable fuera de la función, para poder lograrlo se usa el comando de expanción seguido de unos parentesis para indicar dentro de estos el nombre de la función
- ```
	  f() { echo "parametro"; }
	  
	  v=$(f)
	  
	  echo "$v"
	  parametro
```

W1NS3R · 26 Junio, 2026 18:22

Día 36 Condicional IF ELSE

La condicional If y else es una estructura de control de flujo, compara parametros y devuelve resultados en caso de que sean verdaderos o falso

Ejemplo en pseudocodico:

	  si [condicion]
	  	entonces
	  	si no
	      entonces

Sintaxis 1 IF: Existen varias formas de escirbir la sintaxis de la condicional If en bash
- condiciones con corchetes simples: Esta es la forma portable a otras shell POXIS
- soporta tres tipos de condiciones: Condiciones basadas en cadenas de caracteres, condiciones basadas en números, condiciones basadas en ficheros
- ```
	  if [condicion]; then 
	  instrucciones... 
	  fi
```
Sintaxis Else:
- En caso de que la condición no se cumpla podemos usar else como otra opción
- ```
	  if [condicion]; then 
	  instrucciones... 
	  else 
	  instrucciones...
	  fi 
```

Sintaxis ELIF:

Si queremos operar con distintas condiciones podemos usar ELIF

	  if [condicion]; then 
	  instrucciones... 
	  elif [condicion]; then
	  instrucciones...
	  else 
	  instrucciones...
	  fi

El comando then:
- El comando then cumple una función exclusivamente sintactica, siempre va despues de las condiciones de los IF o de los ELIF, nunca de los else

Ejemplo de uso:

	  variable=1
	  if [ "$variable" -eq 2 ]; then
	      echo "es igual a 2"
	  elif [ "$variable" -eq 1 ]; then
	      echo "es igual a 1"
	  else
	      echo "no es igual a nada"
	  fi

Sintaxis 2 IF:
- condicionales con corchetes dobles: esta es una versión mejorada, pero menos compatible, para hacerla compatible es necesario el uso de #!/bin/bash al inicio del script.
- De entre las mejoras se pueden destacar: Soporte de expansiones en cadenas de caracteres y ficheros, opción e poner cadenas de caracteres entre comillas, permite combinar expresiones dentro de una misma condición.
- Ejemplo de uso:
- ```
	  variable=2
	  nombre="jose"
	  if [[ $variable -eq 1 || $variable -eq 2 ]]; then
	      echo "Es 1 o 2"
	  elif [[ $nombre == J* ]]; then
	      echo "El nombre empieza con J"
	  fi
```
- Aquí podemos ver el uso de operadores lógicos, y una expansión, el “*” que compara si el primer carácter de un carácter o una secuencia de caracteres empieza con la letra a su izquierda
Sintaxis 3 IF:
- condicionales con paréntesis simples: Este tipo de sintaxis tiene como característica crear una subshell o un entorno aislado, donde los cambios no afectan a tu script principal
- Ejemplo:
- ```
	  if (condiciones); then
	  instrucciones...
	  fi
```
Sintaxis 4 IF:
- condicionales con paréntesis dobles: Este tipo de sintaxis tiene como característica el poder hacer operaciones aritméticas con operadores similares a lenguajes como C
- Ejemplo de uso:
- ```
	  variable=1
	  if (( variable < 2 )); then
	      echo "Es menor que 2"
	  fi
	  
```
Sintaxis 5 IF:
- condicionales sin paréntesis ni corchetes: Este tipo de sintaxis sirve para evaluar el código de salida de cualquier comando, si el comando fue exitoso o retorna 0 if lo considerara verdadero, si el comando fallo o retorna cualquier otro numero del 1 al 255 if lo considera falso
- ```
	  if ./script.sh; then
	      echo "El script terminó correctamente"
	  else
	      echo "No se pudo ejecutar el script"
	  fi
```
Operadores:
Operadores Ariméticos:
- Se utilizan principalmente dentro de (())
- Comparación: ==, !=, <, >, <=, >=.
- Lógicos: && (AND), || (OR), ! (NOT).
- Asignación:=, +=, -=, *=, /=.
Operadores de Cadenas:
- Se utilizan dentro de [[ ]].
- Comparación: == (igualdad), != (desigualdad), < (menor que en orden alfabético), > (mayor que).
- Pattern Matching: == pattern (ej. [[ "jose" == j* ]]).
- Nulidad: -z (cadena vacía), -n (cadena no vacía).
Operadores de Ficheros:
- Se utilizan para verificar el estado de archivos y directorios, generalmente dentro de [[ ]] o [ ].
- Verificaciones:-e (existe), -f (es archivo regular), -d (es directorio), -r (legible), -w (escribible), -x (ejecutable).
Operadores Numéricos POXIS:
- Son el estándar de compatibilidad se usan generalmente en [] aunque bash tambien permite usarlo con (())
- -eq: Equal (Igual)
- -ne: Not Equal (No igual)
- -gt: Greater Than (Mayor que)
- -ge: Greater or Equal (Mayor o igual)
- -lt: Less Than (Menor que)
- -le: Less or Equal (Menor o igual)

W1NS3R · 4 Julio, 2026 00:36

Día 37 Condicional CASE:

La condicional case es una estructura de control de flujo, que nos permite ejecutar ciertos bloques de código dependiendo de ciertas condiciones.
Ejemplo en Pseudocodigo:

  caso: 1
  	bloque de codigo
      fin del caso 1
  caso: 2
  	bloque de codigo
      fin del caso 2
  caso: 3
  	bloque de codigo
      fin del caso 3

Sintaxis:

	  case expresion in
	  condicion1)
	  	#codigo en caso de que la exprecion sea cierta
	      ;;
	  condicion2)  
	  	#codigo en caso de que la exprecion sea cierta
	      ;;
	  condicionN)  
	  	#codigo en caso de que la exprecion sea cierta
	      ;;
	  esac

En este ejemplo declaramos la condicional con case seguido de una expresión, las expresiones son el resultado de cualquier expansión, y luego in es un separador sintáctico que opera como delimitador para luego proceder con las condiciones, las cuales evalúan si el resultado de la expansión coincide, los ;; se usan para separar las condiciones, cumple una función sintáctica, y finalmente esac que es case alrevez, y su función es declarar el fin de las condiciones

Ejemplo de uso:

	  variable=1
	  
	  case $variable in
	  1)
	  	echo "primera opción"
	      ;;
	  2)
	  	echo "segunda opción"
	      ;;
	  3)
	  	echo "tercera opción"
	      ;;
	  esac

El comodín (*):

Este es un comodín que permite analizar no solo cadena de caracteres si no tambien partes de esa cadena, y ademas tabulaciones, espacios vacios e incluso ninguna acción
Ejemplo:

	  exprecion="archivo.txt"
	  
	  case $exprecion in
	  *.txt)
	  	echo "es un archivo de texto"
	      ;;
	  *.mp3)
	  	echo "es un archivo de audio"
	      ;;
	  *.mp4)
	  	echo "es un archivo de video"
	      ;;
	  esac

tambien podemos usarlo como sufijo:

	  exprecion="1-Archivo"
	  
	  case $exprecion in
	  1-*)
	  	echo "es el primer archivo"
	      ;;
	  2-*)
	  	echo "es el segundo arhivo"
	      ;;
	  3-*)
	  	echo "es el tercer archivo"
	      ;;
	  esac

de esta forma podemos analizar los primeros caracteres de una expansión.
Otra forma de usarlo es cuando ninguna opción es la correcta o directamente no se ejecuto ninguna opción:

	  exprecion=""
	  
	  case $exprecion in
	  1*)
	  	echo "primera opcion"
	      ;;
	  2*)
	  	echo "segunda opcion"
	      ;;
	  *)
	  	echo "no se ejecuto ninguna opcion valida"
	      ;;
	  esac

Tambien podemos usar varias condiciones para un mismo resultado

	  exprecion="A"
	  
	  case $exprecion in
	  A|B|C*)
	  	echo "Es una de las opciones A, B, C"
	      ;;
	  1|2|3*)
	  	echo "es una de las opciones 1, 2, 3"
	      ;;
	  *)
	  	echo "no se ejecuto ninguna opcion valida"
	      ;;
	  esac

W1NS3R · 7 Julio, 2026 16:15

Día 38 Condicional FOR

La condicional for es una estructura de control de flujo que me permite iterar sobre elementos una cantidad determinada de veces, a diferencia de otros bucles for necesita explicitamente determinar el numero de iteraciones
Sintaxis:
- ```
	  for elemento in datos; do
	  #codigo a ejecutar
	  done
```
- Se declara con for seguido de la variable a utilizar, luego in opera como separador sintactico, despues los datos o elementos que seran asignados a la variable de manera secuencial, finalmente do operando como otro separdor sintactico, el codigo interno del ciclo que se ejecutara en cada interación, y finalmente se cierra con done

Ejemplo de uso:

	  for i in 1 2 3; do
	  	echo $i
	  done

Iterar sobre un rango de números:

	  for i in {0..10}; do
	  	echo $i
	  done

Condicional:

	  for ((i=0; i<=10; i++)) do
	  	echo $i
	  done

W1NS3R · 9 Julio, 2026 05:53

Día 39 Bucle While y Until

Estos son estructuras de control de flujo que nos permiten ejecutar condigo en bucle mientras una condición sea verdadera

Sintaxis de while:

	  while [[ condicion ]]; do
	  #codigo a ejecutar
	  done

Ejemplo de uso:

	  while [[ i -lt 10 ]]; do
	  echo $((i++)) 
	  done

Sintaxis de until:
- la diferencia entre while y until es que until opera cuando la condición es falsa
- ```
	  until [[ condicion ]]; do
	  #codigo a ejecutar
	  done
```

Ejemplo de uso:

	  until [[ i -lt 1 ]]; do
	  echo $((--i))
	  done

W1NS3R · 10 Julio, 2026 16:30

Día 40 Break y Continue

Break y continue son declaraciones de control de flujo, pueden ser utilizadas en los bucles forwhile y until
Break:
- En este ejemplo break termina el bucle en caso de que la condicional “i es igual a 3” sea verdadera, lo que hace que el bucle termine
- ```
	  for i in 1 2 3 4 5; do
	  if [ $i -eq 3 ]; then
	  break
	  fi
	  echo $i
	  done
	  #resultado
	  1
	  2
```

Continue:

En este ejemplo vemos que si la condición se cumple continue salta esa iteración pero no sale del ciclo

	  for i in 1 2 3 4 5; do
	  if [ $i -eq 3 ]; then
	  continue
	  fi
	  echo $i
	  done
	  #resultado
	  1
	  2
	  4
	  5

W1NS3R · 12 Julio, 2026 13:54

Día 41 Depuración de Script

Depurar significa limpiar o corregir, en bash tenemos múltiples opciones para analizar el código escrito

Ejemplo de Script:

	  #!/bin/bash
	  
	  echo "prueba de depuracion"
	  echo "hola mundo"
	  echo "fin"

si ejecutamos el script de esta forma:
- ```
	  bash -x script.sh
```

Nos devolvera algo como esto:

	  + echo 'prueba de depuracion'
	  prueba de depuracion
	  + echo 'hola mundo'
	  hola mundo
	  + echo fin
	  fin

Básicamente nos muestra cada comando del script

Tambien podemos hacer que nos muestre comandos especificos dentro del script:

	  #!/bin/bash
	  
	  echo "prueba de depuracion"
	  set -x
	  echo "hola mundo"
	  echo "fin"

De esta manera si ejecutamos el script nos devolvera algo como:

	  ./script.sh
	  
	  prueba de depuracion
	  + echo 'hola mundo'
	  hola mundo
	  + echo fin
	  fin

W1NS3R · 14 Julio, 2026 00:00

Día 42 El comando CAT

El comando cat es un comando que me permite concatenar la salida de los ficheros

Ejemplo:

Suponiendo que hay 2 ficheros .txt llamados a y b

	  cat a.txt b.txt
	  texto dentro de a
	  texto dentro de b

Banderas (Opciones):
>:
- Esta opción nos permite sobrescribir el contenido
- ```
	  cat a.txt b.txt > c.txt
```
- Ahora el contenido de a.txt y b.txt estara dentro de c.txt
>>:
- Esta opción nos permite añadir el contenido al final del fichero sin sobrescribir
- ```
	  cat a.txt b.txt >> c.txt
```
- La principal diferencia es que en vez de eliminar el contenido dentro de c.txt simplemente añade el nuevo contenido al final
-n:
- Esta opción nos muestra el numero de lineas en el fichero
- ```
	  cat -n a.txt
	  1 hola
	  2 mundo
```

-b:

Esta opción nos muestra el numero de lineas no vacias

	  cat -n a.txt
	  1 hola
	  2 mundo
	  
	  
	  #lineas vacias

-t:

Esta opción nos muestra las tabulaciones con la notación ^I

	  cat -t a.txt
	  hola
	  mundo
	  ^I  #tabulacion dentro de a.txt

-s:
- Esta opción suprime las lineas vacías dentro del fichero en 1 sola linea
- Suponiendo que hay varias lineas vacias dentro de a.txt
- ```
	  cat -s a.txt
	  hola
	  mundo
	  	#solo 1 linea vacia
```