Saltar a contenido

📚 Módulo 2: Creando tus primeros comandos automáticos

Duración estimada: 2-3 horas según tu ritmo y experiencia.

Objetivo: Dominar la creación de scripts básicos, utilizar variables para almacenar datos, redirigir salidas y usar pipes para conectar comandos. 🎯

Prerrequisitos: Haber completado el Módulo 1, acceso a un sistema Linux, macOS o WSL con una terminal y un editor de texto (nano, vim o VS Code).

Nota: Experimenta con cada paso para entender bien cómo funcionan los conceptos antes de continuar.

📖 Contenidos del Módulo

2.1. Primeros scripts: Automatiza tu saludo 🌱

Teoría:

Un script es un archivo con comandos que Bash ejecuta en secuencia. El shebang #!/bin/bash en la primera línea indica que Bash es el intérprete. Esto permite agrupar múltiples órdenes y ejecutarlas como un solo programa.

Práctica:

  1. Crea un archivo saludo.sh:
nano saludo.sh
  1. Escribe el script y guarda con Ctrl+O, Enter, Ctrl+X:
#!/bin/bash
echo "¡Bienvenido a mi primer script!"
  1. Dale permisos y ejecútalo:
chmod +x saludo.sh
./saludo.sh

chmod +x habilita la ejecución; ./ lo corre desde el directorio actual.

  1. Añade la hora actual y prueba:
nano saludo.sh
# Añade esta línea al final:
echo "Hora actual: $(date)"
./saludo.sh

$(date) es una sustitución de comandos: Bash ejecuta date y sustituye el resultado en su lugar. Los $() sirven para capturar la salida de cualquier comando. No confundas esto con $(( )), que es para aritmética (lo veremos en el Módulo 3).

  1. Modifica el script para saludar con tu nombre:
nano saludo.sh
# Edita la línea echo para que quede así:
echo "¡Hola, [tu nombre]! Hora: $(date)"
./saludo.sh

Dato curioso: Los scripts agrupan comandos que usas a menudo, ahorrándote escribirlos una y otra vez. 😄

2.2. Variables: Almacena y reutiliza datos 🖌️

Teoría:

Las variables guardan datos (texto, números, resultados de comandos) para usarlos en distintos puntos del script. En Bash se definen con nombre=valor (sin espacios alrededor del =) y se acceden anteponiendo $ al nombre: $nombre. Esto hace los scripts más flexibles y fáciles de mantener.

Práctica:

  1. Crea un script variables.sh:
nano variables.sh
  1. Define una variable y úsala:
#!/bin/bash
nombre="Aprendiz"
echo "¡Hola, $nombre!"

Guarda y dale permisos: chmod +x variables.sh. Ejecútalo con ./variables.sh.

  1. Cambia el valor de la variable con tu nombre y vuelve a ejecutar:
nano variables.sh
# Cambia la línea nombre= por tu nombre real
nombre="TuNombre"
./variables.sh
  1. Guarda la salida de un comando en una variable:
nano variables.sh
# Añade estas líneas:
hora=$(date)
echo "La hora es: $hora"
./variables.sh
  1. Combina varias variables en un mensaje:
nano variables.sh
# Deja el script así:
#!/bin/bash
nombre="TuNombre"
hora=$(date)
saludo="¡Bienvenido, $nombre!"
echo "$saludo Son las: $hora"
./variables.sh

Consejo: Usa nombres descriptivos para las variables (ej. mi_nombre, archivo_destino). Evita espacios alrededor del =; nombre = "valor" dará error. 💡

2.3. Redirecciones: Guarda y controla salidas ⚙️

Teoría:

Las redirecciones envían la salida de un comando a un archivo en lugar de a la pantalla. Los operadores principales son: - > crea o sobrescribe el archivo con la salida. - >> añade la salida al final del archivo sin borrar lo anterior. - 2> redirige los mensajes de error (stderr) a un archivo.

Esto es fundamental para registrar resultados y depurar scripts.

Práctica:

  1. Redirige un mensaje a un archivo:
echo "Guardando mi primer resultado" > salida.txt
cat salida.txt

> crea el archivo si no existe, o lo sobrescribe si ya existe.

  1. Añade más texto al mismo archivo:
echo "Añadiendo una segunda línea" >> salida.txt
cat salida.txt

>> agrega al final sin borrar lo que había.

  1. Redirige un mensaje de error:
ls /ruta/que/no/existe 2> errores.txt
cat errores.txt

2> captura el error sin que aparezca en pantalla. Muy útil para logs.

  1. Crea un script que combine redirecciones:
nano guarda.sh

Escribe:

#!/bin/bash
echo "Guardando datos en archivo" > resultado.txt
date >> resultado.txt
echo "Script finalizado" >> resultado.txt

Luego: chmod +x guarda.sh && ./guarda.sh && cat resultado.txt

  1. Vacía un archivo sin borrarlo:
> resultado.txt
cat resultado.txt

Redirigir nada a un archivo lo deja vacío. Útil para resetear logs.

Advertencia: > sobrescribe sin preguntar. Si quieres conservar el contenido anterior, usa siempre >>. 🛑

2.4. Pipes: Conecta comandos como un experto 📜

Teoría:

El pipe (|) toma la salida de un comando y la pasa directamente como entrada al siguiente, sin necesidad de archivos intermedios. Ejemplo: ls | grep "txt" lista archivos y filtra los que contienen "txt". Esta capacidad de encadenar herramientas es una de las características más poderosas de Bash.

Práctica:

  1. Lista archivos y filtra con grep:
ls | grep "mi"

Muestra solo los archivos cuyo nombre contiene "mi".

  1. Cuenta el número de archivos con wc -l:
ls | wc -l

wc -l cuenta líneas; como cada archivo ocupa una línea, obtienes el total.

  1. Crea un script que use un pipe para guardar resultados:
nano pipe.sh

Escribe:

#!/bin/bash
ls | grep "txt" > archivos_txt.txt
echo "Archivos .txt encontrados:"
cat archivos_txt.txt

Luego: chmod +x pipe.sh && ./pipe.sh

  1. Guarda el resultado de un pipe en una variable:
nano pipe.sh
# Modifica el script:
#!/bin/bash
archivos=$(ls | grep "txt")
echo "Archivos .txt: $archivos" > resultado.txt
./pipe.sh
cat resultado.txt
  1. Encadena tres comandos:
ls -l | grep "^d" | wc -l

Esto lista en detalle (-l), filtra las líneas que empiezan por d (directorios) y cuenta cuántas hay.

Consejo: Los pipes te permiten construir herramientas potentes combinando comandos simples. Es uno de los conceptos más elegantes de Unix. 💡

2.5. Permisos y ejecución: Seguridad básica 🚀

Teoría:

En Linux, cada archivo tiene permisos que definen quién puede leerlo, escribirlo o ejecutarlo. Los permisos se organizan en tres grupos: propietario, grupo y otros. El comando chmod los modifica. Puedes usar la notación simbólica (+x, -w) o la notación octal, donde cada dígito es la suma de los permisos activos:

  • 4 = lectura (r)
  • 2 = escritura (w)
  • 1 = ejecución (x)

Por ejemplo, 755 significa: propietario puede todo (7 = 4+2+1), grupo y otros pueden leer y ejecutar (5 = 4+1).

Práctica:

  1. Crea un script sin permisos de ejecución:
nano prueba.sh

Escribe:

#!/bin/bash
echo "Sin permisos aún"

Intenta ejecutarlo con ./prueba.sh — debería fallar con "Permission denied".

  1. Añade permisos de ejecución y vuelve a intentarlo:
chmod +x prueba.sh
./prueba.sh
  1. Revisa los permisos con ls -l:
ls -l prueba.sh

Busca la x en la salida. Verás algo como -rwxr-xr-x, donde cada grupo de tres letras representa propietario, grupo y otros.

  1. Crea un script solo accesible por ti:
nano secreto.sh

Escribe:

#!/bin/bash
echo "Este script es privado"

Luego:

chmod 700 secreto.sh
ls -l secreto.sh
./secreto.sh

700 da todos los permisos al propietario y ninguno al resto.

  1. Cambia a permisos compartidos y compara:
chmod 755 secreto.sh
ls -l secreto.sh

Consejo: Usa chmod 755 para scripts que otros también deban ejecutar; chmod 700 para scripts privados con datos sensibles. 💡

🛠️ Ejercicios prácticos

  1. Script básico: Crea un script presentacion.sh que muestre tu nombre y la fecha actual.
  2. Variables: Modifica el script para guardar tu ciudad en una variable y mostrarla también.
  3. Redirección: Redirige la salida del script a un archivo mi_presentacion.txt.
  4. Pipe: Usa ls | grep "sh" y cuenta los resultados con wc -l.
  5. Desafío: Crea un script que guarde en un archivo la lista de scripts .sh del directorio, usando pipes y variables.

📝 Evaluación

Cuestionario (5 preguntas):

  1. ¿Qué hace el shebang #!/bin/bash?
  2. ¿Cómo defines una variable en Bash y cómo la usas?
  3. ¿Cuál es la diferencia entre > y >>?
  4. ¿Qué hace el símbolo | (pipe) en un comando?
  5. ¿Cómo cambias los permisos de un script para poder ejecutarlo?

Tarea práctica:

Crea un script automatiza.sh que: - Guarde tu nombre en una variable y lo muestre. - Guarde la fecha actual en un archivo fecha.txt usando redirección. - Liste los archivos .sh del directorio usando un pipe y los cuente.

Entrega: El script, el archivo fecha.txt y una nota con los pasos seguidos.

🎬 Vídeo con la solución de la evaluación: Próximamente.

🎉 Recursos adicionales

Tip: Experimenta combinando echo, pipes y redirecciones para interiorizar bien cada concepto. 💡

🚀 Siguientes pasos

¡Felicidades por completar el Módulo 2! En el Módulo 3 aprenderás a tomar decisiones con condicionales (if, case) y a repetir tareas con bucles. ¡Sigue automatizando! ✍️