✨ Curso de Bash Script para Principiantes 🚀

¡El mundo sería un lugar mejor si todos pudieran hacer #!/bin/bash sin miedo! 💻✨ #CodeLife #BashScript #GeekMode

Tabla de Contenido

✨ Curso de Bash Script para Principiantes 🚀

Introducción a Bash Script.

Bash (Bourne Again Shell) es un intérprete de comandos y lenguaje de scripting ampliamente utilizado en sistemas Unix y Linux.

Aquí tienes una introducción básica:

Creación de un script:
- Crea un archivo con extensión .sh (por ejemplo, miscript.sh)
- La primera línea debe ser el "shebang": #!/bin/bash
Estructura básica:

#!/bin/bash

# Esto es un comentario
echo "Hola, mundo!"

Variables:

nombre="Juan"
echo "Hola, $nombre"

Input del usuario:

echo "¿Cómo te llamas?"
read nombre
echo "Hola, $nombre"

Condicionales:

if [ "$nombre" = "Juan" ]; then
    echo "Hola, Juan!"
else
    echo "Hola, extraño"
fi

Bucles:

for i in {1..5}
do
   echo "Número $i"
done

Funciones:

saludar() {
    echo "Hola, $1!"
}

saludar "María"

Ejecución de comandos:

fecha=$(date)
echo "La fecha actual es: $fecha"

Para ejecutar tu script:

Dale permisos de ejecución: chmod +x miscript.sh
Ejecútalo: ./miscript.sh

Estos son conceptos básicos para empezar. Bash es muy potente y tiene muchas más características y funcionalidades.

Qué es un Bash Script

Un bash script es un archivo de texto que contiene una serie de comandos que se ejecutan en el intérprete de comandos Bash (Bourne Again SHell) en sistemas Unix y Linux. Estos scripts permiten automatizar tareas, realizar operaciones complejas y ejecutar múltiples comandos en secuencia.

Características principales de los bash scripts:

Extensión de archivo: Suelen tener la extensión ".sh", aunque no es obligatorio.
Shebang: Comienzan con una línea que indica el intérprete a usar, típicamente "#!/bin/bash".
Ejecución de comandos: Pueden ejecutar cualquier comando disponible en el sistema.
Variables: Permiten definir y usar variables para almacenar datos.
Estructuras de control: Incluyen condicionales (if-else), bucles (for, while) y funciones.
Argumentos: Pueden recibir y procesar argumentos de línea de comandos.
Redireccionamiento: Permiten manipular la entrada y salida estándar.

Los bash scripts son muy útiles para administradores de sistemas, desarrolladores y usuarios avanzados que necesitan automatizar tareas repetitivas o crear flujos de trabajo personalizados en entornos Unix/Linux.

Para qué sirve

Los bash scripts sirven para múltiples propósitos, principalmente para automatizar tareas y simplificar procesos en sistemas Unix y Linux. Aquí hay algunos usos comunes:

Automatización de tareas repetitivas: Por ejemplo, realizar copias de seguridad diarias o limpiar archivos temporales periódicamente.
Instalación y configuración de software: Facilitar la instalación de programas y sus dependencias, así como configurar el entorno del sistema.
Administración del sistema: Monitorear recursos, gestionar usuarios, actualizar el sistema operativo, etc.
Procesamiento de datos: Manipular archivos de texto, realizar conversiones de formato, o procesar grandes cantidades de datos.
Tareas de red: Automatizar pruebas de conectividad, configurar firewalls, o gestionar servicios de red.
Desarrollo de software: Compilar código, ejecutar pruebas automáticas, o gestionar el despliegue de aplicaciones.
Personalización del entorno: Crear alias de comandos, configurar el entorno de trabajo, o inicializar aplicaciones al inicio del sistema.
Análisis de logs: Extraer información relevante de archivos de registro del sistema o aplicaciones.
Integración de herramientas: Combinar funcionalidades de diferentes programas para crear flujos de trabajo más complejos.
Automatización de informes: Generar informes periódicos sobre el estado del sistema, uso de recursos, o actividad de usuarios.

En resumen, los bash scripts son una herramienta versátil que permite a los usuarios ahorrar tiempo, reducir errores y realizar tareas complejas de manera eficiente en sistemas Unix y Linux.

Hola Mundo

Cómo crear un script "Hola Mundo" en Bash y cómo funciona.

Primero, aquí está el código para un script "Hola Mundo" en Bash:

#!/bin/bash
echo "Hola Mundo"

Ahora, vamos a desglosar este script:

La primera línea #!/bin/bash es lo que se llama "shebang". Le dice al sistema que este script debe ser ejecutado por el intérprete Bash. El #! es lo que identifica esta línea como shebang, y /bin/bash es la ruta al intérprete de Bash.
La segunda línea echo "Hola Mundo" es el comando que realmente imprime el texto en la pantalla. echo es un comando en Bash que se utiliza para mostrar texto en la salida estándar (normalmente, la terminal).

Para usar este script:

Cree un nuevo archivo con un editor de texto, por ejemplo hola_mundo.sh.
Copie el código anterior en este archivo y guárdelo.
Haga el archivo ejecutable con el comando: chmod +x hola_mundo.sh
Ejecute el script con: ./hola_mundo.sh

Cuando lo ejecute, verá "Hola Mundo" impreso en su terminal.

Este es un ejemplo muy simple, pero ilustra la estructura básica de un script de Bash. A partir de aquí, puede agregar más comandos, usar variables, estructuras de control como bucles y condicionales, y mucho más para crear scripts más complejos y útiles.

Guardar Salida

Guardar la salida en un bash script es una técnica útil para capturar el resultado de comandos o procesos para su posterior uso o análisis. Hay varias formas de hacerlo:

Redirección a un archivo: La forma más básica es usar el operador de redirección > o >>.
```
#!/bin/bash
echo "Hola Mundo" > salida.txt
```
Esto guarda "Hola Mundo" en el archivo salida.txt. El > sobrescribe el archivo si existe, mientras que >> añade al final del archivo.
Capturar en una variable: Puede guardar la salida de un comando en una variable usando la sintaxis de sustitución de comandos.
```
#!/bin/bash
resultado=$(echo "Hola Mundo")
echo $resultado
```
Tee: El comando tee permite mostrar la salida en pantalla y guardarla en un archivo simultáneamente.
```
#!/bin/bash
echo "Hola Mundo" | tee salida.txt
```
Redirección de error estándar: Para guardar los errores, use 2> para redirigir solo errores, o &> para redirigir tanto la salida estándar como los errores.
```
#!/bin/bash
comando_que_puede_fallar 2> errores.log
```
Here documents: Útiles para crear archivos con múltiples líneas de contenido.
```
#!/bin/bash
cat << EOF > archivo.txt
Línea 1
Línea 2
Línea 3
EOF
```

Cada método tiene sus usos específicos dependiendo de lo que necesite hacer con la salida. La redirección simple es útil para logs, la captura en variables es buena para procesamiento posterior en el script, y tee es excelente cuando necesita ver la salida y guardarla al mismo tiempo.

Comentarios

Los comentarios en bash scripts son texto que se incluye en el código pero que no se ejecuta. Son útiles para explicar el propósito del código, dejar notas para otros programadores (o para uno mismo en el futuro), o para deshabilitar temporalmente partes del script. Hay dos tipos principales de comentarios en bash:

Comentarios de una línea: Se crean usando el símbolo #. Todo lo que sigue a este símbolo en la misma línea se considera un comentario.
```
#!/bin/bash

# Esto es un comentario de una línea
echo "Hola Mundo"  # Este es un comentario al final de una línea de código
```
Comentarios multilínea: Aunque bash no tiene un formato oficial para comentarios multilínea, hay algunas técnicas comunes:

a) Usar # en múltiples líneas:
```
# Este es un comentario
# que abarca
# varias líneas
```
b) Usar HERE document con un comando nulo (:):
```
: <<'END_COMMENT'
Este es un comentario
de varias líneas
que no se ejecutará
END_COMMENT
```

Usos comunes de los comentarios:

Documentar el script:

#!/bin/bash

# Nombre: mi_script.sh
# Autor: Juan Pérez
# Fecha: 2024-07-26
# Descripción: Este script realiza una tarea específica...

Explicar secciones complejas:

# La siguiente función calcula el factorial de un número
factorial() {
    # Código de la función...
}

Deshabilitar temporalmente código:

# echo "Esta línea no se ejecutará"
echo "Esta línea sí se ejecutará"

Dejar notas o TODOs:

# TODO: Optimizar esta función para mejor rendimiento

Los comentarios son una parte crucial de la escritura de buenos scripts, ya que mejoran la legibilidad y el mantenimiento del código. Es una buena práctica comentar el código, especialmente en secciones complejas o no obvias.

Delimitador Cat

El delimitador Cat en Bash script se refiere al uso del comando cat junto con un "here document" (también conocido como "heredoc"). Esta técnica permite crear bloques de texto multilínea dentro de un script. El término "delimitador" se refiere a la palabra que se usa para marcar el inicio y el final de este bloque de texto.

Aquí está cómo funciona:

Sintaxis básica:
```
cat << DELIMITADOR
Texto
multilínea
aquí
DELIMITADOR
```
Donde DELIMITADOR puede ser cualquier palabra que elijas (comúnmente se usa EOF, que significa "End Of File").

Ejemplo práctico:

#!/bin/bash

cat << EOF > archivo.txt
Esta es la primera línea.
Esta es la segunda línea.
Y esta es la tercera línea.
EOF

Este script creará un archivo llamado archivo.txt con el contenido especificado.

Usos comunes:
- Crear archivos de configuración
- Generar scripts o código dentro de un script
- Mostrar mensajes largos o instrucciones
Variaciones:
- <<- permite usar tabulaciones para indentar el heredoc, que luego se eliminan
- <<'DELIMITADOR' (con comillas) evita la expansión de variables dentro del heredoc

Ejemplo con variables:

#!/bin/bash
nombre="Juan"
cat << EOF
Hola, $nombre!
Bienvenido a este script.
EOF

Esto mostrará el texto con la variable $nombre expandida.

Esta técnica es muy útil cuando necesitas incluir grandes bloques de texto en tu script, especialmente si ese texto contiene caracteres especiales o múltiples líneas que serían difíciles de manejar con simples comandos echo.

Read

El comando read en Bash script se utiliza para capturar la entrada del usuario o leer líneas de un archivo. Es una herramienta muy útil para hacer scripts interactivos o procesar datos línea por línea. Aquí te explico sus principales usos y características:

Sintaxis básica:
```
read variable
```
Esto lee una línea de entrada y la almacena en la variable especificada.
Leer múltiples variables:
```
read var1 var2 var3
```
Esto lee una línea y divide la entrada en palabras, asignando cada palabra a una variable.
Usar un prompt:
```
read -p "Ingrese su nombre: " nombre
```
El flag -p permite mostrar un prompt antes de esperar la entrada.
Leer con tiempo límite:
```
read -t 5 respuesta
```
El flag -t establece un tiempo límite (en segundos) para la entrada.
Leer sin mostrar la entrada (útil para contraseñas):
```
read -s password
```
El flag -s oculta la entrada del usuario.
Leer un número específico de caracteres:
```
read -n 1 respuesta
```
El flag -n limita la entrada a un número específico de caracteres.

Leer desde un archivo:

while read linea; do
    echo "$linea"
done < archivo.txt

Esto lee el archivo línea por línea.

Usar un delimitador personalizado:
```
IFS=':' read -r usuario pass uid gid info home shell <<< "$linea"
```
Esto divide la entrada usando ':' como delimitador.

Ejemplos prácticos:

Script interactivo simple:

#!/bin/bash
read -p "¿Cuál es tu nombre? " nombre
echo "Hola, $nombre!"

Leer una contraseña:

#!/bin/bash
read -sp "Ingresa tu contraseña: " pass
echo -e "\nLa contraseña ingresada es: $pass"

Leer y procesar un archivo CSV:

#!/bin/bash
while IFS=',' read -r nombre edad ciudad; do
    echo "Nombre: $nombre, Edad: $edad, Ciudad: $ciudad"
done < datos.csv

El comando read es muy versátil y es una herramienta fundamental para crear scripts interactivos y procesar datos en Bash.

Condicionales

Los condicionales en Bash script permiten ejecutar diferentes bloques de código basados en condiciones específicas. Los principales tipos de estructuras condicionales en Bash son:

if-else: La forma más básica de condicional.

if [ condición ]; then
    # código si la condición es verdadera
else
    # código si la condición es falsa
fi

Ejemplo:

if [ "$edad" -ge 18 ]; then
    echo "Eres mayor de edad"
else
    echo "Eres menor de edad"
fi

if-elif-else: Para múltiples condiciones.

if [ condición1 ]; then
    # código si condición1 es verdadera
elif [ condición2 ]; then
    # código si condición2 es verdadera
else
    # código si ninguna condición es verdadera
fi

case: Útil para comparar una variable contra múltiples valores.

case $variable in
    patrón1)
        # código para patrón1
        ;;
    patrón2)
        # código para patrón2
        ;;
    *)
        # código por defecto
        ;;
esac

Operadores de comparación:
- Para números: -eq (igual), -ne (no igual), -lt (menor que), -le (menor o igual), -gt (mayor que), -ge (mayor o igual)
- Para cadenas: = (igual), != (no igual), -z (cadena vacía), -n (cadena no vacía)
- Para archivos: -e (existe), -f (archivo regular), -d (directorio), -r (legible), -w (escribible), -x (ejecutable)
Operadores lógicos:
- && (AND lógico)
- || (OR lógico)
- ! (NOT lógico)

Ejemplos prácticos:

Verificar si un archivo existe:

if [ -f "archivo.txt" ]; then
    echo "El archivo existe"
else
    echo "El archivo no existe"
fi

Comparar números:

read -p "Ingresa un número: " num
if [ "$num" -gt 0 ]; then
    echo "Número positivo"
elif [ "$num" -lt 0 ]; then
    echo "Número negativo"
else
    echo "Cero"
fi

Usar case para un menú:

echo "Selecciona una opción:"
echo "1) Opción 1"
echo "2) Opción 2"
echo "3) Salir"
read opcion
case $opcion in
    1) echo "Seleccionaste la Opción 1" ;;
    2) echo "Seleccionaste la Opción 2" ;;
    3) echo "Saliendo..." ; exit ;;
    *) echo "Opción inválida" ;;
esac

Los condicionales son fundamentales en la programación de scripts Bash, permitiendo crear lógica de decisión y flujos de control complejos.

Case

En Bash scripting, el comando case se utiliza para realizar una comparación de una variable o una expresión con múltiples patrones y ejecutar comandos diferentes según el patrón que coincida. Es una estructura condicional similar a if, pero es más adecuada cuando hay múltiples condiciones posibles. La sintaxis básica de case es la siguiente:

case expresión in
  patrón1)
    # comandos
    ;;
  patrón2)
    # comandos
    ;;
  ...
  patrónN)
    # comandos
    ;;
  *)
    # comandos para cualquier otro caso
    ;;
esac

A continuación, te explico cada parte de esta estructura:

expresión: Es el valor que se va a comparar contra los diferentes patrones. Puede ser una variable o cualquier expresión válida en Bash.
patrón1, patrón2, ..., patrónN: Son los diferentes patrones que se van a comparar con la expresión. Si la expresión coincide con un patrón, se ejecutan los comandos asociados a ese patrón.
comandos: Son los comandos que se ejecutan si la expresión coincide con el patrón correspondiente.
;;: Indica el final de los comandos para ese patrón.
*): Este es el caso por defecto que se ejecuta si la expresión no coincide con ninguno de los patrones especificados. Es opcional.

Aquí tienes un ejemplo práctico:

#!/bin/bash

echo "Ingrese una opción (1-3):"
read opcion

case $opcion in
  1)
    echo "Ha seleccionado la opción 1."
    ;;
  2)
    echo "Ha seleccionado la opción 2."
    ;;
  3)
    echo "Ha seleccionado la opción 3."
    ;;
  *)
    echo "Opción no válida. Por favor, seleccione una opción entre 1 y 3."
    ;;
esac

En este script:

Se pide al usuario que ingrese una opción.
La opción ingresada se almacena en la variable opcion.
El comando case compara el valor de opcion con los patrones 1, 2, 3 y ejecuta los comandos correspondientes.
Si la opción no es válida (no es 1, 2 o 3), se ejecutan los comandos dentro del caso *, que es el caso por defecto.

El uso de case puede simplificar la lógica del script cuando se necesita manejar múltiples condiciones de manera clara y estructurada.

Loops

En Bash scripting, los bucles (loops) son estructuras de control que permiten ejecutar repetidamente un conjunto de comandos hasta que se cumpla una condición específica. Bash admite varios tipos de bucles: for, while, y until. Aquí te explico cada uno con ejemplos:

1. Bucle `for`

El bucle for se usa para iterar sobre una lista de elementos, como un rango de números, una lista de palabras, o el contenido de un directorio.

Sintaxis:

for variable in lista
do
  comandos
done

Ejemplo:

#!/bin/bash

# Iterar sobre una lista de palabras
for color in rojo verde azul
do
  echo "Color: $color"
done

# Iterar sobre un rango de números
for i in {1..5}
do
  echo "Número: $i"
done

2. Bucle `while`

El bucle while ejecuta los comandos mientras la condición especificada sea verdadera.

Sintaxis:

while condición
do
  comandos
done

Ejemplo:

#!/bin/bash

# Inicializar una variable
contador=1

# Mientras el contador sea menor o igual a 5
while [ $contador -le 5 ]
do
  echo "Contador: $contador"
  contador=$((contador + 1))
done

3. Bucle `until`

El bucle until es similar al while, pero ejecuta los comandos mientras la condición sea falsa.

Sintaxis:

until condición
do
  comandos
done

Ejemplo:

#!/bin/bash

# Inicializar una variable
contador=1

# Hasta que el contador sea mayor que 5
until [ $contador -gt 5 ]
do
  echo "Contador: $contador"
  contador=$((contador + 1))
done

4. Bucle `for` con `C`-like syntax

También se puede utilizar una sintaxis similar a los bucles for en C, donde se inicializa una variable, se especifica una condición, y se define un incremento.

Sintaxis:

for (( inicialización; condición; incremento ))
do
  comandos
done

Ejemplo:

#!/bin/bash

# Iterar de 1 a 5 usando la sintaxis de C
for (( i=1; i<=5; i++ ))
do
  echo "Número: $i"
done

5. Bucle `for` para iterar sobre archivos

El bucle for también puede utilizarse para iterar sobre archivos en un directorio.

Ejemplo:

#!/bin/bash

# Iterar sobre todos los archivos .txt en el directorio actual
for archivo in *.txt
do
  echo "Archivo encontrado: $archivo"
done

Uso de `break` y `continue`

break: Sale del bucle inmediatamente.
continue: Salta el resto del cuerpo del bucle y continúa con la siguiente iteración.

Ejemplo con `break` y `continue`:

#!/bin/bash

for i in {1..10}
do
  if [ $i -eq 3 ]; then
    continue  # Saltar la iteración cuando i es 3
  fi
  if [ $i -eq 8 ]; then
    break  # Salir del bucle cuando i es 8
  fi
  echo "Número: $i"
done

Estos son los conceptos básicos de los bucles en Bash scripting, que te permiten realizar operaciones repetitivas de manera eficiente y controlada.

Break y Continue

En Bash scripting, break y continue son comandos utilizados para controlar el flujo de ejecución de los bucles (for, while, until). Estos comandos permiten modificar el comportamiento de los bucles basados en condiciones específicas.

1. `break`

El comando break se utiliza para salir de un bucle inmediatamente, independientemente de la condición del bucle. Es útil cuando deseas terminar el bucle en respuesta a una condición particular.

Ejemplo con `break`:

#!/bin/bash

for i in {1..10}
do
  if [ $i -eq 5 ]; then
    break  # Sale del bucle cuando i es igual a 5
  fi
  echo "Número: $i"
done

echo "Bucle terminado debido a 'break'."

En este ejemplo, el bucle se interrumpirá cuando i sea igual a 5, y no se ejecutarán más iteraciones.

2. `continue`

El comando continue se utiliza para saltar la iteración actual de un bucle y pasar a la siguiente iteración. Es útil cuando deseas omitir ciertas iteraciones basadas en una condición.

Ejemplo con `continue`:

#!/bin/bash

for i in {1..10}
do
  if [ $i -eq 5 ]; then
    continue  # Omite la iteración cuando i es igual a 5
  fi
  echo "Número: $i"
done

echo "Bucle completado con 'continue'."

En este ejemplo, cuando i es igual a 5, el comando continue hace que se omita el resto de los comandos en esa iteración y se pase a la siguiente iteración del bucle.

Uso de `break` y `continue` en bucles anidados

Ambos comandos también se pueden utilizar en bucles anidados. Es posible especificar cuántos niveles de bucles deseas interrumpir o continuar utilizando un argumento numérico.

Ejemplo de `break` en bucles anidados:

#!/bin/bash

for i in {1..3}
do
  for j in {1..3}
  do
    if [ $j -eq 2 ]; then
      break  # Sale del bucle interno cuando j es igual a 2
    fi
    echo "i=$i, j=$j"
  done
done

echo "Bucles anidados terminados debido a 'break'."

Ejemplo de `continue` en bucles anidados:

#!/bin/bash

for i in {1..3}
do
  for j in {1..3}
  do
    if [ $j -eq 2 ]; then
      continue  # Omite la iteración actual del bucle interno cuando j es igual a 2
    fi
    echo "i=$i, j=$j"
  done
done

echo "Bucles anidados completados con 'continue'."

Estos ejemplos muestran cómo break y continue pueden influir en el flujo de ejecución de bucles, proporcionando una manera flexible de controlar cuándo salir o omitir iteraciones específicas basadas en condiciones dinámicas.

Argumentos en Bash Script

En Bash scripting, los argumentos son valores que se pasan a un script cuando se ejecuta desde la línea de comandos. Los argumentos permiten que el script reciba y use datos proporcionados por el usuario u otro programa, haciéndolo más flexible y reutilizable. Aquí te explico cómo funcionan los argumentos en Bash scripts y cómo utilizarlos.

1. Acceso a los Argumentos

Los argumentos pasados a un script se pueden acceder usando variables especiales:

$0: El nombre del script.
$1, $2, $3, etc.: Los primeros, segundos, terceros, etc., argumentos.
$#: El número de argumentos pasados al script.
$@: Todos los argumentos pasados al script como una lista.
$*: Todos los argumentos pasados al script como una sola cadena.
"$@": Todos los argumentos pasados al script como una lista, cada uno entre comillas.
"$*": Todos los argumentos pasados al script como una sola cadena entre comillas.

2. Ejemplo de Uso de Argumentos

Supongamos que tenemos un script llamado mi_script.sh y queremos pasarle dos argumentos.

Contenido de `mi_script.sh`:

#!/bin/bash

echo "Nombre del script: $0"
echo "Primer argumento: $1"
echo "Segundo argumento: $2"
echo "Número de argumentos: $#"

echo "Todos los argumentos (separados): $@"
echo "Todos los argumentos (cadena única): $*"

Ejecución del script:

$ ./mi_script.sh argumento1 argumento2

Salida del script:

Nombre del script: ./mi_script.sh
Primer argumento: argumento1
Segundo argumento: argumento2
Número de argumentos: 2
Todos los argumentos (separados): argumento1 argumento2
Todos los argumentos (cadena única): argumento1 argumento2

3. Procesamiento de Argumentos

A menudo, es útil procesar argumentos en un bucle para manejar un número variable de argumentos o realizar operaciones específicas basadas en los valores de los argumentos.

Ejemplo de procesamiento de argumentos:

#!/bin/bash

# Verificar si hay al menos un argumento
if [ $# -lt 1 ]; then
  echo "Uso: $0 arg1 [arg2 ... argN]"
  exit 1
fi

# Procesar cada argumento
for arg in "$@"
do
  echo "Argumento: $arg"
done

4. Uso de `shift`

El comando shift se utiliza para desplazar los argumentos hacia la izquierda. Esto es útil cuando deseas procesar un argumento a la vez y luego pasar al siguiente.

Ejemplo de uso de `shift`:

#!/bin/bash

# Verificar si hay al menos un argumento
if [ $# -lt 1 ]; then
  echo "Uso: $0 arg1 [arg2 ... argN]"
  exit 1
fi

# Procesar cada argumento usando shift
while [ $# -gt 0 ]
do
  echo "Argumento: $1"
  shift
done

5. Argumentos de Opción

Los scripts Bash a menudo utilizan argumentos de opción (como -a o --long-option). Estos se pueden manejar de manera eficiente con el comando getopts.

Ejemplo de uso de `getopts`:

#!/bin/bash

while getopts ":a:b:" opt; do
  case $opt in
    a)
      echo "Opción -a con valor: $OPTARG"
      ;;
    b)
      echo "Opción -b con valor: $OPTARG"
      ;;
    \?)
      echo "Opción inválida: -$OPTARG"
      ;;
    :)
      echo "La opción -$OPTARG requiere un argumento."
      ;;
  esac
done

Ejecución del script:

$ ./mi_script.sh -a valorA -b valorB

Salida del script:

Opción -a con valor: valorA
Opción -b con valor: valorB

Estos conceptos básicos sobre el manejo de argumentos en Bash scripts te permitirán crear scripts más flexibles y poderosos, que puedan recibir y procesar información desde la línea de comandos de manera efectiva.

Stdin

STDIN (Standard Input) en Bash script se refiere a la entrada estándar, que es uno de los tres flujos de datos estándar en sistemas Unix/Linux. Es el canal por el cual los datos entran a un programa. Aquí te explico los aspectos clave:

Concepto básico:
- STDIN es el flujo de entrada predeterminado.
- Normalmente está conectado al teclado cuando se ejecuta un script interactivamente.
- Tiene el descriptor de archivo 0.
Uso común:
- Los programas leen datos de STDIN cuando no se especifica otra fuente de entrada.
- Muchos comandos de Unix/Linux están diseñados para leer de STDIN si no se les proporciona un archivo de entrada.
Redirección de STDIN: Se puede redirigir STDIN para que lea de un archivo en lugar del teclado:
```
comando < archivo.txt
```
Pipes (tuberías): STDIN puede recibir datos de otro comando a través de pipes:
```
comando1 | comando2
```
Aquí, la salida de comando1 se convierte en la entrada (STDIN) de comando2.
Here documents: Otra forma de proporcionar entrada a un comando:
```
cat << EOF
línea1
línea2
EOF
```
Lectura de STDIN en scripts:
- El comando read lee de STDIN por defecto:
```
read variable
```
- Puedes leer línea por línea de STDIN en un bucle:
```
while read linea; do
    echo "Leído: $linea"
done
```

Ejemplo práctico - procesamiento de texto:

#!/bin/bash

# Este script lee líneas de STDIN y las procesa
while read linea; do
    echo "Línea procesada: ${linea^^}"  # Convierte a mayúsculas
done

Puedes usar este script así:

echo "hola mundo" | ./script.sh

O:

./script.sh < archivo.txt

Verificar si hay datos en STDIN:

if [ -t 0 ]; then
    echo "No hay datos en STDIN"
else
    echo "Hay datos disponibles en STDIN"
fi

Uso con comandos que esperan STDIN: Muchos comandos como grep, sort, awk pueden leer de STDIN si no se les proporciona un archivo:
```
echo "línea1\nlínea2\nlínea3" | sort
```

STDIN es una parte fundamental de la filosofía de Unix de crear programas que puedan trabajar juntos, permitiendo que la salida de un programa sea la entrada de otro. Esto facilita la creación de scripts potentes y flexibles en Bash.

sterr y stdout

STDERR (Standard Error) y STDOUT (Standard Output) son dos de los tres flujos estándar en sistemas Unix/Linux, junto con STDIN. Estos son fundamentales en la programación de bash scripts para manejar la salida de los comandos y programas. Aquí te explico ambos:

STDOUT (Standard Output):

Concepto:
- Es el flujo de salida principal para los procesos.
- Tiene el descriptor de archivo 1.
Uso:
- Por defecto, la salida normal de los comandos va a STDOUT.
- Normalmente se muestra en la terminal.

Redirección:

Se puede redirigir usando > o >>:

echo "Hola" > archivo.txt  # Sobrescribe
echo "Mundo" >> archivo.txt  # Añade al final

STDERR (Standard Error):

Concepto:
- Es el flujo para mensajes de error y diagnóstico.
- Tiene el descriptor de archivo 2.
Uso:
- Los mensajes de error se envían a STDERR.
- Por defecto, también se muestra en la terminal.
Redirección:
- Se redirige usando 2> o 2>>:
```
comando_que_puede_fallar 2> errores.log
```

Diferencias y usos combinados:

Separación de salidas:
- Permite distinguir entre salida normal y errores.
- Útil para logging y depuración.
Redirección conjunta:
- Redirigir ambos a un archivo:
```
comando > salida_y_errores.log 2>&1
```
- Redirigir a archivos separados:
```
comando > salida.log 2> errores.log
```
Pipes y redirección:
- Solo STDOUT pasa por defecto en un pipe:
```
comando | grep "patrón"  # Solo procesa STDOUT
```
- Para incluir STDERR en un pipe:
```
comando 2>&1 | grep "patrón"
```
Supresión de salidas:
- Descartar STDOUT: comando > /dev/null
- Descartar STDERR: comando 2> /dev/null
- Descartar ambos: comando > /dev/null 2>&1

En scripts:

#!/bin/bash

echo "Mensaje normal" >&1  # Explícitamente a STDOUT
echo "Mensaje de error" >&2  # Explícitamente a STDERR

Capturar en variables:

salida=$(comando)  # Captura solo STDOUT
salida_err=$(comando 2>&1)  # Captura STDOUT y STDERR

Uso con tee:

Para ver y guardar la salida simultáneamente:

comando | tee salida.log  # Solo STDOUT
comando 2>&1 | tee salida_completa.log  # STDOUT y STDERR

Entender y manejar STDOUT y STDERR es crucial para crear scripts robustos, gestionar errores eficazmente y controlar la salida de los programas. Permite una mejor organización de la información y facilita la depuración y el logging en scripts bash.

Pipes

Los pipes (tuberías) en Bash script son una característica poderosa que permite conectar la salida de un comando directamente a la entrada de otro. Esto facilita la creación de flujos de procesamiento complejos combinando comandos simples. Aquí te explico los aspectos clave de los pipes:

Concepto básico:
- Un pipe se representa con el símbolo |.
- Conecta el STDOUT (salida estándar) de un comando al STDIN (entrada estándar) del siguiente.
Sintaxis:
```
comando1 | comando2
```
La salida de comando1 se convierte en la entrada de comando2.
Múltiples pipes: Se pueden encadenar varios comandos:
```
comando1 | comando2 | comando3
```
Usos comunes:

a) Filtrar salida:
```
ls -l | grep ".txt"
```
Lista archivos y filtra solo los que tienen extensión .txt.

b) Contar líneas/palabras:
```
cat archivo.txt | wc -l
```
Cuenta las líneas en archivo.txt.

c) Ordenar y unificar:
```
sort archivo.txt | uniq
```
Ordena las líneas y elimina duplicados.
Pipes con comandos complejos:
```
find . -type f | xargs grep "patrón"
```
Busca "patrón" en todos los archivos del directorio actual y subdirectorios.
Pipes y redirección:
```
echo "Hola" | tee archivo.txt | tr 'a-z' 'A-Z'
```
Escribe "Hola" en archivo.txt y muestra "HOLA" en la pantalla.
Pipes en scripts:
```
#!/bin/bash

cat /etc/passwd | cut -d: -f1 | sort
```
Este script muestra una lista ordenada de usuarios del sistema.
Manejo de errores con pipes: Por defecto, los pipes solo manejan STDOUT. Para incluir STDERR:
```
comando1 2>&1 | comando2
```
Pipes con subshells:
```
(comando1; comando2) | comando3
```
La salida de ambos comando1 y comando2 se pasa a comando3.
Ejemplo práctico - Procesamiento de logs:
```
cat access.log | grep "ERROR" | cut -d' ' -f1 | sort | uniq -c | sort -nr
```
Este comando analiza un archivo de log, extrae las líneas con "ERROR", obtiene la primera columna (posiblemente IPs), las ordena, cuenta ocurrencias únicas y ordena por frecuencia.
Pipes con comandos de control de flujo:
```
cat archivo.txt | while read linea; do
    echo "Procesando: $linea"
done
```
Lee el archivo línea por línea y procesa cada una.

Los pipes son fundamentales en la filosofía Unix de crear herramientas pequeñas y especializadas que pueden combinarse para realizar tareas complejas. Permiten crear flujos de trabajo eficientes y flexibles, procesando datos de manera secuencial y eficiente.

Strings

Las strings (cadenas de texto) en Bash script son secuencias de caracteres que se utilizan para representar texto. Son fundamentales en la programación de scripts para manejar nombres, mensajes, rutas de archivo y más. Aquí te explico los aspectos clave de las strings en Bash:

Definición básica:
```
nombre="Juan"
mensaje='Hola Mundo'
```
Se pueden usar comillas simples ('') o dobles ("").
Diferencia entre comillas simples y dobles:
- Comillas simples: Interpretan todo literalmente.
- Comillas dobles: Permiten expansión de variables y caracteres especiales.
```
echo '$nombre'  # Imprime: $nombre
echo "$nombre"  # Imprime: Juan
```

Concatenación:

saludo="Hola, $nombre"
completo="$nombre $apellido"

Longitud de una string:
```
longitud=${#nombre}
```

Substrings:

echo ${nombre:0:2}  # Imprime los primeros 2 caracteres
echo ${nombre:2}    # Imprime desde el tercer carácter hasta el final

Reemplazo de caracteres:

echo ${nombre/a/o}  # Reemplaza la primera 'a' por 'o'
echo ${nombre//a/o} # Reemplaza todas las 'a' por 'o'

Eliminación de prefijo/sufijo:

archivo="imagen.jpg"
echo ${archivo%.jpg}  # Elimina el sufijo .jpg
echo ${archivo#image} # Elimina el prefijo image

Mayúsculas y minúsculas:

echo ${nombre^^}  # Convierte a mayúsculas
echo ${nombre,,}  # Convierte a minúsculas

Comparación de strings:

if [ "$str1" = "$str2" ]; then
    echo "Las strings son iguales"
fi

Strings vacías:

if [ -z "$variable" ]; then
    echo "La string está vacía"
fi

Strings multilínea:

texto="Primera línea
Segunda línea
Tercera línea"

O usando here documents:

texto=$(cat <<EOF
Primera línea
Segunda línea
Tercera línea
EOF
)

Procesamiento de strings:

echo "hola,mundo" | tr ',' ' '  # Reemplaza ',' por espacio
echo "HoLa" | tr '[:upper:]' '[:lower:]'  # Convierte a minúsculas

Búsqueda en strings:

if [[ "$texto" == *"buscar"* ]]; then
    echo "Encontrado"
fi

Dividir una string:

IFS=':' read -ra ADDR <<< "$STRING"
for i in "${ADDR[@]}"; do
    echo "$i"
done

Interpolación de comandos:

fecha=$(date)
echo "La fecha actual es: $fecha"

Las strings en Bash son muy versátiles y se utilizan extensivamente en casi todos los scripts. Su manejo eficiente es crucial para procesar texto, manejar entradas de usuario, trabajar con archivos y mucho más.

Numbers

Los números en Bash script se utilizan para realizar cálculos, comparaciones y otras operaciones aritméticas. Bash tiene algunas particularidades en el manejo de números que es importante entender. Aquí te explico los aspectos clave:

Tipos de números:
- Bash trabaja principalmente con enteros.
- No tiene soporte nativo para números de punto flotante (decimales).
Asignación de variables numéricas:
```
numero=42
```
Operaciones aritméticas básicas: Usar la sintaxis $((expresión)) o let:
```
suma=$((5 + 3))
let producto=4*5
```

Operadores aritméticos: +, -, *, /, % (módulo), ** (exponenciación)

resultado=$((10 / 3))    # División entera
resto=$((10 % 3))        # Módulo
potencia=$((2 ** 3))     # Exponenciación

Incremento y decremento:

let numero++    # Incremento
let numero--    # Decremento
let numero+=5   # Incremento por 5

Comparaciones numéricas: En estructuras de control como if:
```
if [ $numero -eq 10 ]; then
    echo "El número es 10"
fi
```
Operadores: -eq (igual), -ne (no igual), -lt (menor que), -le (menor o igual), -gt (mayor que), -ge (mayor o igual)
Operaciones de punto flotante: Bash no maneja directamente decimales, pero se puede usar bc para cálculos con decimales:
```
resultado=$(echo "scale=2; 10 / 3" | bc)
```

Generación de números aleatorios:

aleatorio=$RANDOM              # Número aleatorio entre 0 y 32767
aleatorio=$((RANDOM % 100))    # Número aleatorio entre 0 y 99

Secuencias numéricas:
```
for i in {1..10}; do
    echo $i
done
```

Conversión de bases:

echo $((16#FF))    # Convierte FF hexadecimal a decimal
printf "%x\n" 255  # Convierte 255 decimal a hexadecimal

Evaluación aritmética en condicionales:

if (( $numero > 0 && $numero < 10 )); then
    echo "Número entre 1 y 9"
fi

Uso de expr (aunque menos común):
```
resultado=`expr 5 + 3`
```
Trabajar con números grandes: Bash puede manejar enteros de 64 bits en sistemas modernos.

Verificación si es número:

if [[ $variable =~ ^[0-9]+$ ]]; then
    echo "Es un número entero"
fi

Cálculos más complejos: Para cálculos matemáticos avanzados, es común usar herramientas externas como bc o awk.

Es importante recordar que Bash está diseñado principalmente para scripting de shell y no para cálculos matemáticos intensivos. Para operaciones numéricas complejas o de alto rendimiento, generalmente se recomienda usar lenguajes más especializados como Python o C.

declare

El comando declare en Bash script es una herramienta versátil utilizada para declarar variables y establecer sus atributos. Es especialmente útil para definir el tipo y las características de las variables. Aquí te explico los aspectos clave de declare:

Sintaxis básica:
```
declare [opciones] variable[=valor]
```
Declaración simple de variables:
```
declare nombre="Juan"
```
Principales opciones de declare:

a) -i (integer): Declara una variable como entero
```
declare -i numero=42
```
b) -r (readonly): Hace que una variable sea de solo lectura
```
declare -r CONSTANTE="Valor fijo"
```
c) -a (array): Declara una variable como array
```
declare -a mi_array=(1 2 3 4 5)
```
d) -A (associative array): Declara un array asociativo (diccionario)
```
declare -A diccionario
diccionario[clave]="valor"
```
e) -x (export): Exporta la variable al entorno
```
declare -x VAR_ENTORNO="valor"
```
f) -l (lowercase): Convierte el valor a minúsculas
```
declare -l minusculas="TEXTO"
```
g) -u (uppercase): Convierte el valor a mayúsculas
```
declare -u mayusculas="texto"
```

Combinación de opciones:

declare -ri MAX_INTENTOS=3  # Entero de solo lectura

Mostrar variables y sus atributos:

declare -p nombre  # Muestra la declaración de 'nombre'

Eliminar atributos:

declare +x VAR_ENTORNO  # Elimina el atributo de exportación

Uso con funciones:

declare -f  # Lista todas las funciones definidas
declare -f nombre_funcion  # Muestra la definición de una función específica

Variables locales en funciones:

funcion() {
    declare local var_local="Solo visible aquí"
}

Declaración de arrays:

declare -a numeros=(1 2 3 4 5)
declare -A capitales=([España]="Madrid" [Francia]="París")

Uso en scripts para mejorar la legibilidad:

#!/bin/bash
declare -i edad
declare -r PI=3.14159
declare -a nombres

Declaración de variables sin asignar valor:
```
declare mi_var
```

Verificar si una variable está declarada:

if declare -p variable &>/dev/null; then
    echo "La variable está declarada"
fi

El uso de declare es particularmente útil en scripts más grandes o complejos, donde la claridad en la definición y el tipo de las variables es importante. Ayuda a prevenir errores y hace que el código sea más fácil de entender y mantener.

declare es especialmente valioso cuando se trabaja con enteros, arrays, y cuando se necesita control sobre los atributos de las variables, como hacerlas de solo lectura o exportarlas al entorno.

Arrays

En Bash scripting, los arrays (arreglos) son una estructura de datos que permite almacenar múltiples valores en una sola variable. Los arrays pueden ser indexados numéricamente o asociativamente (con claves de texto). Aquí te explico cómo trabajar con arrays en Bash.

1. Definición de Arrays

Arrays Indexados Numéricamente

Los arrays indexados numéricamente utilizan índices numéricos para acceder a sus elementos. Los índices empiezan en 0.

Ejemplos de Definición:

# Definir un array con valores explícitos
mi_array=(valor1 valor2 valor3)

# Definir un array con valores añadidos individualmente
mi_array[0]="valor1"
mi_array[1]="valor2"
mi_array[2]="valor3"

Arrays Asociativos

Los arrays asociativos utilizan claves de texto para acceder a sus elementos. Esta funcionalidad está disponible en Bash 4.0 y versiones posteriores.

Ejemplos de Definición:

# Declarar un array asociativo
declare -A mi_array_asociativo

# Añadir elementos al array asociativo
mi_array_asociativo[clave1]="valor1"
mi_array_asociativo[clave2]="valor2"
mi_array_asociativo[clave3]="valor3"

2. Acceso a Elementos del Array

Arrays Indexados Numéricamente

# Acceder a un elemento del array
echo "${mi_array[0]}"  # Salida: valor1

# Acceder a todos los elementos del array
echo "${mi_array[@]}"  # Salida: valor1 valor2 valor3

# Acceder a los índices del array
echo "${!mi_array[@]}"  # Salida: 0 1 2

Arrays Asociativos

# Acceder a un elemento del array asociativo
echo "${mi_array_asociativo[clave1]}"  # Salida: valor1

# Acceder a todos los valores del array asociativo
echo "${mi_array_asociativo[@]}"  # Salida: valor1 valor2 valor3

# Acceder a todas las claves del array asociativo
echo "${!mi_array_asociativo[@]}"  # Salida: clave1 clave2 clave3

3. Modificación de Elementos del Array

Arrays Indexados Numéricamente

# Modificar un elemento del array
mi_array[1]="nuevo_valor"
echo "${mi_array[1]}"  # Salida: nuevo_valor

Arrays Asociativos

# Modificar un elemento del array asociativo
mi_array_asociativo[clave2]="nuevo_valor"
echo "${mi_array_asociativo[clave2]}"  # Salida: nuevo_valor

4. Longitud del Array

Arrays Indexados Numéricamente

# Obtener la longitud del array
echo "${#mi_array[@]}"  # Salida: 3

Arrays Asociativos

# Obtener la longitud del array asociativo
echo "${#mi_array_asociativo[@]}"  # Salida: 3

5. Iteración sobre Arrays

Arrays Indexados Numéricamente

# Iterar sobre los elementos del array
for elemento in "${mi_array[@]}"
do
  echo "$elemento"
done

# Iterar sobre los índices del array
for indice in "${!mi_array[@]}"
do
  echo "Índice: $indice, Valor: ${mi_array[$indice]}"
done

Arrays Asociativos

# Iterar sobre las claves del array asociativo
for clave in "${!mi_array_asociativo[@]}"
do
  echo "Clave: $clave, Valor: ${mi_array_asociativo[$clave]}"
done

Ejemplo Completo

Aquí tienes un ejemplo completo que muestra la creación, modificación y iteración de arrays indexados numéricamente y asociativos:

#!/bin/bash

# Arrays indexados numéricamente
mi_array=("valor1" "valor2" "valor3")

# Modificar un elemento
mi_array[1]="nuevo_valor"

# Mostrar todos los elementos
echo "Array indexado numéricamente:"
for elemento in "${mi_array[@]}"
do
  echo "$elemento"
done

# Arrays asociativos
declare -A mi_array_asociativo
mi_array_asociativo[clave1]="valor1"
mi_array_asociativo[clave2]="valor2"
mi_array_asociativo[clave3]="valor3"

# Modificar un elemento
mi_array_asociativo[clave2]="nuevo_valor"

# Mostrar todos los elementos
echo "Array asociativo:"
for clave in "${!mi_array_asociativo[@]}"
do
  echo "Clave: $clave, Valor: ${mi_array_asociativo[$clave]}"
done

Este script demuestra cómo definir, modificar, acceder e iterar sobre arrays en Bash, proporcionando una base sólida para trabajar con esta útil estructura de datos.

functions

Las funciones en Bash scripting son bloques de código reutilizables que pueden ser llamados varias veces dentro de un script. Las funciones permiten organizar y estructurar mejor el código, facilitando su mantenimiento y comprensión. Aquí te explico cómo definir y usar funciones en Bash, junto con algunos ejemplos prácticos.

Definición de Funciones

Las funciones en Bash se definen con la siguiente sintaxis:

function nombre_funcion {
  comandos
}

# Alternativa sin la palabra clave 'function'
nombre_funcion() {
  comandos
}

Llamada a una Función

Para llamar a una función, simplemente escribe su nombre:

nombre_funcion

Ejemplo Básico de Función

#!/bin/bash

# Definición de la función
saludar() {
  echo "Hola, $1!"
}

# Llamada a la función con un argumento
saludar "Mundo"

Pasar Argumentos a Funciones

Las funciones en Bash pueden recibir argumentos de la misma manera que los scripts. Los argumentos se acceden usando $1, $2, etc., dentro de la función.

Ejemplo con Argumentos

#!/bin/bash

# Definición de la función
multiplicar() {
  local resultado=$(( $1 * $2 ))
  echo "El resultado de $1 * $2 es $resultado"
}

# Llamada a la función con dos argumentos
multiplicar 5 3

Variables Locales en Funciones

Puedes declarar variables locales dentro de una función usando la palabra clave local. Esto evita que las variables dentro de la función afecten el entorno global del script.

Ejemplo con Variables Locales

#!/bin/bash

# Definición de la función
incrementar() {
  local numero=$1
  numero=$(( numero + 1 ))
  echo "El número incrementado es $numero"
}

# Llamada a la función
incrementar 10

# Intentar acceder a 'numero' fuera de la función (no estará disponible)
echo "Valor de 'numero' fuera de la función: $numero"  # Esto no imprimirá nada

Funciones con Retorno de Valores

Las funciones en Bash no retornan valores como en otros lenguajes de programación. En su lugar, puedes usar echo para imprimir el valor de retorno y capturarlo usando la sustitución de comandos.

Ejemplo de Retorno de Valores

#!/bin/bash

# Definición de la función
suma() {
  local resultado=$(( $1 + $2 ))
  echo "$resultado"
}

# Capturar el valor de retorno de la función
resultado=$(suma 5 7)
echo "La suma de 5 y 7 es $resultado"

Funciones Recursivas

Bash permite funciones recursivas, es decir, funciones que se llaman a sí mismas. Esto es útil para ciertos tipos de algoritmos, como el cálculo de factoriales.

Ejemplo de Función Recursiva

#!/bin/bash

# Definición de la función
factorial() {
  if [ $1 -le 1 ]; then
    echo 1
  else
    local temp=$(( $1 - 1 ))
    local result=$(factorial $temp)
    echo $(( $1 * result ))
  fi
}

# Llamada a la función factorial
numero=5
resultado=$(factorial $numero)
echo "El factorial de $numero es $resultado"

Ejemplo Completo con Varias Funciones

A continuación, un script más complejo que utiliza varias funciones para ilustrar su uso:

#!/bin/bash

# Función para saludar
saludar() {
  echo "Hola, $1!"
}

# Función para sumar dos números
suma() {
  local resultado=$(( $1 + $2 ))
  echo "$resultado"
}

# Función para multiplicar dos números
multiplicar() {
  local resultado=$(( $1 * $2 ))
  echo "$resultado"
}

# Llamadas a las funciones
saludar "Mundo"

resultado_suma=$(suma 5 7)
echo "La suma de 5 y 7 es $resultado_suma"

resultado_multiplicar=$(multiplicar 5 7)
echo "El resultado de 5 * 7 es $resultado_multiplicar"

Este script demuestra cómo definir y usar funciones, pasar argumentos, y trabajar con variables locales y valores de retorno. Las funciones en Bash son una herramienta poderosa para escribir scripts más modulares y fáciles de mantener.

directories

En Bash scripting, trabajar con directorios es una tarea común que puede incluir la creación, eliminación, cambio, listado, y comprobación de la existencia de directorios. Aquí te explico cómo realizar estas operaciones básicas de manipulación de directorios en Bash.

1. Crear Directorios

Para crear directorios, se utiliza el comando mkdir. Puedes crear un solo directorio o varios directorios a la vez.

Crear un Solo Directorio

#!/bin/bash

mkdir nombre_del_directorio

Crear Directorios Anidados

El parámetro -p permite crear directorios anidados (es decir, crear directorios y subdirectorios en una sola llamada).

#!/bin/bash

mkdir -p padre/hijo/nieto

2. Eliminar Directorios

Para eliminar directorios, se utiliza el comando rmdir o rm -r.

Eliminar un Directorio Vacío

#!/bin/bash

rmdir nombre_del_directorio

Eliminar un Directorio y su Contenido

El parámetro -r (o --recursive) permite eliminar un directorio y todo su contenido (archivos y subdirectorios).

#!/bin/bash

rm -r nombre_del_directorio

3. Cambiar de Directorio

Para cambiar de directorio, se utiliza el comando cd.

#!/bin/bash

cd nombre_del_directorio

Volver al Directorio Anterior

#!/bin/bash

cd -

Ir al Directorio Home del Usuario

#!/bin/bash

cd ~

4. Listar el Contenido de un Directorio

Para listar el contenido de un directorio, se utiliza el comando ls.

#!/bin/bash

ls nombre_del_directorio

Listar con Detalles

El parámetro -l muestra información detallada sobre los archivos y directorios.

#!/bin/bash

ls -l nombre_del_directorio

Listar incluyendo Archivos Ocultos

El parámetro -a incluye archivos ocultos (los que comienzan con un punto .).

#!/bin/bash

ls -a nombre_del_directorio

5. Comprobar la Existencia de un Directorio

Para comprobar si un directorio existe, se utiliza una estructura if junto con el operador -d.

#!/bin/bash

if [ -d nombre_del_directorio ]; then
  echo "El directorio existe."
else
  echo "El directorio no existe."
fi

Ejemplo Completo

A continuación, un ejemplo completo de un script Bash que realiza varias operaciones con directorios:

#!/bin/bash

# Crear un directorio
mkdir -p mi_directorio/subdirectorio

# Comprobar si el directorio se creó correctamente
if [ -d mi_directorio/subdirectorio ]; then
  echo "El directorio mi_directorio/subdirectorio se creó correctamente."
else
  echo "Error al crear el directorio mi_directorio/subdirectorio."
fi

# Cambiar al nuevo directorio
cd mi_directorio/subdirectorio || exit

# Crear algunos archivos en el nuevo directorio
touch archivo1.txt archivo2.txt

# Listar el contenido del directorio actual
echo "Contenido de $(pwd):"
ls -l

# Volver al directorio anterior
cd - || exit

# Eliminar el directorio y su contenido
rm -r mi_directorio

# Comprobar si el directorio se eliminó correctamente
if [ ! -d mi_directorio ]; then
  echo "El directorio mi_directorio se eliminó correctamente."
else
  echo "Error al eliminar el directorio mi_directorio."
fi

Este script demuestra cómo crear directorios, cambiar a esos directorios, crear archivos dentro de ellos, listar su contenido, y finalmente eliminar los directorios y su contenido. Además, incluye comprobaciones para asegurarse de que las operaciones se realizaron correctamente.

curl

curl es una herramienta de línea de comandos utilizada para transferir datos desde o hacia un servidor, utilizando uno de los muchos protocolos soportados (HTTP, HTTPS, FTP, etc.). Es muy útil en scripts Bash para interactuar con servicios web, descargar archivos, enviar datos a través de solicitudes POST, y mucho más.

Aquí te explico cómo usar curl en scripts Bash, con ejemplos de las tareas más comunes.

1. Instalación de `curl`

La mayoría de las distribuciones de Linux ya incluyen curl preinstalado. Puedes verificar si curl está instalado ejecutando:

curl --version

Si no está instalado, puedes instalarlo usando el administrador de paquetes de tu sistema:

En Debian/Ubuntu:

sudo apt-get install curl

En Red Hat/CentOS:

sudo yum install curl

2. Realizar una Solicitud GET

Para realizar una solicitud GET simple y mostrar la respuesta, puedes usar:

#!/bin/bash

url="https://jsonplaceholder.typicode.com/posts/1"
response=$(curl -s $url)

echo "Respuesta de la solicitud GET:"
echo "$response"

En este ejemplo, -s oculta el progreso y los mensajes de error para que solo se muestre el contenido de la respuesta.

3. Realizar una Solicitud POST

Para enviar datos a través de una solicitud POST, puedes usar la opción -d para especificar los datos a enviar. Aquí tienes un ejemplo:

#!/bin/bash

url="https://jsonplaceholder.typicode.com/posts"
data='{"title": "foo", "body": "bar", "userId": 1}'

response=$(curl -s -X POST -H "Content-Type: application/json" -d "$data" $url)

echo "Respuesta de la solicitud POST:"
echo "$response"

4. Enviar Datos a través de Formulario con POST

Para enviar datos de un formulario, puedes usar -F para especificar los campos del formulario:

#!/bin/bash

url="https://example.com/form"
response=$(curl -s -X POST -F "campo1=valor1" -F "campo2=valor2" $url)

echo "Respuesta de la solicitud POST del formulario:"
echo "$response"

5. Descargar un Archivo

Para descargar un archivo y guardarlo con un nombre específico, usa -o:

#!/bin/bash

url="https://example.com/archivo.zip"
archivo_destino="archivo.zip"

curl -o $archivo_destino $url
echo "Archivo descargado como $archivo_destino"

6. Autenticación

Para acceder a recursos que requieren autenticación, puedes usar las opciones -u (para autenticación básica) o -H (para enviar un token de autorización en la cabecera).

Autenticación Básica

#!/bin/bash

url="https://example.com/protegido"
usuario="mi_usuario"
password="mi_password"

response=$(curl -s -u $usuario:$password $url)

echo "Respuesta de la solicitud con autenticación básica:"
echo "$response"

Autenticación con Token

#!/bin/bash

url="https://example.com/protegido"
token="mi_token_de_autenticacion"

response=$(curl -s -H "Authorization: Bearer $token" $url)

echo "Respuesta de la solicitud con token:"
echo "$response"

7. Guardar la Respuesta en un Archivo

Para guardar la respuesta de curl en un archivo, usa -o o -O.

Guardar en un Archivo con un Nombre Específico

#!/bin/bash

url="https://jsonplaceholder.typicode.com/posts/1"
archivo_destino="respuesta.json"

curl -s -o $archivo_destino $url
echo "Respuesta guardada en $archivo_destino"

Guardar con el Nombre del Archivo en la URL

#!/bin/bash

url="https://jsonplaceholder.typicode.com/posts/1"

curl -O $url
echo "Respuesta guardada con el nombre del archivo en la URL"

8. Configuración de Tiempo de Espera

Para establecer un tiempo de espera (timeout) para la conexión y la transferencia, puedes usar --connect-timeout y -m (o --max-time):

#!/bin/bash

url="https://jsonplaceholder.typicode.com/posts/1"

# Timeout de conexión: 5 segundos, Timeout total: 10 segundos
response=$(curl -s --connect-timeout 5 -m 10 $url)

echo "Respuesta con timeout configurado:"
echo "$response"

Ejemplo Completo

A continuación, un ejemplo completo que incluye varios de los conceptos anteriores:

#!/bin/bash

# URL de la API
url="https://jsonplaceholder.typicode.com/posts"

# Datos para la solicitud POST
data='{"title": "foo", "body": "bar", "userId": 1}'

# Realizar una solicitud GET
response_get=$(curl -s $url/1)
echo "Respuesta de la solicitud GET:"
echo "$response_get"

# Realizar una solicitud POST
response_post=$(curl -s -X POST -H "Content-Type: application/json" -d "$data" $url)
echo "Respuesta de la solicitud POST:"
echo "$response_post"

# Descargar un archivo
archivo_url="https://jsonplaceholder.typicode.com/posts/1"
archivo_destino="post_1.json"
curl -s -o $archivo_destino $archivo_url
echo "Archivo descargado como $archivo_destino"

# Comprobar si el archivo se ha descargado correctamente
if [ -f $archivo_destino ]; then
  echo "El archivo $archivo_destino se descargó correctamente."
else
  echo "Error al descargar el archivo $archivo_destino."
fi

Este ejemplo demuestra cómo usar curl para realizar solicitudes GET y POST, descargar archivos y manejar errores básicos. curl es una herramienta poderosa y flexible que es muy útil en scripts Bash para interactuar con servicios web y transferir datos.

debugging bash script

Depurar (debugging) scripts Bash es una tarea crucial para identificar y corregir errores. Aquí tienes algunas técnicas y herramientas que puedes utilizar para depurar scripts Bash.

1. `set -x` y `set +x`

El comando set -x permite activar el modo de depuración, mostrando cada comando y su argumento cuando se ejecuta. Puedes desactivar este modo con set +x.

Ejemplo:

#!/bin/bash

# Activar modo de depuración
set -x

echo "Este es un script de ejemplo"
var="Hola Mundo"
echo $var

# Desactivar modo de depuración
set +x

echo "Fin del script"

2. `bash -x` y `bash -v`

Puedes ejecutar el script con la opción -x o -v para activar el modo de depuración sin modificar el script.

Ejemplo con `-x`:

bash -x mi_script.sh

Ejemplo con `-v`:

bash -v mi_script.sh

3. `set -e`

El comando set -e hace que el script termine si un comando falla. Esto es útil para identificar qué comando está causando un error.

Ejemplo:

#!/bin/bash

set -e

comando_exitoso
comando_que_falla
comando_no_alcanzado

4. Uso de `trap`

El comando trap puede capturar señales y errores para ejecutar comandos específicos en respuesta a ellos.

Ejemplo:

#!/bin/bash

# Función de limpieza
limpiar() {
  echo "Limpiando..."
}

# Capturar señal de salida
trap limpiar EXIT

echo "Script en ejecución"
exit 1  # Forzar un error

5. `echo` y Variables

Usar echo para imprimir valores de variables y mensajes en puntos clave del script ayuda a entender el flujo y los valores actuales de las variables.

Ejemplo:

#!/bin/bash

var="Hola Mundo"
echo "Valor de var: $var"

if [ "$var" == "Hola Mundo" ]; then
  echo "La variable contiene 'Hola Mundo'"
else
  echo "La variable NO contiene 'Hola Mundo'"
fi

6. `exec` para Redirigir Salida

Puedes usar exec para redirigir la salida estándar y de error a un archivo de log.

Ejemplo:

#!/bin/bash

exec > script.log 2>&1

echo "Este mensaje va al archivo de log"
comando_que_falla

Ejemplo Completo

A continuación, un ejemplo completo de un script Bash con varias técnicas de depuración:

#!/bin/bash

# Activar modo de depuración
set -x

# Capturar errores y señales
trap 'echo "Se produjo un error en la línea $LINENO"' ERR
trap 'echo "Señal de salida capturada"' EXIT

# Variables
var="Hola Mundo"
echo "Valor de var: $var"

# Función de ejemplo
mi_funcion() {
  local local_var="Variable local"
  echo "Dentro de la función: $local_var"
  comando_que_no_existe
}

# Llamar a la función
mi_funcion

# Desactivar modo de depuración
set +x

echo "Fin del script"

Uso de Debuggers Interactivos

Además de las técnicas mencionadas, puedes usar depuradores interactivos como bashdb para una depuración más avanzada.

Instalación de `bashdb`:

sudo apt-get install bashdb

Ejemplo de Uso:

bashdb mi_script.sh

Estas técnicas y herramientas te ayudarán a depurar y corregir errores en tus scripts Bash de manera más efectiva.

Name		Name	Last commit message	Last commit date
Latest commit History 3 Commits
sh_14_scripts		sh_14_scripts
.gitignore		.gitignore
README.md		README.md
archivo.txt		archivo.txt
errors.txt		errors.txt
file.txt		file.txt
hola.txt		hola.txt
image.png		image.png
sh_01_hola_mundo.sh		sh_01_hola_mundo.sh
sh_02_guardar_salida.sh		sh_02_guardar_salida.sh
sh_03_comentario.sh		sh_03_comentario.sh
sh_04_delimitador_cat.sh		sh_04_delimitador_cat.sh
sh_05_read.sh		sh_05_read.sh
sh_06_condicionales.sh		sh_06_condicionales.sh
sh_07_logical_operador.sh		sh_07_logical_operador.sh
sh_08_case.sh		sh_08_case.sh
sh_09_loops.sh		sh_09_loops.sh
sh_10_break_y_continue.sh		sh_10_break_y_continue.sh
sh_11_argumentos.sh		sh_11_argumentos.sh
sh_12_stdin.sh		sh_12_stdin.sh
sh_13_sterr_y_stdout.sh		sh_13_sterr_y_stdout.sh
sh_14_pipes.sh		sh_14_pipes.sh
sh_15_compare_string.sh		sh_15_compare_string.sh
sh_15_concatenation.sh		sh_15_concatenation.sh
sh_16_numbers.sh		sh_16_numbers.sh
sh_17_declare.sh		sh_17_declare.sh
sh_18_arrays.sh		sh_18_arrays.sh
sh_19_functions.sh		sh_19_functions.sh
sh_20_directories.sh		sh_20_directories.sh
sh_21_curl.sh		sh_21_curl.sh
sh_22_debugging_bash_script.sh		sh_22_debugging_bash_script.sh
users.json		users.json

zolynux/curso-de-bash-script

Folders and files

Latest commit

History

Repository files navigation

✨ Curso de Bash Script para Principiantes 🚀

Introducción a Bash Script.

Qué es un Bash Script

Para qué sirve

Hola Mundo

Guardar Salida

Comentarios

Delimitador Cat

Read

Condicionales

Case

Loops

1. Bucle for

Sintaxis:

Ejemplo:

2. Bucle while

Sintaxis:

Ejemplo:

3. Bucle until

Sintaxis:

Ejemplo:

4. Bucle for con C-like syntax

Sintaxis:

Ejemplo:

5. Bucle for para iterar sobre archivos

Ejemplo:

Uso de break y continue

Ejemplo con break y continue:

Break y Continue

1. break

Ejemplo con break:

2. continue

Ejemplo con continue:

Uso de break y continue en bucles anidados

Ejemplo de break en bucles anidados:

Ejemplo de continue en bucles anidados:

Argumentos en Bash Script

1. Acceso a los Argumentos

2. Ejemplo de Uso de Argumentos

Contenido de mi_script.sh:

Ejecución del script:

Salida del script:

3. Procesamiento de Argumentos

Ejemplo de procesamiento de argumentos:

4. Uso de shift

Ejemplo de uso de shift:

5. Argumentos de Opción

Ejemplo de uso de getopts:

Ejecución del script:

Salida del script:

Stdin

sterr y stdout

Pipes

Strings

Numbers

declare

Arrays

1. Definición de Arrays

Arrays Indexados Numéricamente

Ejemplos de Definición:

Arrays Asociativos

Ejemplos de Definición:

2. Acceso a Elementos del Array

Arrays Indexados Numéricamente

Arrays Asociativos

3. Modificación de Elementos del Array

Arrays Indexados Numéricamente

Arrays Asociativos

4. Longitud del Array

Arrays Indexados Numéricamente

Arrays Asociativos

5. Iteración sobre Arrays

Arrays Indexados Numéricamente

Arrays Asociativos

Ejemplo Completo

1. Bucle `for`

2. Bucle `while`

3. Bucle `until`

4. Bucle `for` con `C`-like syntax

5. Bucle `for` para iterar sobre archivos

Uso de `break` y `continue`

Ejemplo con `break` y `continue`:

1. `break`

Ejemplo con `break`:

2. `continue`

Ejemplo con `continue`:

Uso de `break` y `continue` en bucles anidados

Ejemplo de `break` en bucles anidados:

Ejemplo de `continue` en bucles anidados:

Contenido de `mi_script.sh`:

4. Uso de `shift`

Ejemplo de uso de `shift`:

Ejemplo de uso de `getopts`:

1. Instalación de `curl`

1. `set -x` y `set +x`

2. `bash -x` y `bash -v`

Ejemplo con `-x`:

Ejemplo con `-v`:

3. `set -e`

4. Uso de `trap`

5. `echo` y Variables

6. `exec` para Redirigir Salida

Instalación de `bashdb`: