Shell script
miércoles, 3 de septiembre de 2025 08:33
Comando echo
○ Se utiliza para mostrar mensajes en la terminal.
○ Es equivalente a [Link] en Java.
○ Cuando se abre con comillas ("), permite escribir varias líneas presionando Enter sin cerrar el comando, finalizando
solo cuando se cierran las comillas.
○ Ejemplo de uso: Para pedir una operación, se puede usar echo "Ingrese la operación" y luego listar las operaciones
disponibles (*, /, +, -, %).
Comando read
○ Se utiliza para leer la entrada del usuario y almacenarla en una variable.
○ Ejemplo: read N1 guarda la entrada en la variable N1.
Diferencias y recomendaciones (echo y read -p)
○ echo "Ingrese un número" seguido de read N1: Muestra el mensaje en una línea y espera la entrada en la siguiente
línea.
○ read -p "Ingrese un número" N1: Muestra el mensaje y espera la entrada en la misma línea. Esta es la forma
preferida para una interfaz más amigable con el usuario.
○ El comando echo -n (no mencionado explícitamente en el contexto del read, pero sí en el video) no hace un salto
de línea.
○ Si se usa read sin -p, el cursor espera la entrada en una nueva línea. Para una mejor experiencia de usuario, es
recomendable incluir un mensaje que guíe al usuario sobre qué se espera como entrada.
Operaciones aritméticas y variables
• Operaciones soportadas: * (multiplicación), / (división), + (suma), - (resta), % (resto/módulo).
Sintaxis para operaciones con enteros:
• Las operaciones se realizan con números enteros.
• Se usa el signo de pesos ($) delante de las variables para acceder a su valor (ej. $N1).
• La sintaxis para realizar operaciones aritméticas es $(( EXPRESION )). Por ejemplo: resultado=$(($N1 $OP $N2)).
• $OP representa la variable que contiene el operador deseado.
• Uso de variables para operadores: Si se tiene una variable Op que almacena el operador (ej. +, -), se puede usar $(($N1
$Op $N2)) para ejecutar la operación correspondiente.
Validaciones y manejo de errores
• Importancia: Un programa bien hecho no debería arrojar errores.
• Controles necesarios: Es crucial validar las entradas del usuario para asegurar que:
○ Los valores ingresados son números enteros.
○ La operación ingresada es una de las operaciones válidas (*, /, +, -, %).
• Manejo con if: Para realizar estas validaciones, se deben usar estructuras condicionales (if).
• Lectura de mensajes de error: Es fundamental leer y entender los mensajes de error cuando ocurren, en lugar de
simplemente decir "me dio error".
Errores frecuentes
Interpretación octal de números con cero inicial:
○ Si un número se ingresa con un 0 al principio (ej. 04, 010), el shell lo interpreta como un número octal.
○ El resultado de cualquier operación con dicho número se dará en decimal.
○ Ejemplo: 010 (octal) es 8 (decimal). Entonces, 010 + 5 resultaría en 13 (8 + 5), no 15 (10 + 5).
○ Error Adicional: Si un número octal ingresado contiene dígitos 8 o 9 (ej. 080), el shell generará un error, ya que
estos dígitos no existen en el sistema octal.
Mensaje "Programa ejecutado con éxito": Se debe evitar usar este mensaje si el script no implementa controles de errores
robustos, ya que podría dar una falsa sensación de seguridad.
Error frecuente al usar read (signo de pesos $)
Incorrecto: read $N1
Correcto: read N1
Explicación: El signo $ se usa para obtener el valor de una variable. Si se usa read $N1, el shell intentará leer la entrada en el
valor actual de N1. Si N1 está vacía, intentará leer sin asignar a ninguna variable; si N1contiene un valor (ej. dato),
intentará leer la entrada en una variable llamada dato. Este es un error lógico que no siempre produce un error visible de
inmediato, dificultando su detección.
Error frecuente al asignar Variables (espacios alrededor de =)
Incorrecto: read $N1
Correcto: read N1
Explicación: El signo $ se usa para obtener el valor de una variable. Si se usa read $N1, el shell intentará leer la entrada en el
valor actual de N1. Si N1 está vacía, intentará leer sin asignar a ninguna variable; si N1contiene un valor (ej. dato),
intentará leer la entrada en una variable llamada dato. Este es un error lógico que no siempre produce un error visible de
inmediato, dificultando su detección.
Error frecuente al asignar Variables (espacios alrededor de =)
Incorrecto: VAR = VALOR (con espacios alrededor del signo =)
Correcto: VAR=VALOR (sin espacios)
Explicación: Si se colocan espacios, el shell interpreta VAR como un comando y VALOR como su argumento, no como una
asignación de variable.
Declaración de variables: En Bash, las variables no necesitan ser declaradas explícitamente. read o una asignación directa
(VAR=VALOR) las crean automáticamente.
Nombres de archivos y variables (restricciones y buenas prácticas)
• Evitar espacios y caracteres especiales: No se deben usar espacios, asteriscos (*), signos de igual (=) u otros caracteres
especiales en los nombres de archivos o variables. El shell puede interpretarlos como parte de un comando o un
modificador.
Ejemplo: Si se nombra un archivo mi documento (con espacio), manipularlo puede ser complicado.
• read como comando: Si se escribe read seguido de un espacio (y no de una variable), el shell lo interpretará como el
comando read sin argumentos, lo que puede causar errores o un comportamiento inesperado.
• Recomendación de mayúsculas: Se sugiere usar variables en MAYÚSCULAS o al menos iniciar con mayúscula (ej.
MI_VARIABLE, MiVariable). Esto ayuda a diferenciarlas de los comandos del shell (que suelen ser en minúsculas) y mejora
la legibilidad del código.
• Complicaciones con caracteres especiales: Es posible crear archivos con nombres que incluyan caracteres como * o \
(barra invertida), incluso con un signo de igual al principio (ej. \=Pepe). Sin embargo, esto complicará enormemente su
manipulación y acceso, por lo que debe evitarse.
• Espacios al final del nombre: Un error difícil de detectar puede ser que un archivo tenga un espacio al final de su
nombre, especialmente si se creó en un entorno gráfico.
Creación y edición de scripts
Un script es un archivo que contiene una secuencia de comandos ejecutables por el shell.
• Editor: Para crear o modificar un script, se utiliza un editor de texto en la terminal.
○ Nano: Es el editor recomendado (nano nombre_del_script.sh).
○ Vim/Vi: Otros editores disponibles.
• Encabezado (#!/bin/bash): Aunque no es obligatorio, es una buena práctica iniciar el script con #!/bin/bash. Esto indica al
sistema qué intérprete debe usar para ejecutar el script.
○ Este encabezado es como un "predictivo" para el script.
○ Si el script se ejecuta directamente con ./[Link] y no se especifica bash, el sistema utilizará el intérprete
definido en el encabezado.
• Nombre del archivo: Se recomienda usar la extensión .sh (e., [Link]).
Interacción con el usuario
Para obtener información del usuario dentro de un script:
Mostrar mensaje al usuario: Se utiliza echo para imprimir mensajes en la terminal.
○ Ejemplo: echo "Ingrese un nombre"
Leer entrada del usuario: Se utiliza read para capturar la entrada del usuario y almacenarla en una variable.
○ read -p "Mensaje: ": Muestra un mensaje y espera la entrada en la misma línea.
○ Ejemplo: read -p "Ingrese un nombre: " nombre_dir
Uso de variables: Las variables se referencian con el signo $ (e.j $nombre_dir).
○ Importante: Si la variable contiene múltiples palabras (con espacios), debe encerrarse entre comillas dobles al ser
usada para que se trate como una sola cadena (e.g., "Hola ¿qué tal?"). De lo contrario, cada palabra será
interpretada como un argumento separado, lo que puede causar errores.
Creación y gestión de directorios
• Crear un directorio: El comando mkdir se utiliza para crear nuevos directorios.
○ Ejemplo: mkdir $nombre_di
• Uso de variables en nombres de directorios: Si se desea crear un directorio con el valor de una variable, se debe usar el
signo $.
○ Si se usa mkdir dir, se creará un directorio llamado "dir".
○ Si se usa mkdir $dir y la variable dir contiene "mi_carpeta", se creará un directorio llamado "mi_carpeta".
• Ubicación de creación: mkdir crea el directorio en el directorio actual donde se está ejecutando el script, a menos que se
especifique una ruta absoluta o relativa.
• Manejo de rutas: Se puede especificar una ruta completa.
○ Ejemplo: mkdir /home/sandra/prueba/nueva_carpeta
• Creación de directorios intermedios: Para crear directorios padres si no existen, se usa la opción -p.
○ Ejemplo: mkdir -p /ruta/intermedia/nueva_carpeta
• Errores comunes:
○ Directorio ya existe: mkdir fallará si el directorio ya existe.
signo $.
○ Si se usa mkdir dir, se creará un directorio llamado "dir".
○ Si se usa mkdir $dir y la variable dir contiene "mi_carpeta", se creará un directorio llamado "mi_carpeta".
• Ubicación de creación: mkdir crea el directorio en el directorio actual donde se está ejecutando el script, a menos que se
especifique una ruta absoluta o relativa.
• Manejo de rutas: Se puede especificar una ruta completa.
○ Ejemplo: mkdir /home/sandra/prueba/nueva_carpeta
• Creación de directorios intermedios: Para crear directorios padres si no existen, se usa la opción -p.
○ Ejemplo: mkdir -p /ruta/intermedia/nueva_carpeta
• Errores comunes:
○ Directorio ya existe: mkdir fallará si el directorio ya existe.
○ Permisos denegados: mkdir fallará si no se tienen los permisos necesarios en la ruta especificada.
○ Nombres de directorio con $ : Si la variable dir está vacía, mkdir $dir dará error.
○ Nombres de directorio con espacios: Si la variable dir contiene "hola qué tal" y no se usan comillas (e.g., mkdir
$dir), mkdir intentará crear tres directorios ("hola", "¿qué", "tal?"), lo que probablemente generará errores.
Estructuras de control: El comando test y if/else
El comando test (o corchetes []) se utiliza para evaluar condiciones y devuelve un valor de éxito (0) si la condición es
verdadera y un valor de fallo (distinto de 0) si es falsa.
Palabras clave de if:
• if: Inicia la estructura condicional.
• then: Separa la condición de los comandos a ejecutar si es verdadera.
• elif: Opcional, para condiciones adicionales.
• else: Opcional, para comandos si ninguna condición anterior es verdadera.
• fi: Cierra la estructura condicional (if al revés).
Requisitos de espaciado:
• Debe haber al menos un espacio antes y después de [, ], then, else, elif, fi.
Palabras clave de if:
• if: Inicia la estructura condicional.
• then: Separa la condición de los comandos a ejecutar si es verdadera.
• elif: Opcional, para condiciones adicionales.
• else: Opcional, para comandos si ninguna condición anterior es verdadera.
• fi: Cierra la estructura condicional (if al revés).
Requisitos de espaciado:
• Debe haber al menos un espacio antes y después de [, ], then, else, elif, fi.
• Las palabras clave (then, else, elif, fi) deben ir en una nueva línea (no pueden ir en la misma línea que la condición o los
comandos, aunque esto es más por buenas prácticas de estilo).
• Evaluación del comando test: El comando test es muy versátil y puede evaluar:
Objetos del sistema de archivos:
• -d archivo: Verdadero si archivo es un directorio.
• -f archivo: Verdadero si archivo es un archivo regular.
• -e archivo: Verdadero si archivo existe (es un archivo o directorio).
• -ot archivo1 archivo2: Verdadero si archivo1 es más antiguo que archivo2.
• -nt archivo1 archivo2: Verdadero si archivo1 es más nuevo que archivo2.
• -r archivo: Verdadero si el usuario tiene permisos de lectura sobre archivo.
• -w archivo: Verdadero si el usuario tiene permisos de escritura sobre archivo.
• -x archivo: Verdadero si el usuario tiene permisos de ejecución sobre archivo.
• -s archivo: Verdadero si archivo no está vacío.
• -L archivo: Verdadero si archivo es un enlace simbólico.
Enteros: Se utilizan operadores específicos.
• -eq: Igual a.
• -ne: Diferente a.
• -gt: Mayor que.
• -ge: Mayor o igual que.
• -lt: Menor que.
• -le: Menor o igual que.
Cadenas:
• string1 == string2: Verdadero si string1 es igual a string2.
• string1 != string2: Verdadero si string1 es diferente a string2.
• -z string: Verdadero si string tiene longitud cero (está vacío).
• -n string: Verdadero si string tiene longitud no cero (no está vacío).
• Operadores lógicos (para combinar condiciones en test):
• -a: AND lógico.
• -o: OR lógico.
Comillas dobles en variables: Es una muy buena práctica encerrar los valores de las variables entre comillas dobles cuando se
utilizan en condiciones ("$variable"). Esto evita problemas si la variable contiene espacios o está vacía, asegurando que se
trate como una sola cadena o un valor definido.
El Comando test y la variable $?
• El comando test no imprime nada por pantalla si la condición se cumple; solo devuelve un código de salida: 0para
verdadero (éxito) y 1 (o cualquier número distinto de 0) para falso (fallo).
• Para ver el valor de retorno del último comando, se usa la variable $?.
• Si la condición de test es verdadera, $? será 0. Si es falsa, $? será 1.
Errores del comando test:
• Si test tiene un error de sintaxis, devolverá 2.
• Un error muy común es olvidar el signo $ para expandir una variable o usarlo incorrectamente. Por ejemplo, [ -d $dir ]
donde dir está vacía, test lo interpreta como [ -d ] y esto es un error de sintaxis, no una condición falsa. En este caso,
el valor de retorno será 2.
Consideraciones avanzadas y buenas prácticas
Programas recursivos: Un programa que se llama a sí mismo se denomina programa recursivo.
• Peligro: Si no se maneja una condición de salida adecuada, puede llevar a bucles infinitos y problemas de rendimiento.
Llamadas entre scripts:
• Es preferible que un script llame a otro script y, al finalizar, retome la ejecución del script original, en lugar de que el
script hijo vuelva a llamar al padre.
• Problema de llamadas mutuas: Si el script principal (script_A) llama a un script secundario (script_B), y script_B llama de
nuevo a script_A para "volver al menú", esto crea una cadena de llamadas recursivas. Cada vez que se llama de nuevo,
se añade una nueva capa de ejecución. Si el usuario decide "salir" en script_A, solo sale de la última capa, y tendría que
salir múltiples veces para cerrar todas las instancias.
Solución: El script hijo (script_B) simplemente debe finalizar su ejecución. La ejecución del script padre (script_A) continuará
automáticamente desde el punto donde llamó a script_B.
Llamadas entre scripts:
• Es preferible que un script llame a otro script y, al finalizar, retome la ejecución del script original, en lugar de que el
script hijo vuelva a llamar al padre.
• Problema de llamadas mutuas: Si el script principal (script_A) llama a un script secundario (script_B), y script_B llama de
nuevo a script_A para "volver al menú", esto crea una cadena de llamadas recursivas. Cada vez que se llama de nuevo,
se añade una nueva capa de ejecución. Si el usuario decide "salir" en script_A, solo sale de la última capa, y tendría que
salir múltiples veces para cerrar todas las instancias.
Solución: El script hijo (script_B) simplemente debe finalizar su ejecución. La ejecución del script padre (script_A) continuará
automáticamente desde el punto donde llamó a script_B.
Comando sleep:
• Permite pausar la ejecución del script por un número determinado de segundos.
• Ejemplo: sleep 10 (pausa por 10 segundos).
• Uso en bucles: Puede ser útil en bucles infinitos (while true) para monitorear un estado cada cierto tiempo, por
ejemplo.
El comando test puede tener tres estados de retorno:
• 0: Éxito (verdadero).
• 1: No éxito (falso).
• 2: Error de sintaxis (algo está mal con la forma en que se escribió el comando test).
Importante: Esto es crucial para un manejo de errores robusto, ya que no es lo mismo que una condición sea falsa a que la
condición no se pueda evaluar debido a un error.
Redirección de errores:
• Se puede redirigir la salida de errores (stderr) de un comando a /dev/null para que no se muestre por pantalla.
• comando 2>/dev/null: Redirige solo los errores a "la nada".
• comando &>/dev/null: Redirige tanto la salida estándar como los errores.
• Uso: Es útil cuando se quiere probar si un comando funciona sin que su salida o errores afecten la interfaz del usuario.
if/else y test con redirección:
code Bashdownloadcontent_copy
expand_less
IGNORE_WHEN_COPYING_START
IGNORE_WHEN_COPYING_END
if [ -d "$dir_name" ] 2>/dev/null; then
• echo "Error: el directorio '$dir_name' ya existe."
• else
• mkdir "$dir_name"
• echo "Directorio '$dir_name' creado."
• fi
En este ejemplo, si dir_name ya existe, [ -d "$dir_name" ] devuelve 1 (falso), y mkdir se ejecuta. Si dir_name no existe, [ -d
"$dir_name" ] devuelve 0 (verdadero) y se intenta crear el directorio. Si mkdir falla por permisos, test no generó el error, pero
mkdir sí lo hará.
Comparación de datos con test
El comando test es fundamental para comparar diferentes tipos de datos:
Objetos del sistema de archivos:
• -d <objeto>: Si el objeto existe y es un directorio.
• -f <objeto>: Si el objeto existe y es un archivo regular.
• -e <objeto>: Si el objeto existe (sea archivo o directorio).
• -ot <objeto1> <objeto2>: Si <objeto1> es más antiguo que <objeto2>.
• -nt <objeto1> <objeto2>: Si <objeto1> es más nuevo que <objeto2>.
Números (Enteros):
• num1 -eq num2: num1 es igual a num2.
• num1 -ne num2: num1 es distinto de num2.
• num1 -gt num2: num1 es mayor que num2.
• num1 -ge num2: num1 es mayor o igual que num2.
• num1 -lt num2: num1 es menor que num2.
• num1 -le num2: num1 es menor o igual que num2.
Cadenas de caracteres:
• "cadena1" == "cadena2": cadena1 es igual a cadena2.
• "cadena1" != "cadena2": cadena1 es distinto de cadena2.
• -z "cadena": cadena está vacía (longitud cero).
• -n "cadena": cadena no está vacía (longitud no cero).
Mezcla de tipos de comparación: Un error común es intentar comparar números con operadores de cadena (==, !=) o cadenas
con operadores numéricos (-eq, -gt). test interpretará los valores como cadenas si se usan operadores de cadena, y como
números si se usan operadores numéricos. Si los tipos no coinciden, puede dar resultados inesperados o errores de sintaxis.
El comando test con paréntesis rectos []
Los corchetes [] son un alias para el comando test. Es decir, [ <condición> ] es lo mismo que test <condición>.
"cadena1" != "cadena2": cadena1 es distinto de cadena2.
• -z "cadena": cadena está vacía (longitud cero).
• -n "cadena": cadena no está vacía (longitud no cero).
Mezcla de tipos de comparación: Un error común es intentar comparar números con operadores de cadena (==, !=) o cadenas
con operadores numéricos (-eq, -gt). test interpretará los valores como cadenas si se usan operadores de cadena, y como
números si se usan operadores numéricos. Si los tipos no coinciden, puede dar resultados inesperados o errores de sintaxis.
El comando test con paréntesis rectos []
Los corchetes [] son un alias para el comando test. Es decir, [ <condición> ] es lo mismo que test <condición>.
Comparación de cadenas (ejemplo [ "$1" == "$2" ]):
• Compara si la cadena de $1 es igual a la cadena de $2. Si la condición es verdadera, test devuelve 0.
• Si se omite el espacio entre el corchete y la cadena (e.g., [$1), o entre la cadena y el corchete (e.g., $2]), esto causará un
error de sintaxis en test.
• Errores con espacios: test es muy sensible a los espacios.
○ [ $var ] (sin $) puede generar un error si var está vacío, ya que test interpretaría [ ] como un error de sintaxis.
○ [ "$var" ] es correcto incluso si var está vacío, ya que test interpretaría [ "" ] como la condición -n "", que es falsa.
• No es if: Es importante recordar que [] es solo para evaluar la condición, no para ejecutar los comandos del if. Siempre
se necesita if para la estructura condicional completa.
Ejecución de scripts y códigos de retorno
• Códigos de retorno: Todos los comandos en Linux devuelven un código de retorno ($?):
○ 0: Éxito.
○ >0: Fallo o error.
• if y códigos de retorno: if evalúa el código de retorno del comando o test que se le proporciona.
○ Si el comando devuelve 0, if considera la condición como verdadera.
○ Si devuelve un número distinto de 0, if considera la condición como falsa.
Uso del comando while
El bucle while ejecuta un bloque de código repetidamente mientras una condición sea verdadera.
Ejemplo `while true`**: Crea un bucle infinito que se ejecuta indefinidamente. Útil para monitorear procesos o servicios.
• Se puede finalizar con `Ctrl+C`.
• sleep en bucles while: Es común usar sleep dentro de un bucle while para introducir pausas entre iteraciones.
Estructuras de control avanzadas
• case: Es el equivalente al switch/case de Java. Se utiliza para comparar una variable con múltiples patrones y ejecutar
acciones específicas.
○ Termina con esac (case al revés).
• for: Se utiliza para iterar sobre una lista de elementos (números, cadenas, archivos, etc.).
Estilo de codificación en shell script
• Identación: Es crucial para la legibilidad del código.
• Separación de comandos: Colocar then, else, elif, fi, do, done en líneas separadas es una buena práctica (aunque a veces
el shell permite ponerlos en la misma línea separados por ;).
• Comillas en variables: Siempre usar comillas dobles (") al referenciar variables para evitar problemas con espacios o
valores vacíos.
if y [] (corchetes rectos)
• if [ <condición> ]: Es la forma recomendada y más clara para las condiciones.
• if test <condición>: Es equivalente pero menos usado en scripts modernos.
• elif: Es el equivalente de else if en otros lenguajes.
El comando test y [] (corchetes)
• test es un comando en sí mismo que evalúa una condición y devuelve 0 (verdadero) o 1 (falso).
• [ es un alias de test que requiere un ] de cierre (por eso se usan juntos [ <condición> ]).
Códigos de retorno en comandos
• Todos los comandos de Linux devuelven un código de retorno ($estado = $?).
• 0: Significa que el comando se ejecutó con éxito.
• Cualquier valor distinto de 0: Significa que el comando falló o hubo un error.
• El if en Bash evalúa este código de retorno para determinar si la condición es verdadera o falsa.