Operaciones lógicas en Linux

Introducción

Bienvenido al laboratorio de operaciones lógicas en Linux. En este laboratorio, aprenderá sobre las operaciones lógicas en Linux, que son herramientas esenciales para controlar el flujo de ejecución de comandos y tomar decisiones en los scripts.

Las operaciones lógicas le permiten combinar comandos y condiciones, lo que le permite crear scripts más sofisticados que pueden responder a diferentes situaciones. Al final de este laboratorio, entenderá cómo utilizar operadores lógicos para controlar la ejecución de comandos y verificar los atributos de archivos en Linux.

Skills Graph

Comprender las operaciones lógicas básicas en Linux

La shell de Linux proporciona varias formas de combinar comandos y condiciones utilizando operadores lógicos. En este paso, aprenderá sobre los operadores lógicos más comúnmente utilizados: && (AND) y || (OR).

Primero, naveguemos hasta nuestro directorio de proyecto:

cd ~/project

Comencemos creando algunos archivos de prueba que usaremos a lo largo de este laboratorio:

touch treasure_map.txt shield.txt kings_gauntlet.txt

Ahora, creemos un script para demostrar las operaciones lógicas básicas. Usaremos el editor de texto nano para crear un archivo llamado logic_basics.sh:

nano logic_basics.sh

En este script, usaremos operadores lógicos para verificar si dos archivos existen. Escriba o pegue el siguiente código en el editor:

#!/bin/bash

## This script demonstrates logical AND (&&) and OR (||) operators
## It checks if two specific files exist in the current directory

if [[ -f "treasure_map.txt" ]] && [[ -f "shield.txt" ]]; then
  echo "Both files exist. Proceed with the mission."
else
  echo "One or both files are missing. Abort the mission!"
fi

El operador && significa "AND" - ambas condiciones deben ser verdaderas para que la condición general sea verdadera.
La prueba -f verifica si un archivo existe y es un archivo regular (no un directorio u otro tipo de archivo especial).

Para guardar el archivo en nano, presione Ctrl+X, luego presione Y para confirmar el guardado y presione Enter para confirmar el nombre del archivo.

Ahora, hagamos el script ejecutable y ejecutémoslo:

chmod +x logic_basics.sh
./logic_basics.sh

Debería ver la salida:

Both files exist. Proceed with the mission.

Intentemos otro ejemplo para entender mejor los operadores lógicos. Cree un nuevo script llamado logical_or.sh:

nano logical_or.sh

Agregue el siguiente contenido:

#!/bin/bash

## This script demonstrates the logical OR (||) operator
## It checks if at least one of two files exists

if [[ -f "treasure_map.txt" ]] || [[ -f "nonexistent_file.txt" ]]; then
  echo "At least one file exists."
else
  echo "Neither file exists."
fi

El operador || significa "OR" - si cualquiera de las condiciones es verdadera, la condición general es verdadera.

Guarde el archivo (Ctrl+X, Y, Enter), hágalo ejecutable y ejecútelo:

chmod +x logical_or.sh
./logical_or.sh

Salida:

At least one file exists.

Esto demuestra que, aunque "nonexistent_file.txt" no existe, la condición sigue siendo verdadera porque "treasure_map.txt" sí existe.

Operaciones lógicas con permisos de archivos

En Linux, los permisos de archivo controlan quién puede leer, escribir o ejecutar archivos. En este paso, aprenderá cómo utilizar operaciones lógicas para verificar los permisos de archivo.

Primero, creemos un script llamado permission_check.sh:

nano permission_check.sh

Agregue el siguiente contenido al script:

#!/bin/bash

## This script checks read and write permissions on a file
## using logical operators

filename="kings_gauntlet.txt"

if [[ -r "$filename" ]] && [[ -w "$filename" ]]; then
  echo "You have read and write permissions on $filename."
elif [[ -r "$filename" ]] || [[ -w "$filename" ]]; then
  echo "You have limited permissions on $filename."
else
  echo "You do not have permissions on $filename."
fi

En este script:

• -r prueba si un archivo es legible por el usuario actual
• -w prueba si un archivo es escribible por el usuario actual
• El operador && requiere que ambas condiciones sean verdaderas
• El operador || requiere que al menos una condición sea verdadera

Guarde el archivo (Ctrl+X, Y, Enter) y hágalo ejecutable:

chmod +x permission_check.sh

Ahora, modifiquemos los permisos de nuestro archivo de prueba y veamos cómo afecta la salida de nuestro script.

Primero, establezcamos los permisos para permitir tanto la lectura como la escritura:

chmod 600 kings_gauntlet.txt
./permission_check.sh

Salida:

You have read and write permissions on kings_gauntlet.txt.

Ahora, cambiemos los permisos a solo lectura:

chmod 400 kings_gauntlet.txt
./permission_check.sh

Salida:

You have limited permissions on kings_gauntlet.txt.

Finalmente, eliminemos todos los permisos:

chmod 000 kings_gauntlet.txt
./permission_check.sh

Salida:

You do not have permissions on kings_gauntlet.txt.

No olvide restaurar permisos razonables al archivo:

chmod 600 kings_gauntlet.txt

Encadenamiento de comandos con operadores lógicos

Los operadores lógicos en Linux no se limitan a las declaraciones condicionales en los scripts; también se pueden utilizar directamente en la línea de comandos para encadenar comandos. En este paso, aprenderá cómo utilizar operadores lógicos para el encadenamiento de comandos.

El operador && le permite ejecutar un segundo comando solo si el primer comando tiene éxito (devuelve un estado de salida igual a cero). Esto es útil para ejecutar una secuencia de comandos en la que cada paso depende del éxito del paso anterior.

Intentemos un ejemplo sencillo:

mkdir -p test_dir && echo "Directory created successfully"

El comando mkdir -p crea un directorio (y los directorios padre si es necesario), y la opción -p evita un error si el directorio ya existe. El comando echo se ejecuta solo si el comando mkdir tiene éxito.

Salida:

Directory created successfully

Ahora, intentemos el operador ||, que ejecuta el segundo comando solo si el primer comando falla:

ls nonexistent_file.txt || echo "File not found"

Dado que "nonexistent_file.txt" no existe, el comando ls falla y se ejecuta el comando echo.

Salida:

ls: cannot access 'nonexistent_file.txt': No such file or directory
File not found

También puede combinar múltiples comandos utilizando estos operadores. Cree un script llamado command_chain.sh:

nano command_chain.sh

Agregue el siguiente contenido:

#!/bin/bash

## This script demonstrates chaining commands with logical operators

echo "Starting command chain..."

## Create a directory and enter it only if creation succeeds
mkdir -p logic_test && cd logic_test && echo "Changed to new directory"

## Create a file and write to it only if creation succeeds
touch test_file.txt && echo "This is a test" > test_file.txt && echo "Created and wrote to file"

## Try to read a nonexistent file, or display an error message
cat nonexistent.txt || echo "Failed to read file"

## Return to the original directory
cd .. && echo "Returned to original directory"

echo "Command chain completed"

Guarde el archivo (Ctrl+X, Y, Enter), hágalo ejecutable y ejecútelo:

chmod +x command_chain.sh
./command_chain.sh

Salida:

Starting command chain...
Changed to new directory
Created and wrote to file
cat: nonexistent.txt: No such file or directory
Failed to read file
Returned to original directory
Command chain completed

Este script demuestra cómo los operadores lógicos pueden controlar el flujo de ejecución de los comandos en función del éxito o fracaso de los comandos anteriores.

Operadores avanzados de prueba de archivos

Linux proporciona una variedad de operadores de prueba de archivos que se pueden combinar con operadores lógicos. En este paso, aprenderá sobre algunos de los operadores de prueba de archivos más útiles.

Creemos un script que demuestre estos operadores:

nano file_tests.sh

Agregue el siguiente contenido:

#!/bin/bash

## This script demonstrates various file testing operators in Linux

## Check if a file exists (as a file, directory, or other type)
file_to_check="treasure_map.txt"
directory_to_check="test_dir"

echo "--- Basic File Tests ---"
## -e checks if the file exists (any type)
if [[ -e "$file_to_check" ]]; then
  echo "$file_to_check exists"
else
  echo "$file_to_check does not exist"
fi

## -f checks if it's a regular file (not a directory or device)
if [[ -f "$file_to_check" ]]; then
  echo "$file_to_check is a regular file"
fi

## -d checks if it's a directory
if [[ -d "$directory_to_check" ]]; then
  echo "$directory_to_check is a directory"
else
  echo "$directory_to_check is not a directory"
fi

echo "--- File Size Tests ---"
## -s checks if file is not empty (has a size greater than zero)
if [[ -s "$file_to_check" ]]; then
  echo "$file_to_check is not empty"
else
  echo "$file_to_check is empty"
fi

echo "--- Permission Tests ---"
## -r, -w, -x check read, write, and execute permissions
if [[ -r "$file_to_check" ]]; then
  echo "$file_to_check is readable"
fi

if [[ -w "$file_to_check" ]]; then
  echo "$file_to_check is writable"
fi

if [[ -x "$file_to_check" ]]; then
  echo "$file_to_check is executable"
else
  echo "$file_to_check is not executable"
fi

echo "--- Combining Tests with Logical Operators ---"
## Combining tests with AND (&&)
if [[ -f "$file_to_check" ]] && [[ -r "$file_to_check" ]]; then
  echo "$file_to_check is a readable file"
fi

## Combining tests with OR (||)
if [[ -f "$file_to_check" ]] || [[ -d "$file_to_check" ]]; then
  echo "$file_to_check is either a file or a directory"
fi

Guarde el archivo (Ctrl+X, Y, Enter), hágalo ejecutable y ejecútelo:

chmod +x file_tests.sh
./file_tests.sh

La salida mostrará los resultados de varias pruebas de archivos en nuestros archivos y directorios existentes.

Para hacer las pruebas más interesantes, agreguemos algo de contenido a nuestro archivo treasure_map.txt y creemos el directorio que estamos probando:

echo "This is a treasure map!" > treasure_map.txt
mkdir -p test_dir

Ahora ejecute el script nuevamente:

./file_tests.sh

Ahora debería ver una salida diferente ya que el archivo tiene contenido y el directorio existe.

Este script demuestra cómo usar varios operadores de prueba de archivos y combinarlos con operadores lógicos para crear comprobaciones de archivos sofisticadas.

Resumen

En este laboratorio, ha aprendido sobre las operaciones lógicas en Linux y cómo se pueden utilizar para controlar el flujo de ejecución de comandos y el comportamiento de los scripts. Aquí está un resumen de lo que ha aprendido:

1. Ha aprendido sobre los operadores lógicos básicos && (AND) y || (OR) y cómo utilizarlos en declaraciones condicionales.

2. Ha utilizado operadores de prueba de archivos como -f, -r, -w y -x para verificar la existencia y los permisos de los archivos.

3. Ha practicado el encadenamiento de comandos utilizando operadores lógicos para crear secuencias de operaciones que dependen del éxito o fracaso de comandos anteriores.

4. Ha explorado varios operadores de prueba de archivos y ha aprendido cómo combinarlos con operadores lógicos para crear condiciones más complejas.

Estas operaciones lógicas son herramientas fundamentales en la escritura de scripts y el uso de la línea de comandos en Linux. Le permiten crear scripts más sofisticados que pueden manejar diferentes situaciones en función de condiciones y resultados de comandos anteriores.

Al dominar las operaciones lógicas, ha adquirido una habilidad esencial para la administración de sistemas Linux, la automatización y la escritura de scripts que le será muy útil en su camino como usuario o administrador de Linux.