Aprendiendo Operadores de Prueba de Archivos de Bash con Ejemplos – techsyncer

Bash es increíblemente flexible y ofrece varias opciones para probar archivos. Y si estás buscando una forma de probar tus archivos, los operadores de prueba de archivos en Bash te llevarán a lugares inimaginables.

En este tutorial, aprenderás diferentes operadores de prueba de archivos y cómo usarlos para verificar si un archivo existe, es legible, está vacío, y más.

Sigue leyendo y hazte amigo de los operadores de prueba de archivos en Bash.

Prerrequisitos

Este tutorial será una demostración práctica. Si quieres seguir, asegúrate de tener lo siguiente:

A Linux system with Bash installed – This tutorial uses Ubuntu 20.04.

La mayoría de las distribuciones de Linux tienen Bash instalado por defecto. Pero si estás usando Windows, puedes instalar el Subsistema de Windows para Linux (WSL) para obtener un shell de Bash.

A user account with sudo privileges to run commands as root – This tutorial uses a root account for simplicity. But using a non-root user with sudo access is always recommended.

Este tutorial asume que tienes acceso SSH a tu sistema Linux.

¿Cuáles Son los Operadores de Prueba de Archivos Bash?

Antes de ensuciarte las manos con los operadores de prueba, echa un vistazo a cómo funcionan. Los operadores de prueba de archivos te permiten verificar varios aspectos de un archivo, como si existe un archivo, si es legible/escribible, etc.

El uso de operadores de prueba de archivos puede ayudar a prevenir errores en tus scripts de Bash. El código a continuación es una plantilla para la declaración if. La declaración if-else es una herramienta potente que verás a menudo en scripts de Bash.

Recuerda que las partes then y else del bloque de código son opcionales. Puedes usar una declaración if sin ellas.

# Representa el archivo que deseas probar.
# Reemplaza file_name con el nombre del archivo objetivo a probar.
FILE="file_name"
# Operador - El operador de prueba de archivo a usar.
if [ Operator $FILE ]

then
 # Tareas a realizar si el operador devuelve verdadero.
 do something

else
 # Tareas a realizar si el operador devuelve falso.
 do something

fi

Comprobando si un Archivo Existe

Has visto un vistazo de cómo funcionan los operadores de prueba, pero eso no es suficiente para entender mejor los entresijos de su uso. Así que comienza con un ejemplo básico, como verificar si un archivo existe.

En el mundo real, es posible que desees verificar si existe un archivo de configuración antes de crear uno. No quieres perder el tiempo construyendo un archivo de configuración desde cero solo para descubrir que ya existe uno igual.

Para verificar si un archivo ya existe:

1. Abre tu terminal y ejecuta el comando touch a continuación para crear un nuevo archivo test.txt. Este comando no proporciona salida, pero verificarás el archivo en el próximo paso.

touch test.txt

2. A continuación, ejecuta el siguiente comando ls para listar el archivo recién creado (test.txt) en tu directorio de trabajo.

ls -al test.txt

La salida a continuación verifica que has creado correctamente el archivo test.txt.

Ahora que tienes un archivo de prueba, puedes usar el bloque de código base en un script de Bash para verificar si el archivo existe en los siguientes pasos.

3. Ejecuta el siguiente comando para crear (touch) y abrir un nuevo archivo de script de shell (if_file_exists.sh) en tu editor de texto preferido (nano).

touch if_file_exists.sh && nano if_file_exists.sh

4. Ahora, coloca el código a continuación en tu nuevo archivo if_file_exists.sh, guarda el archivo y cierra el editor.

Ejecuta una declaración if-else para probar si un archivo especificado existe.

Si el operador devuelve true, recibirás un mensaje diciendo que el archivo existe.

Si el operador devuelve true, recibirás un mensaje diciendo que el archivo no existe. Pero esta vez, el archivo se crea automáticamente, tomando el nombre que definiste en la variable FILE.

La línea #!/bin/bash en la parte superior del archivo se conoce como shebang. Un shebang le indica a tu sistema qué intérprete usar para ejecutar el script, en este caso, Bash. Si no incluyes un shebang, tu sistema usará el intérprete predeterminado, que podría no ser Bash. La ausencia de shebang puede hacer que tu script falle.

#!/bin/bash
# FILE - Una variable que contiene el valor del archivo que deseas probar.
# Puedes reutilizar este mismo bloque de código para probar diferentes archivos 
  # cambiando el valor de la variable $FILE.
FILE="test.txt"

# El operador -e prueba la existencia del archivo
if [ -e $FILE ]
then
  # Si el operador devuelve true, imprime un mensaje diciendo que el archivo existe.
  echo "$FILE exists"
else
  # Si el operador devuelve true, imprime un mensaje diciendo que el archivo no existe,
    # luego crea el archivo con el nombre que definiste en la variable FILE.
  echo "$FILE does not exist, creating new file" && touch test.txt
fi

5. Ejecute el siguiente comando para ejecutar su nuevo script (if_file_exists.sh)

bash if_file_exists.sh

Si todo sale bien, verá el mensaje de que test.txt existe impreso en su terminal, como se muestra a continuación.

6. A continuación, ejecute los siguientes comandos para eliminar (rm -rf) el archivo de prueba (test.txt) y listar todos los archivos en su directorio de trabajo.

rm -rf test.txt
ls test.txt

A continuación, puede verificar que el archivo test.txt ya no está en la lista.

7. Vuelva a ejecutar el siguiente comando para ejecutar su script if_file_exists.sh.

Dado que el archivo test.txt ya no existe, el script crea un nuevo archivo test.txt cuando el operador -e devuelve falso.

bash if_file_exists.sh

8. Finalmente, ejecute el comando ls a continuación para listar el archivo test.txt en su directorio de trabajo.

ls -al test.txt

La salida a continuación confirma que su script ha creado un nuevo archivo test.txt.

Comprobación de si un archivo es un archivo regular o especial

Antes de abrir o procesar un archivo, es posible que desee verificar primero si ese archivo es regular o especial. ¿Por qué? Un archivo especial es un tipo de archivo almacenado en un sistema de archivos, así que tenga cuidado de no meterse con estos archivos.

Por ejemplo, un error común al abrir un archivo especial es el error “No such file or directory”. Este error ocurre cuando el archivo que intenta abrir no existe. Pero el mismo error también puede ocurrir al abrir un archivo especial en lugar de uno regular.

Abra un nuevo archivo special_file.sh en su editor de texto, agregue el siguiente código y guarde los cambios.

El código a continuación es similar al anterior. Pero este código utiliza el operador -f en lugar del operador -e. El operador -f prueba si un archivo especificado (/dev/vmmon) es un archivo regular.

#!/bin/bash
# El archivo /dev/vmmon es un archivo especial
  # usado para comunicarse con dispositivos de hardware en Linux.
FILE="/dev/vmmon"

# Prueba si el archivo 
if [ -f $FILE ]
then
  # Si el operador devuelve verdadero, recibirás un mensaje que dice
    # el archivo es un archivo regular.
  echo "$FILE is a regular file"

else
  # Si el operador devuelve verdadero, recibirás un mensaje que dice 
    # que el archivo no existe o es un archivo regular.
  echo "Either $FILE does not exist or is not a regular file"

fi

Ahora, ejecuta el comando a continuación para ejecutar tu script special_file.sh.

bash special_file.sh

Dado que el archivo (/dev/vmmon) especificado en la variable FILE es un archivo especial, obtendrás el siguiente mensaje.

Verificando si un Directorio Existe

Hasta ahora, has aprendido cómo verificar si un archivo existe. ¿Pero aplica el mismo método para directorios? Sí, utilizando el operador de prueba -d. Este operador es útil si planeas tomar acciones en función de si un directorio existe o no.

Tal vez quieras copiar todos los archivos de un directorio a otro. Si el directorio de destino no existe, puedes crearlo antes de copiar los archivos.

1. Ejecute el comando ls a continuación para listar el ejemplo-dir desde el directorio de trabajo.

ls -la example-dir

Obtendrá un mensaje que dice No existe el archivo o directorio ya que el directorio no existe. Si no desea que su flujo se interrumpa simplemente porque un directorio no existe, vaya al siguiente paso.

Listing the *example-dir* from the working directory

2. A continuación, abra un nuevo archivo llamado if_dir_exists.sh en su editor de texto, agregue el código a continuación y guarde el archivo. El siguiente código prueba si existe un directorio especificado y realiza tareas dependiendo de qué valor devuelva el operador -d.

Puede lograr el mismo resultado cambiando los if y else statements usando el operador de negación (!). En situaciones del mundo real, el operador ! puede ayudar a escribir un script más limpio y conciso.

#!/bin/bash
# Define el nombre del directorio en la variable dir
dir=example_dir

# Prueba si el directorio (dir) existe
if [ ! -d $dir ]
then
  # Si el operador devuelve verdadero, crea un directorio contra el valor de la variable dir
  mkdir $dir
  # Copia el archivo test.txt al directorio recién creado
  cp test.txt $dir
  # Imprime un mensaje sobre las tareas realizadas anteriormente.
  echo "The directory has been created, and the test.txt file has been copied."
else
  # Si el operador devuelve falso, 
    # el comando echo imprime un mensaje diciendo que el directorio existe.
  echo "Directory $dir exists"
fi

3. Ahora, ejecute el comando a continuación para ejecutar su script (if_dir_exists.sh)

bash if_dir_exists.sh

Puedes ver el mensaje que dice que el directorio ha sido creado y que el archivo test.txt ha sido copiado ya que el directorio example_dir no existe.

Executing the *if_dir_exists.sh* to test if a directory exists

4. Finalmente, ejecuta el comando ls contra el directorio example_dir para confirmar que el directorio existe y contiene el archivo test.txt.

ls -la example_dir

Confirming the *example_dir* directory exists and contains the *test*.txt file

Comprobando Si un Archivo Está Vacío

Ya sabes cómo utilizar los tres operadores de prueba de archivo más utilizados (-e, -f y -d) para mejorar tus habilidades de scripting. Pero aún hay otros operadores que te encantaría explorar.

Por lo general, en lugar de resaltar el contenido de un archivo para copiarlo a otro archivo, ejecutarías un comando para que haga el trabajo por ti. Pero espera un momento, ya que es posible que tu archivo de destino no esté vacío.

¿Por qué no usar el operador -s para comprobar si un archivo existe y no está vacío? Este operador devuelve verdadero si el archivo existe y tiene un tamaño mayor que cero.

1. Abre un nuevo archivo llamado empty_file.sh en tu editor de texto, añade el siguiente código y guarda el archivo.

El siguiente código prueba si un archivo especificado está vacío e imprime un mensaje dependiendo del valor que devuelva el operador -s.

#!/bin/bash
# Define el nombre del archivo de destino
FILE=test.txt

# El operador -s verifica si el archivo de destino existe y no está vacío
if [ -s $FILE ]
then
  # Si el operador devuelve verdadero, el comando echo imprime un mensaje
    # diciendo que el archivo existe y no está vacío.
  echo "$FILE exists and is not empty"
else
  # Si el operador devuelve falso, el comando echo imprime un mensaje 
    # diciendo que el archivo no existe o está vacío.
  echo "$FILE either does not exist or is empty"
  # Agregar texto al archivo de destino
  echo "This is a test. This is not an empty file" > $FILE
fi

2. Ahora, ejecuta el siguiente comando para ejecutar tu script (empty_file.sh).

bash empty_file.sh

A continuación, puedes ver el mensaje que indica que test.txt no existe o está vacío. Pero al mismo tiempo, el script agrega texto al archivo test.txt.

Executing the *empty_file.sh* file to test if the *text.txt* file is empty

3. Ejecuta el comando cat a continuación para verificar que el archivo test.txt contenga el texto agregado.

cat test.text

4. Finalmente, vuelve a ejecutar el siguiente comando bash para ejecutar el script empty_file.sh.

bash empty_file.sh

A continuación, puedes ver que la salida cambió a test.txt existe y no está vacío, ya que el archivo test.txt ahora contiene algún texto y tiene un tamaño mayor que cero (0).

Rerunning the *empty_file.sh* script to check if the *test.txt* file is empty

Comprobando si un Archivo Existe y es Legible

Tal vez tu automatización involucre la lectura de archivos para realizar tareas. El éxito de esas tareas dependerá de si los archivos son legibles. Escribir un script para verificar si un archivo existe y es legible será útil como solución.

Para demostrar la comprobación de la existencia y legibilidad de un archivo:

1. Ejecute el siguiente comando para iniciar sesión en otra cuenta de usuario (ata).

su - ata

Su indicador cambia ($) para indicar que ha iniciado sesión como el otro usuario.

Alternativamente, puede cambiar los permisos del archivo a legible, escribible o ambos con el comando chmod.

2. Una vez iniciada la sesión, cree un nuevo archivo llamado readable_file.sh con su editor de texto

Agregue el siguiente código al archivo readable_file.sh, y guarde los cambios. Este código verifica si existe y es legible un archivo llamado test.txt en el directorio /root.

#!/bin/bash
# Definir el archivo objetivo
FILE=test.txt

# Comprobar si el archivo objetivo es legible.
# Puede cambiar -r a -w para comprobar si un archivo es escribible en su lugar.
if [ -r $FILE ] 
then  
  # Si el operador devuelve verdadero, imprima un mensaje que indique
    # que el archivo existe y es legible.
  echo "$FILE exists and is readable" 
else  
  # Si el operador devuelve falso, imprima un mensaje que indique
    # que el archivo no existe o no es legible.
  echo "$FILE does not exist or is unreadable"
fi

3. Ahora, ejecute el siguiente comando para ejecutar el script readable_file.sh.

bash readable_file.sh

En esta ocasión, verás un mensaje que dice que /root/test.txt no existe o no se puede leer. Dado que el archivo text.test está ubicado en el directorio /root, el usuario actual (ata) no tiene permisos de lectura para el archivo text.txt.

4. Finalmente, ejecuta los siguientes comandos para realizar lo siguiente:

Cambia el archivo sudoers para permitir que el usuario actual (ata) use sudo para ejecutar comandos elevados.

Ejecuta el script readable_file.sh, que prueba si un archivo específico es legible.

sudo bash
bash readable_file.sh

Puedes ver a continuación que la salida imprime que test.txt existe y se puede leer porque el usuario ata ahora tiene permisos de lectura para el archivo test.txt.

Changing the sudoers file and executing the *readable_file.sh* script

Conclusión

A testing phase is always a priority before making drastic changes, whether on files or directories on your system. And in this tutorial, you’ve learned about the Bash file test operators and how to use them to test if a file (regular or special) or directory exists or if a file is readable or not.

Con estas habilidades recién adquiridas, puedes decidir con confianza qué acción tomar basándote en el resultado de las pruebas. Pero hay muchas otras formas en las que puedes utilizar los operadores de prueba de archivos Bash.

¿Por qué no intentar verificar la extensión de un archivo? ¿O tal vez verificar si existen varios archivos para asegurarte de que todos los archivos que necesitas estén disponibles?