Operaciones del sistema de archivos en la shell

Introducción

En este laboratorio, aprenderás cómo realizar diversas pruebas de archivos en la shell. Las pruebas de archivos son herramientas esenciales para verificar las propiedades de archivos y directorios en el sistema de archivos. Al final de este laboratorio, estarás familiarizado con los comandos comunes de prueba de archivos y su uso, que son habilidades fundamentales para trabajar con archivos en entornos Linux.

Skills Graph

Creación de un archivo de prueba

Antes de comenzar con las operaciones de archivos, es importante entender nuestro entorno de trabajo. En Linux, siempre estás trabajando dentro de un directorio específico, y es crucial saber dónde te encuentras en el sistema de archivos.

1. Abre una terminal en el WebIDE. Aquí es donde escribirás tus comandos.

2. Crea un nuevo archivo llamado test_file.txt:

   touch test_file.txt

   El comando touch se utiliza para crear un archivo vacío. Si el archivo ya existe, actualiza la marca de tiempo del archivo sin cambiar su contenido.

3. Agrega algún contenido al archivo:

   echo "This is a test file for our lab." > test_file.txt

   Este comando utiliza echo para mostrar el texto y > para redirigir esa salida al archivo. Ten cuidado con >, ya que sobrescribirá cualquier contenido existente en el archivo.

4. Verifica el contenido del archivo:

   cat test_file.txt

   cat es la abreviatura de "concatenar", pero a menudo se utiliza para mostrar el contenido de un archivo. Deberías ver el mensaje "This is a test file for our lab."

Si cometemos un error o deseas comenzar de nuevo, siempre puedes eliminar el archivo con rm test_file.txt y comenzar de nuevo desde el paso 1.

Prueba de existencia de archivos

Ahora que hemos creado un archivo, aprendamos cómo verificar si un archivo existe. Esta es una tarea común en los scripts de shell, especialmente cuando se necesitan realizar operaciones en archivos.

1. Crea un nuevo archivo de script llamado file_exists.sh:

   touch file_exists.sh

2. Agrega el siguiente contenido al archivo:

   #!/bin/bash
   
   filename="test_file.txt"
   if [ -e "$filename" ]; then
     echo "$filename exists"
   else
     echo "$filename does not exist"
   fi

   Analicemos esto:

   • #!/bin/bash se llama shebang. Le dice al sistema que este es un script de bash.
   • Establecemos una variable filename con el valor "test_file.txt".
   • La declaración if verifica si el archivo existe. -e es una prueba que devuelve verdadero si el archivo existe.
   • Usamos echo para imprimir un mensaje según si el archivo existe o no.

3. Guarda el archivo y sal del editor.

4. Haz el script ejecutable:

   chmod +x file_exists.sh

5. Ejecuta el script:

   ./file_exists.sh

   Deberías ver la salida: "test_file.txt exists"

6. Ahora, probemos con un archivo que no existe. Primero, cambiaremos el nombre de nuestro archivo de prueba:

   mv test_file.txt non_existent.txt

   Este comando cambia el nombre de test_file.txt a non_existent.txt.

7. Modifica el script para verificar el nombre de archivo original "test_file.txt":

   nano file_exists.sh

   Cambia la variable filename a "test_file.txt" si no está ya configurada con ese valor.

8. Ejecuta el script nuevamente:

   ./file_exists.sh

   Deberías ver la salida: "test_file.txt does not exist"

Este script demuestra cómo verificar la existencia de un archivo, lo cual es crucial cuando tu script necesita trabajar con archivos que pueden o no estar presentes.

Prueba de existencia de directorios

Similar a la prueba de existencia de archivos, también podemos verificar si un directorio existe. Esto es útil cuando tu script necesita trabajar con directorios que pueden o no estar presentes.

1. Crea un nuevo archivo de script llamado dir_exists.sh:

   touch dir_exists.sh

2. Agrega el siguiente contenido al archivo:

   #!/bin/bash
   
   dirname="test_directory"
   if [ -d "$dirname" ]; then
     echo "$dirname exists"
   else
     echo "$dirname does not exist"
   fi

   Este script es muy similar al script de existencia de archivos, pero utiliza -d en lugar de -e. La prueba -d verifica específicamente la existencia de un directorio.

3. Guarda el archivo y sal del editor.

4. Haz el script ejecutable:

   chmod +x dir_exists.sh

5. Ejecuta el script:

   ./dir_exists.sh

   Deberías ver la salida: "test_directory does not exist"

6. Ahora, creemos el directorio y ejecutemos el script nuevamente:

   mkdir test_directory
   ./dir_exists.sh

   Ahora deberías ver la salida: "test_directory exists"

   mkdir es el comando para crear un nuevo directorio.

Este script demuestra cómo verificar la existencia de un directorio. Esto puede ser especialmente útil en scripts que necesitan crear, modificar o eliminar directorios.

Prueba de permisos de archivos

En Linux, cada archivo y directorio tiene permisos asociados que determinan quién puede leer, escribir o ejecutarlos. En este paso, aprenderemos cómo verificar los permisos de un archivo, específicamente si un archivo es legible.

1. Primero, cambiemos el nombre de nuestro archivo a su nombre original:

   mv non_existent.txt test_file.txt

2. Crea un nuevo archivo de script llamado file_readable.sh:

   touch file_readable.sh

3. Agrega el siguiente contenido al archivo:

   #!/bin/bash
   
   filename="test_file.txt"
   if [ -r "$filename" ]; then
     echo "You have read permission for $filename"
   else
     echo "You do not have read permission for $filename"
   fi

   Este script utiliza la prueba -r, que verifica si el archivo es legible por el usuario actual.

4. Guarda el archivo y sal del editor.

5. Haz el script ejecutable:

   chmod +x file_readable.sh

6. Ejecuta el script:

   ./file_readable.sh

   Deberías ver la salida: "You have read permission for test_file.txt"

7. Ahora, eliminemos el permiso de lectura y ejecutemos el script nuevamente:

   chmod -r test_file.txt
   ./file_readable.sh

   Ahora deberías ver la salida: "You do not have read permission for test_file.txt"

   chmod -r elimina los permisos de lectura del archivo.

8. Restaura el permiso de lectura:

   chmod +r test_file.txt

   Es importante restaurar los permisos para no dejar accidentalmente nuestro archivo ilegible.

Este script demuestra cómo verificar los permisos de un archivo. Comprender y gestionar los permisos de archivos es crucial para la seguridad del sistema y el correcto funcionamiento de los scripts.

Resumen

En este laboratorio, has aprendido cómo realizar operaciones esenciales del sistema de archivos en la shell. Has creado scripts para probar la existencia de archivos y directorios, así como los permisos de los archivos. Estas habilidades son fundamentales para trabajar con archivos y directorios en entornos Linux y forman la base para tareas de scripting de shell más complejas.

Has practicado:

1. Comprender tu entorno de trabajo
2. Crear y manipular archivos
3. Escribir y ejecutar scripts de shell
4. Probar la existencia de archivos y directorios
5. Verificar los permisos de los archivos

Estas habilidades serán valiosas a medida que sigas trabajando con sistemas Linux y desarrolles scripts de shell más avanzados. Recuerda siempre comprobar la existencia de archivos y directorios antes de realizar operaciones en ellos para evitar errores en tus scripts. Además, ten en cuenta los permisos de los archivos cuando trabajes con datos sensibles o archivos del sistema.

A medida que avances, es posible que desees explorar pruebas de archivos más avanzadas, aprender sobre otras estructuras de scripting de shell como bucles y funciones, y practicar la combinación de estos conceptos para crear scripts más complejos y potentes.