En este ejemplo se muestra como procesar multiples argumentos pasados a un scripts Bash.
|
1 2 3 4 5 6 7 8 |
#!/bin/bash echo echo "Numero de Argumentos = ${#@}" echo for arg in "$@" do echo "$arg " done |
Al ejecutarlo, obtendremos el siguiente resultado : (bash ejemplo.sh uno dos tres cuatro cinco)
|
1 2 3 4 5 6 7 |
Numero de Argumentos = 5 uno dos tres cuatro cinco |
Para aplicar una acción u otra en función de una determinada circunstancia tendremos que usar un condicional if. Imaginemos que tenemos un fichero opciones.txt y tiene el siguiente contenido:
|
1 2 3 |
blanco negro azul |
Ahora queremos que si una de las líneas del fichero contiene la palabra blanco la terminal nos de como resultado 1. En el caso que el fichero de texto no disponga de la palabra blanco entonces queremos que nos devuelva 0. Para conseguir nuestro propósito podemos usar el siguiente comando:
|
1 |
if [[ $(grep -x "blanco" /home/joan/opciones.txt) ]]; then echo "1"; else echo "0"; fi |
y el resultado obtenido será:
|
1 |
1 |
Si ahora borramos la palabra blanco del fichero opciones.txt y volvemos a ejecutar el comando:
|
1 |
if [[ $(grep -x "blanco" /home/joan/opciones.txt) ]]; then echo "1"; else echo "0"; fi |
El resultado será el siguiente:
|
1 |
Nótese que en este ejemplo usamos grep con la opción -x. La opción -x hace que grep solo considere las líneas cuyo contenido completo sea la palabra blanco.
|
1 |
grep -E --color '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' /etc/hosts |
Y obtendremos el siguiente resultado:
|
1 2 |
127.0.0.1 localhost 127.0.1.1 gk55 |
En el resaltado de color se muestra el contenido definido por nuestra expresión regular. En nuestro caso la expresión regular define 4 cifras entre el 0 y el 9, separadas por puntos. Cada una de las cifras entre el 0 y el 9 está separada puntos y podrá tener 1, 2 o 3 caracteres.
Si queremos que la salida del comando solo muestre las IP omitiendo las palabras localhost y gk55 podemos usar la opción -o. De este modo grep solo mostrará la cadena de texto o palabra de cada una de las líneas que coincide con nuestro criterio de búsqueda. Por lo tanto si ejecutamos el siguiente comando:
|
1 |
grep -E --color -o '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' /etc/hosts |
Obtendremos el siguiente resultado:
|
1 2 |
127.0.0.1 127.0.1.1 |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
#!/bin/bash # Archivo de log archivo_log="archivo.log" # Declaración de array asociativo para contabilizar errores declare -A errores # Leer archivo de log línea por línea while read -r linea; do # Extraer el tipo de error de la línea tipo_error=$(echo "$linea" | cut -d ':' -f 1) # Incrementar la cuenta de errores en el array asociativo ((errores["$tipo_error"]++)) done < "$archivo_log" # Mostrar resultados echo "Cantidad de errores por tipo:" for tipo_error in "${!errores[@]}"; do echo "Tipo: $tipo_error - Cantidad: ${errores[$tipo_error]}" done |
En este ejemplo, se utiliza un array asociativo en bash (errores) para contabilizar la cantidad de errores por tipo desde un archivo de log ($archivo_log). El archivo de log se lee línea por línea utilizando un bucle while y el comando read, y luego se utiliza el comando cut para extraer el tipo de error de cada línea, asumiendo que los errores están separados por dos puntos («:») en el archivo de log. Luego, se incrementa la cuenta de errores en el array asociativo utilizando la sintaxis errores["$tipo_error"]++.
Finalmente, se muestra el resultado en la salida, iterando sobre las claves del array asociativo ("${!errores[@]}") y mostrando el tipo de error y la cantidad de errores correspondiente utilizando la sintaxis ${errores[$tipo_error]}.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
#!/bin/bash # Rutas de directorios de origen y destino directorio_origen="/ruta/del/directorio/origen/" directorio_destino="/ruta/del/directorio/destino/" # Nombre de archivo de registro archivo_log="respaldo.log" # Fecha actual fecha_actual=$(date +%Y%m%d%H%M%S) # Realizar respaldo incremental (El comando "rsync" va en una sola linea) rsync -a --delete --backup --backup-dir="$directorio_destino$fecha_actual" "$directorio_origen" "$directorio_destino" >> "$archivo_log" # Registrar la información del respaldo en el archivo de registro echo "Fecha de respaldo: $(date)" >> "$archivo_log" echo "Directorio de origen: $directorio_origen" >> "$archivo_log" echo "Directorio de destino: $directorio_destino" >> "$archivo_log" echo "Respaldo incremental creado en: $directorio_destino$fecha_actual" >> "$archivo_log" echo "------------------------------" >> "$archivo_log" echo "Respaldo incremental completado." |
En este ejemplo, se utiliza el comando rsync para realizar un respaldo incremental del directorio de origen ($directorio_origen) al directorio de destino ($directorio_destino). El respaldo se realiza utilizando las opciones -a para mantener los atributos y permisos, --delete para eliminar archivos en el directorio de destino que ya no existen en el directorio de origen, y --backup para crear copias de seguridad de los archivos modificados o eliminados.
Además, se utiliza la opción --backup-dir para especificar el directorio de destino donde se guardarán las copias de seguridad de los archivos modificados o eliminados, utilizando la fecha actual en el nombre del directorio ($directorio_destino$fecha_actual) para hacer que el respaldo sea incremental.
La información del respaldo se registra en un archivo de registro ($archivo_log) que incluye la fecha del respaldo, los directorios de origen y destino, y el directorio de destino donde se guardaron las copias de seguridad.
