Shell Script UNIX-LINUX-WINDOWS

En Bash 4 y versiones posteriores, las matrices asociativas le permiten crear listas de pares clave-valor que se pueden buscar por clave o por valor. Debido a la relación bidireccional entre la clave y el valor, también se denominan diccionarios de datos.

Podemos iterar a través de una matriz asociativa usando un  for círculo. Este script es «asociative.sh». Define una matriz asociativa con cuatro entradas, una para cada uno de «perro», «gato», «robin» y «humano». Estas son las claves. Los valores son el número (predeterminado) de patas que tiene cada uno.

#!/bin/bash

declare -A animals=( [dog]=Four-legged [cat]=Four-legged [robin]=Two-legged [human]=Two-legged )

for legs in ${!animals[@]}
do
  if [ ${animals[$legs]} == "Two-legged" ]; then 
    echo ${legs}
  fi
done

El iterador se llama legs . Tenga en cuenta que el encabezado del ciclo contiene un «!«Punto de exclamación. Esto no actúa como el operador lógico NOT, es parte de la sintaxis de matriz asociativa. Se requiere para buscar a través de la matriz.

El cuerpo del bucle realiza una prueba de comparación de cadenas. Si el valor del miembro de la matriz es «de dos patas», imprime el valor de la clave en la ventana del terminal. Cuando lo ejecutamos, el script imprime las criaturas de dos patas.

Este codigo ${animals[@]} se expande a los valores y ${!animal[@]} se expande a dog cat robin human.

Permite la sustitución del contenido de la variable siguiendo una amplia
variedad de reglas. Los distintos formatos para la expansión de paráme-
tros son :

BASH proporciona unas potentes herramientas para el tratamiento de
cadenas, sin embargo la sintaxis puede resultar engorrosa y requiere de
experiencia para depurar el código. Por lo tanto, se recomienda crear
guiones que resulten fáciles de comprender, documentando claramente
las órdenes más complejas. Aqui algunos ejemplos de utilidad :

Realizar una copia en forma recursiva, es decir que debe copiar el directorio y todo su contenido.

cp -r  /Fotos  /respaldo/MisFotos

Si con este mismo ejemplo se requiere respaldar el directorio /Fotos, pero que solo grabe los archivos que se han modificado o no existe en el destino (-u) y además que muestre en pantalla lo que esta realizando.

cp -r -u -v /Fotos  /respaldo/MisFotos                    #o también  ==>>    cp -ruv  /Fotos  /respaldo/MisFotos

Otra utilidad es para realizar backups, por ejemplo, si constantemente trabajamos con un archivo (planilla.txt) y deseamos tener copias de versiones del mismo.

cp --force --backup=numbered planilla.txt planilla.txt

Aqui copiamos el archivo sobre si mismo, el comando cp por si mismo no lo puede hacer, por eso utilizamos la opcion «-force» con la cula lo forzamos a realizar la copia. Y con la opción «-backup=numbered«, le indicamos que las copias esten numeradas consecutivamente. Estas quedarían como : planilla.txt~1~ planilla.txt~2~ planilla.txt~3~ etc…..

Para conservar la propiedad,permisos y fecha y hora del archivo a copiar, se utiliza la opción «-p» (–preserve)

cp -p planilla.txt planilla2.txt

Preservar enlaces duros mientras se copia. De forma predeterminada, el comando cp no conserva los vínculos físicos entre los archivos al copiar. Sin embargo, puede usar la opción ‘-l’ para crear enlaces duros en lugar de copiar los archivos reales. Esto puede ser útil cuando desea crear un directorio espejo sin usar espacio adicional en el disco.

cp -Rl  /source_directory  /destination_directory/

Copiar archivos sin seguir enlaces simbólicos. Al copiar directorios usando la opción recursiva ( -R ), el comando cp sigue los enlaces simbólicos de forma predeterminada. Para evitar este comportamiento y, en su lugar, copiar los enlaces simbólicos, utilice la opción ‘-P’:

cp -RP  /source_directory  /destination_directory/

Una forma interesante de cargar un arreglo desde una variable. Para este ejemplo se muestran las rutas que contiene la variable de entorno PATH.

#!/bin/bash
paths=$(echo $PATH)
backIFS=$IFS
IFS=':' read -r -a paths <<< "$paths"
# read x y <<<"1 2"     ## Esta forma nos permite asignar valores a variables.
for item in "${paths[@]}"
do
echo $item
done
## Con la siguiente linea procedemos a restaurar el separador IFS
IFS=$backIFS

Para un mejor manejo de los colores en SCRIPT BASH se pueden definir como variables de la siguiente forma :

red='\033[31m'
reset='\033[0m'

Entonces, puedes accionar los colores simplemente con el comando Echo:

echo -e "${red}Esto es un texto rojo.${reset}Y ahora el texto vuelve a ser normal." 

A continuación resumimos los distintos códigos escape para los diversos colores de fuente y fondo:

      \033[30m        Color de fuente negro
      \033[31m        Color de fuente rojo
      \033[32m        Color de fuente verde
      \033[33m        Color de fuente amarillo
      \033[34m        Color de fuente azul
      \033[35m        Color de fuente magenta
      \033[36m        Color de fuente turquesa
      \033[37m        Color de fuente blanco
      \033[40m        Color de fondo negro
      \033[41m        Color de fondo rojo
      \033[42m        Color de fondo verde
      \033[43m        Color de fondo amarillo
      \033[44m        Color de fondo azul
      \033[45m        Color de fondo magenta
      \033[46m        Color de fondo turquesa
      \033[47m        Color de fondo gris

Además del color de la fuente y del fondo, con el comando de Linux Echo también pueden determinarse otras características del texto como la negrita o el subrayado. He aquí los códigos de distintas propiedades de texto:

      \033[0m         Restaurar todas las caracteristicas
      \033[1m         Negrita
      \033[4m         Subrayado
      \033[5m         Parpadeo
      \033[7m         Pantalla inversa

Si quieres escribir el texto rojo en negrita, utiliza el siguiente código:

echo -e "\033[1;31mEsto es un texto rojo en negrita." 

En este ejemplo se muestra como procesar multiples argumentos pasados a un scripts Bash.

#!/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)

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:

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:

if [[ $(grep -x "blanco" /home/joan/opciones.txt) ]]; then echo "1"; else echo "0"; fi

y el resultado obtenido será:

1

Si ahora borramos la palabra blanco del fichero opciones.txt y volvemos a ejecutar el comando:

if [[ $(grep -x "blanco" /home/joan/opciones.txt) ]]; then echo "1"; else echo "0"; fi

El resultado será el siguiente:

0

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.

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:

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:

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:

127.0.0.1
127.0.1.1

#!/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]}.

#!/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.

#!/bin/bash

# Patrones a buscar
patrones=("error" "warning" "critical")

# Archivo de log
archivo_log="archivo.log"

# Bucle para cada patrón
for patron in "${patrones[@]}"; do
  echo "Buscando patrón: $patron"
  echo "--------------------"
  grep -i "$patron" "$archivo_log"
  echo "--------------------"
  echo
done

echo "Búsqueda de patrones en el archivo de log completada."

En este ejemplo, se definen los patrones a buscar en el archivo de log en el array patrones. Luego, se utiliza un bucle for para iterar sobre cada patrón y se utiliza el comando grep para buscar el patrón en el archivo de log especificado en la variable archivo_log. El uso de la opción -i en el comando grep hace que la búsqueda sea insensible a mayúsculas y minúsculas.

Puedes agregar o modificar los patrones en el array patrones según tus necesidades. Al ejecutar este script, mostrará las líneas del archivo de log que contienen los patrones buscados, con un separador «—» para cada patrón encontrado.

Ten en cuenta que este es solo un ejemplo básico y que puedes personalizar y expandir este script según tus necesidades específicas, como agregar más opciones de búsqueda, procesar resultados de búsqueda de diferentes maneras, o manejar errores y excepciones.

@echo off
setlocal enabledelayedexpansion

set dominio=ejemplo.com
set nueva_ip=192.168.1.100

set "tempfile=%temp%\hosts.tmp"
set "hostsfile=%systemroot%\System32\drivers\etc\hosts"

REM Buscar y reemplazar la línea en el archivo hosts
for /f "tokens=*" %%a in (%hostsfile%) do (
  echo %%a | findstr /i /c:"%dominio%" >nul
  if not errorlevel 1 (
    echo %nueva_ip% %%a >> %tempfile%
  ) else (
    echo %%a >> %tempfile%
  )
)

REM Sobrescribir el archivo hosts con el archivo temporal
move /y %tempfile% %hostsfile% >nul

echo Archivo hosts modificado correctamente.

En este script, se utiliza la variable dominio para especificar el nombre de dominio que deseas modificar, y la variable nueva_ip para especificar la nueva dirección IP que deseas asignarle. El script busca la línea que contiene el nombre de dominio en el archivo hosts, y si lo encuentra, lo reemplaza con la nueva dirección IP en un archivo temporal. Luego, sobrescribe el archivo hosts original con el archivo temporal, logrando así la modificación de la entrada.

Ten en cuenta que, al igual que en los ejemplos anteriores, necesitas tener privilegios de administrador en el sistema para ejecutar este script BATCH en DOS, y debes tener precaución al modificar el archivo hosts, siguiendo las políticas de seguridad y las leyes aplicables. Además, asegúrate de hacer copias de seguridad del archivo hosts antes de modificarlo, por si necesitas restaurarlo en caso de errores o problemas.

@echo off
setlocal enabledelayedexpansion

set "modificaciones[0]=ejemplo1.com=192.168.1.101"
set "modificaciones[1]=ejemplo2.com=192.168.1.102"
set "modificaciones[2]=ejemplo3.com=192.168.1.103"
set "archivo_nuevas_lineas=nuevas_lineas.txt"

set "tempfile=%temp%\hosts.tmp"
set "hostsfile=%systemroot%\System32\drivers\etc\hosts"

REM Realizar modificaciones
for /f "tokens=*" %%a in (%hostsfile%) do (
  set "linea=%%a"
  set "modificado=false"
  
  REM Modificar líneas existentes
  for %%b in (0 1 2) do (
    for /f "delims== tokens=1,2" %%c in ("!modificaciones[%%b]!") do (
      echo !linea! | findstr /i /c:"%%c" >nul
      if not errorlevel 1 (
        echo %%d %%c >> %tempfile%
        set "modificado=true"
      )
    )
  )

  REM Escribir líneas no modificadas
  if "!modificado!"=="false" (
    echo !linea! >> %tempfile%
  )
)

REM Agregar nuevas líneas desde archivo
if exist "%archivo_nuevas_lineas%" (
  for /f "tokens=*" %%a in (%archivo_nuevas_lineas%) do (
    echo %%a >> %tempfile%
  )
) else (
  echo El archivo de nuevas líneas no se encontró: %archivo_nuevas_lineas%
  echo No se agregaron nuevas líneas al archivo hosts.
)

REM Sobrescribir el archivo hosts con el archivo temporal
move /y %tempfile% %hostsfile% >nul

echo Archivo hosts modificado correctamente.

En este otro ejemplo, se utiliza la variable archivo_nuevas_lineas para especificar el nombre del archivo que contiene las nuevas líneas que se desean agregar. El script verifica si el archivo existe y, si es así, lee las líneas del archivo y las agrega al archivo temporal. Si el archivo no existe, muestra un mensaje de error indicando que no se encontró el archivo de nuevas líneas.

#!/bin/bash

# Función para calcular la raíz cuadrada
function sqrt {
    echo "sqrt($1)" | bc
}

# Obtener los coeficientes de la ecuación
read -p "Ingresa el coeficiente a: " a
read -p "Ingresa el coeficiente b: " b
read -p "Ingresa el coeficiente c: " c

# Calcular el discriminante
discriminante=$((b*b - 4*a*c))

# Verificar si la ecuación tiene soluciones reales
if [ $discriminante -lt 0 ]; then
    echo "La ecuación no tiene soluciones reales."
else
    # Calcular las raíces
    x1=$(((-b + $(sqrt $discriminante)) / (2*a)))
    x2=$(((-b - $(sqrt $discriminante)) / (2*a)))

    # Imprimir las soluciones
    echo "Las soluciones de la ecuación son: x1=$x1 y x2=$x2"
fi

Para resolver ecuaciones de segundo grado ingresando los coeficientes a, b y c cuando se te solicite. El script utiliza la fórmula general para resolver la ecuación y muestra las soluciones reales si existen, o un mensaje indicando que la ecuación no tiene soluciones reales en caso contrario.

@echo off
for /f "tokens=2 delims==." %%a in ('"wmic OS Get localdatetime /value | findstr /B Local"') do set fecha=%%a
set fec1=%fecha:~,8%-%fecha:~8,4%
set fec2=%fecha:~6,2%%fecha:~4,2%%fecha:~,4%-%fecha:~8,4%
echo Formato 1 = %fec1%
echo Formato 2 = %fec2%
echo Archivo 1 = archivo-%fec1%.txt
echo Archivo 2 = archivo-%fec2%.txt
pause>nul

Al ejecutar el script, se obtiene el siguiente resultado. Pudiendo adaptarlo a cualquier situación que se requiera.

D:\Fuentes>programa.cmd

Formato 1 = 20230201-2028
Formato 2 = 01022023-2028
Archivo 1 = archivo-20230201-2028.txt
Archivo 2 = archivo-01022023-2028.txt

Para este ejemplo se utilizan 2 archivos de texto plano. “factura.txt” el cual contiene datos de facturas, con un código que es único en el archivo. El segundo archivo es “detalle.txt” el cual contiene el detalle de las facturas, identificados por el código de la factura y pueden ser múltiples líneas en el archivo.

El script une estos 2 archivos en el archivo “facdet.txt” el cual contiene las facturas y luego el detalle de dicha factura.

@echo off
setlocal enabledelayedexpansion
cls
color 1F
set fact=0
set archivo=factura.txt
echo. > facdet.txt
for /F "tokens=*" %%a in (factura.txt) do (
     set factura=%%a
     set numfac=!factura:~3,10!

     set /a fact=!fact! + 1
     echo !factura! >> facdet.txt
     for /F "delims=" %%i IN ('findstr /B ...!numfac! detalle.txt') do (
        set detalle=%%i
        set dato=!detalle:~11!
        echo            !dato! >> facdet.txt
        set /a tota=!tota! + 1
     )
)
echo "-----------------------------------------"
echo "Se procesaron !fact! facturas.-"
echo "-----------------------------------------"
echo "Contenido Archivo FACDET.TXT             "
echo "-----------------------------------------"
type facdet.txt
echo "-----------------------------------------"
pause > null

Existe un error que me dio en algún momento, específicamente en el comando “findstr” que se ejecuta dentro del ciclo FOR. Al ejecutar el SCRIPT me daba error “ no se reconoce como un comando interno o externo”.

Pero si el comando lo ejecutaba en la línea de comando o en el script fuera del ciclo FOR, si lo ejecutaba en forma correcta. Busqué alguna solución en la WEB y me di cuenta que muchas personas tenían este problema. La solución que daban todos era por problemas con la variable “PATH” de Windows. No era mi caso.

El problema me lo origino el antivirus que tenía, que por algún motivo, bloqueo la ejecución, pero solo cuando se gatilla dentro del ciclo FOR. Ni idea por qué.   Elimine el bloqueo y el problema se solucionó. Por si a alguien le pueda servir.

@echo off
set cadena=%1
setlocal
call :len %cadena% a
echo La cadena %cadena% tiene %a% caracteres.
endlocal
goto :eof
:len
setlocal enabledelayedexpansion&set l=0&set str=%~1
:loop
set x=!str:~%l%,1!&if not defined x (endlocal&set "%~2=%l%"&goto :eof)
set /a l=%l%+1&goto :loop

La cadena se le pasa como parámetro al SCRIPT. Si la cadena contiene ESPACIOS, se debe ingresar encerrada en comillas simples