Comando test en Linux: evaluar condiciones y expresiones en scripts

El comando test es una gran herramienta para probar condiciones. Basándose en la variable de retorno del comando test, se pueden armar lógicas de programación para ejecutar algo si una condición se cumple o no.

Puede probar condiciones en archivos, permisos, textos, números, e incluso a través de expresiones, y proporciona el resultado mediante la variable de retorno $?.

En este ejemplo el comando test verifica si 1 es menor que 2 (-lt = less than - menor que):

$ test 1 -lt 2 $ echo $?0

Como la variable de retorno fue 0, el número 2 es menor que 1.

En este otro ejemplo él prueba con el "-d" si el archivo /usr/src es un directorio:

$ test –d /usr/src$ echo $?0

Las opciones más comunes del comando test son:

Opción	Para qué sirve	Ejemplo
-d /directorio	Verifica si un archivo es un directorio y si existe	$ test -d /etc
-e archivo	Verifica si un archivo existe, independientemente de su tipo	$ test -e /etc/passwd
-f archivo	Verifica si un archivo existe y si es común	$ test -f /etc/passwd
-z archivo	Verifica si el archivo está vacío	$ test -z /etc/groups
-n "$variable"	Verifica si el tamaño de un texto es mayor que cero	$ test -n "$LIBRO"
-s archivo	Verifica si un archivo existe y si su tamaño es mayor que cero	$ test -s /etc/passwd
s1 = s2	Verifica si un texto es igual a otro	$ test "$LIBRO" = "Certificación Linux"
s1 != s2	Verifica si un texto es diferente de otro	$ test "$LIBRO" != "Certificación Linux"
x -eq y	Verifica si un número x es igual a y	$ VAR=10 ; test $VAR -eq 10
x -gt y	Verifica si un número x es mayor que y	$ VAR=10 ; test $VAR -gt 9
x -lt y	Verifica si un número x es menor que y	$ VAR=10 ; test $VAR -lt 11
x -ne y	Verifica si un número x no es igual a y	$ VAR=10 ; test $VAR -ne 11
x -ge y	Verifica si un número x es mayor o igual a y	$ VAR=10 ; test $VAR -ge 9
x -le y	Verifica si un número x es menor o igual a y	$ VAR=10 ; test $VAR -le 11
expresión -a expresión	Verifica si ambas expresiones son verdaderas	$ test 10 -ge 9 -a 22 -gt 10; echo $?
expresión -o expresión	Verifica si una O expresión son verdaderas	$ test 10 -ge 11 -o 22 -gt 10; echo $?
archivo1 -nt archivo2	Verifica si archivo1 fue modificado después de archivo2 (más nuevo)	$ test archivo1 -nt archivo2
archivo1 -ot archivo2	Verifica si archivo1 fue modificado antes de archivo2 (más viejo)	$ test archivo1 -ot archivo2
-r archivo	Verifica si el archivo tiene permiso de lectura	$ test -r archivo
-w archivo	Verifica si el archivo tiene permiso de escritura	$ test -w archivo
-x archivo	Verifica si el archivo tiene permiso de ejecución	$ test -x archivo
-O archivo	Verifica si eres el dueño del archivo	$ test -O archivo

Uso de [  ] en lugar del "test"

El comando test puede ser abreviado con corchetes [  ]. Observe que debe haber un espacio entre la expresión y los corchetes:

$ [ 10 -ge 8 ]$ echo $?0

Operadores || y &&

Los operadores (pipe pipe) II y && sirven para verificar si la expresión a la derecha retorna verdadero o falso.

El operador && verifica si algo que está a su derecha es verdadero, y de ser así ejecuta el comando a su izquierda.

En este ejemplo, forzamos el retorno verdadero con el comando "true" que siempre retornará verdadero:

$ true && echo "Deu certo"Deu certo

Si usamos el comando "false", que siempre retorna falso, el operador && no va a ejecutar el comando a la izquierda:

$ false && echo "Deu certo"

El operador II verifica si algo que está a su derecha es falso, y de ser así ejecuta el comando a su izquierda.

En este ejemplo, forzamos el retorno verdadero con el comando true. En este caso, el II no va a ejecutar nada.

$ true || echo "Deu certo"

Ahora bien, forzando el retorno falso con el comando false, el II ejecuta el comando echo:

$ false || echo "Deu certo"Deu certo

Los operadores && e II también pueden ser usados juntos:

$ test 100 -gt 99 && echo "SIM" || echo "NÃO"

En este caso retornará SÍ porque 100 es mayor que 99.

Control de flujo con if (si)

Los controles de flujo (if) son comandos que prueban algunas alternativas y, de acuerdo con el resultado, ejecutan comandos.

La lógica del comando if es "si esto es verdadero, haga esto, si no, haga aquello". Vea el ejemplo:

if [ $? = 0 ]; then 	echo ‘O comando foi completado com sucesso...’else 	echo ‘O comando falhou.’fi

En este ejemplo el if prueba si el contenido de la variable de retorno $? es 0. En caso positivo, ejecuta el comando echo "El comando fue completado con éxito...". Si la condición es falsa, ejecuta el comando echo "El comando falló.".

Diferente de otros lenguajes, el if prueba un comando y no una condición. Por lo tanto, debemos utilizar el comando test en conjunto con el if. Generalmente se escribe usando el atajo de los corchetes [  ] para el comando test.

Control de flujo con case

El case es una forma inteligente de comparar el valor de algo con varios patrones.

Caso una ocurrencia sea positiva, él permite que se ejecuten comandos.

Cada case es una expresión que corresponde a un patrón.

El operador ")" termina una lista de patrones e inicia una lista de comandos.

Lo que separa un patrón de otro es ";;".

Al final del case, se debe terminar con la instrucción esac (case al revés).

Ejemplo de un script que dependiendo del UID del usuario imprime un mensaje diferente:

#!/bin/bashID=$(id -u)case "$ID" in   0)      echo "Você é o root.";      echo "Parabens!"   ;;   1000)      echo "Você é o Uirá."   ;;   100[1-9])      echo "Vocé é outro usuário"esacecho "fim";

Si el valor de la variable ID es 0, imprimirá un mensaje de felicitación. Si es igual a 1000, imprime "eres el Uirá". Si está entre 1001 y 1009, imprime "Eres otro usuario".

Si se ejecuta con el usuario uira, que tiene el UID igual a 1000:

$ ./meucase Você é o Uirá.fim

Si se ejecuta como root:

$ sudo ./meucase Você é o root.Parabens!fim

El case es mejor que usar varias veces el comando "if" para comparar algo con varios patrones.

Loops con el comando for

$ for algo; do comando; comando2; done

El shell posee estructuras para probar condiciones y ejecutar determinadas secuencias de programas varias veces (loop), hasta que la condición probada se satisfaga.

Los tres comandos que posibilitan esto son el for (hasta que), el while (mientras sea verdadero) y until (mientras sea falso).

El comando for permite que los bucles (loops) se hagan para que uno o más comandos se ejecuten hasta que una determinada variable recorra todos los valores de una lista dada.

Vea un ejemplo simple:

$ for numero in um dois três quatro cincodoecho "Contando: $numero"done 

Contando: um
Contando: dois
Contando: três
Contando: quatro
Contando: cinco

El mismo comando puede ser escrito en una sola línea:

$ for numero in um dois três quatro cinco; do echo "Contando: $numero"; done

Vea el ejemplo:

$ ls -1 > lista_arquivos.txt

Ahora se puede usar el for para ejecutar diversos comandos para cada archivo de la lista:

$ for i in $(cat lista_arquivos.txt); do cp $i $i.backup; mv $i.backup /tmp/backup; done;

Este bucle asigna a la variable $i cada línea del archivo lista_archivos.txt.

La expresión $(comando) genera una lista con el resultado del comando. Tiene el mismo efecto que utilizar el comando entre comillas invertidas: `comando`.

Luego ejecuta los comandos para renombrar y mover los archivos hasta que la lista esté completa.

Ahora un ejemplo un poco más complejo, con uso del for con if:

$ for i in `ls -1`; do if test -f $i;  then echo “$i é um arquivo “; else echo “$i não é um arquivo”; fi ; done

Desktop não é um arquivoDocuments não é um arquivoDownloads não é um arquivoHR_PROFESSOR.sql é um arquivo

En esta línea, el resultado del comando ls -1 se coloca en la variable $i; Luego cada línea de la variable $i se prueba para saber si es un archivo; si es verdadero, se mostrará una frase y, si es falso, otra frase.

Loops con el comando while

$ while [ expresión ] ; do comando; comando; done

El while prueba continuamente una expresión, hasta que una expresión tenga variable de retorno igual a cero o verdadero.

En este ejemplo, la variable $i obtiene el valor inicial igual a cero.

Mientras (while) la condición del comando test representado por los [ ] retorne cero (verdadero), el bucle del loop continuará ejecutándose.

En el bucle la variable $i es incrementada, hasta que $i alcance la condición de no ser menor que 4:

$ i=0
$ while [ $i -lt 4 ]; do echo "conta $i" ; i=$[$i+1]; doneconta 0conta 1conta 2conta 3

El while necesita tener una condición de salida satisfecha, de lo contrario quedará en loop infinito.

Loops con el comando until

El comando until es lo inverso al comando while, pero ejecuta algo mientras el test sea falso, o con valores diferentes de cero.

Su sintaxis es:

until [CONDIÇÃO]do  [COMANDOS]done

Ejemplo:

#!/bin/bashcounter=0until [ $counter -gt 3 ]do  echo Counter: $counter  ((counter++))done

Al ejecutarse:

$ ./contador Counter: 0Counter: 1Counter: 2Counter: 3

El until es útil para hacer que un script espere hasta que un comando no retorne más error, ya que solo se ejecuta si el retorno del test es diferente de cero.

El código cero de salida de un programa generalmente indica que fue ejecutado con éxito.

En este ejemplo, el comando until se usa para esperar hasta que el host consiga hacer ping al IP 8.8.8.8. Cuando el comando ping consiga hacer ping al host 8.8.8.8, retornará cero, haciendo que el procesamiento deje el loop:

#!/bin/bash
until ping -c 1 8.8.8.8 &>/dev/null
do
    echo "Esperando a rede..."
    sleep 1
done
echo "A rede está no ar"

Aprenda mucho más sobre Linux en nuestro curso en línea. Puedes realizar la inscripción aquí. Si ya tienes una cuenta, o quieres crear una, simplemente ingresa o crea tu usuario aquí.

¿Te gustó? Comparte