Saltar a contenido

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

Duración estimada: 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, explorando su utilidad técnica. 🎯

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: El tiempo varía según tu nivel y dedicación; experimenta con cada paso para entender cómo funcionan los conceptos.

📖 Contenidos del Módulo

2.1. Primeros scripts: Automatiza tu saludo 🌱

Teoría:

Un script es un archivo con comandos que Bash ejecuta juntos. El shebang #!/bin/bash indica que Bash es el intérprete. Técnicamente, esto permite ejecutar múltiples órdenes como un programa.

Práctica:

  1. Crea un archivo saludo.sh: 
    nano saludo.sh
    Abre el editor y escribe lo siguiente.
  2. Añade un script simple y guarda (Ctrl+O, Enter, Ctrl+X): 
    #!/bin/bash
echo "¡Bienvenido a mi primer script!"
    El shebang asegura que Bash lo procese.
  3. Dale permisos y ejecútalo: 
    chmod +x saludo.sh
./saludo.sh
    chmod +x habilita la ejecución; ./ lo corre.
  4. Añade otro comando y prueba: 
    nano saludo.sh
echo "¡Hora actual: $(date)"
./saludo.sh
    $(date) ejecuta date dentro del script.
  5. Modifica para saludar con tu nombre: 
    nano saludo.sh
echo "¡Hola, [tu nombre]! Hora: $(date)"
./saludo.sh

Dato curioso

Los scripts ahorran tiempo al agrupar comandos que usas a menudo. 😄

2.2. Variables: Almacena y reutiliza datos 🖌️

Teoría:

Las variables guardan datos (ej. texto, números) para usarlos en scripts. En Bash, se definen con nombre=valor y se acceden con $nombre. Técnicamente, esto optimiza la flexibilidad de los scripts.

Práctica:

  1. Crea un script variables.sh: 
    nano variables.sh
  2. Define una variable y úsala: 
    #!/bin/bash
nombre="Aprendiz"
echo "¡Hola, $nombre!"
    Guarda y ejecuta con chmod +x variables.sh y ./variables.sh.
  3. Añade una variable con tu nombre: 
    nano variables.sh
nombre="TuNombre"
echo "¡Hola, $nombre!"
    Ejecuta de nuevo y verifica.
  4. Usa una variable con date: 
    hora=$(date)
echo "La hora es: $hora"
    Ejecuta y observa la salida.
  5. Combina variables en un mensaje: 
    nano variables.sh
nombre="TuNombre"
saludo="¡Bienvenido, $nombre!"
echo "$saludo Hora: $(date)"
./variables.sh

Consejo

Usa nombres claros para variables (ej. mi_nombre); evita espacios cerca de =. 💡

2.3. Redirecciones: Guarda y controla salidas ⚙️

Teoría:

Las redirecciones envían la salida de un comando a un archivo o dispositivo. > sobrescribe, >> añade, y 2> maneja errores. Técnicamente, esto es esencial para registrar o depurar.

Práctica:

  1. Redirige un saludo a un archivo: 
    echo "Guardando mi script" > salida.txt
cat salida.txt
    > crea o sobrescribe el archivo.
  2. Añade más texto al archivo: 
    echo "Añadiendo más" >> salida.txt
cat salida.txt
    >> agrega sin borrar.
  3. Redirige un comando con error: 
    ls /ruta/falsa 2> errores.txt
cat errores.txt
    2> captura errores; revisa el resultado.
  4. Combina salidas en un script: 
    nano guarda.sh
#!/bin/bash
echo "Guardando datos" > resultado.txt
date >> resultado.txt
chmod +x guarda.sh
./guarda.sh
cat resultado.txt
  5. Limpia el archivo y verifica: 
    > resultado.txt
cat resultado.txt

Advertencia

> sobrescribe archivos; usa >> si quieres conservar datos. 🛑

2.4. Pipes: Conecta comandos como un experto 📜

Teoría:

Los pipes (|) envían la salida de un comando como entrada a otro. Ejemplo: ls | grep texto filtra resultados. Técnicamente, esto potencia la combinación de herramientas.

Práctica:

  1. Lista archivos y filtra con grep: 
    ls | grep "mi"
    Busca archivos con "mi" en el nombre.
  2. Cuenta líneas con wc: 
    ls | wc -l
    -l cuenta líneas; muestra el número de archivos.
  3. Crea un script con pipe: 
    nano pipe.sh
#!/bin/bash
ls | grep "txt" > archivos_txt.txt
chmod +x pipe.sh
./pipe.sh
cat archivos_txt.txt
  4. Combina con variable: 
    nano pipe.sh
archivos=$(ls | grep "txt")
echo "Archivos .txt: $archivos" > resultado.txt
./pipe.sh
cat resultado.txt
  5. Prueba un pipe complejo: 
    ls -l | grep "^d" | wc -l
    Cuenta directorios (^d filtra líneas que empiezan con "d").

Consejo

Usa pipes para encadenar comandos y ahorrar pasos. 💡

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

Teoría:

Los permisos definen quién puede ejecutar o editar un script. chmod ajusta estos permisos (ej. +x para ejecución). Técnicamente, esto protege y controla el acceso.

Práctica:

  1. Crea un script sin permisos: 
    nano prueba.sh
#!/bin/bash
echo "Sin permisos aún"
    Intenta ejecutarlo con ./prueba.sh (debería fallar).
  2. Añade permisos y ejecuta: 
    chmod +x prueba.sh
./prueba.sh
    +x habilita ejecución; verifica el resultado.
  3. Revisa permisos con ls: 
    ls -l prueba.sh
    Busca la "x" en la salida (ej. -rwxr-xr-x).
  4. Crea un script protegido: 
    nano secreto.sh
#!/bin/bash
echo "Este es secreto"
chmod 700 secreto.sh
./secreto.sh
    700 da permisos solo al propietario.
  5. Verifica y ajusta permisos: 
    ls -l secreto.sh
chmod 755 secreto.sh
ls -l secreto.sh

Consejo

Usa chmod 755 para scripts compartidos; 700 para privados. 💡

🛠️ Ejercicios prácticos

  1. Script básico:
    • Crea un script presentacion.sh que muestre tu nombre y la fecha.
  2. Variables:
    • Modifica el script para usar una variable con tu ciudad.
  3. Redirección:
    • Redirige la salida del script a 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 archivos .sh usando pipes y variables.

📝 Evaluación

Cuestionario corto (5 preguntas):

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

Tarea práctica:

  • Crea un script automatiza.sh que:
    • Guarde tu nombre en una variable.
    • Muestre la fecha redirigida a fecha.txt.
    • Liste archivos .sh usando un pipe.
  • Entrega: Script, fecha.txt y una nota con los pasos.

Vídeo con la solución de la evaluación:

🎉 Recursos adicionales

Tip

Experimenta combinando echo con pipes para practicar. 💡

🚀 Siguientes pasos

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