Haciendo loops por ejemplo :
|
1 2 3 4 5 6 7 |
#!/bin/bash CONT=0 for i in "$@" do let CONT=$CONT+1 echo "Argumento $CONT: $i" done |
Podemos realizarlo también, con un while :
|
1 2 3 4 5 6 7 8 |
#!/bin/bash CONT=0 while [ "$*" ] do let CONT=$CONT+1 echo "Argumento $CONT: $1" shift done |
Para poder trabajar con arrays asociativos, se debe tener instalado version 4 o superior de BASH :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
#!/bin/bash #Declara un array asociativo declare -A capital #Esta es una forma de llenar el array capital=([GB]="Londres" [Japón]="Tokio") #Esta es otra capital[Alemania]="Berlín" capital[China]="Pekín" #Para agregar datos a un array capital+=([Bélgica]="Bruselas" [Egipto]="Cairo") #Muestra el numero de elementos del array echo "Tamaño: ${#capital[@]}" #Para mostrar la capital de Alemania echo "Capital de Alemania : ${capital[Alemania]}" #Iterar sobre el array mostrando la clave y su valor echo "País -> Capital" for country in "${!capital[@]}" do echo "$country -> ${capital[$country]}" done |
Al ejecutra este script, nos mostyrara el siguiente resultado :
|
1 2 3 4 5 6 7 8 9 |
Size: 6 Capital de Alemania : Berlín País -> Capital GB -> Londres Alemania -> Berlín Bélgica -> Bruselas China -> Pekín Japón -> Tokio Egipto -> Cairo |
|
1 |
for i in `ps aux | grep "/tmp/prueba.sh" | awk '{print $2}'`; do kill -9 $i; done |
|
1 2 3 4 5 |
#!/bin/bash read -t 10 -p "Nombre del archivo: " nombre_archivo nombre_archivo=${nombre_archivo:-main-file.txt} echo "El nombre del archivo es: $nombre_archivo" echo "Nombre de archivo ingresado : $nombre_archivo" |
Para este ejemplo utilizaremos un archivo llamado «traspaso.txt» el cual contiene los siguientes datos :
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Mercedes-Benz BMW Nissan Honda Land Rover & Range Rover Toyota Nissan BYD Toyota Volkswagen Hyundai Nissan |
Queremos cambiar el valor «Nissan» por «Toyota», pudiendo realizarlo de la siguiente manera en SCRIPTS BASH :
|
1 2 3 |
#!/bin/bash a="Toyota" sed -e 's/Nissan/'"$a"'/g' traspaso.txt >> nuevo-traspaso.txt |
Por último, podemos realizar el cambio con perl, pasando por la terminal o consola la siguiente orden :
|
1 |
perl -p -i -e 's/Nissan/Toyota/g' traspaso.txt |
Recordemos que expect es una librería que automatiza de forma interactiva los scripts, así que si no tienes instalado ésta utilidad, para poder utilizar éste script deberás tenerlo previamente.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
#!/bin/bash #Contiene nombre de la cuenta (login) account=super01 #Contiene la password antigua pass_old=old-pw #Contiene la nueva password pass_new=new_pw #Contiene el comando que se ejecutará command=passwd #Corresponde al archivo que contiene la lista de los servidores a los que se les cambiará la password servers="/home/todosoftware/pruebas/list_servers.txt" #Contiene el números de servidores a cambiar la password num=`cat $servers | wc -l` #Hora de inicio del proceso (lo utilizamos para saber si tardó en ejecutarse) inicio=`date +%H:%M:%S` #Ciclo FOR para iterar cada nombre de servidor for host in $(cat $servers); do echo " Cambiando Password SERVIDOR ==> $host" #La siguiente línea ejecuta un programa EXPECT en que al programa se le pasan 5 argumentos #Nombre servidor - cuenta (login) - password antigua - comando (passwd) - password nueva.- /usr/local/bin/expect /home/todosoftware/change_pass.exp $host $account $pass_old $pass_new "$command" done #Hora en que finaliza el cambio de password fin=`date +%H:%M:%S` echo " ---------------------------------- FIN CAMBIO DE PASSWORD ---------------------------------" #Muestra el numero de servidores y la hora de Inicio y Termino del proceso echo " $num servidores Inicio = $inicio Termino = $fin" echo " -----------------------------------------------------------------------------------------------" total=0 read pausa exit |
A continuación except hace el cambio de forma interactiva :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
#!/usr/local/bin/expect set host [lindex $argv 0] set account [lindex $argv 1] set pass_old [lindex $argv 2] set pass_new [lindex $argv 3] set command [lindex $argv 4] set timeout 2 log_user 0 spawn ssh -o StrictHostKeyChecking=no $account@$host expect "*?assword:*" send "$contrasena\r" expect "*->" send "echo\r" expect "*->" send "$command\r" expect "*?assword:*" send "$pass_old\r" expect "*?assword:*" send "$pass_new\r" expect "*?assword:*" log_user 1 send "$pass_new\r" expect "*->" send "exit\r" log_user 0 expect eof |
Supongamos que tienes una lista de URLs de sitios web y deseas extraer el título de cada página para realizar un análisis posterior. En lugar de procesar cada URL secuencialmente, puedes aprovechar el procesamiento en paralelo para acelerar el proceso. Aquí hay un ejemplo de cómo podrías hacerlo,
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
#!/bin/bash # Lista de URLs urls=( "https://www.ejemplo1.com" "https://www.ejemplo2.com" "https://www.ejemplo3.com" # Añadir más URLs según sea necesario ) # Función para extraer el título de una página web extract_title() { url="$1" title=$(curl -s "$url" | grep -o "<title>.*</title>" | sed -e 's/<[^>]*>//g') echo "Título de $url: $title" } # Exportar la función para que esté disponible para xargs export -f extract_title # Utilizar xargs para ejecutar la función extract_title en paralelo printf "%s\n" "${urls[@]}" | xargs -I {} -P 4 bash -c 'extract_title "$@"' _ {} echo "Proceso de extracción de títulos completado." |
El comando mapfile ofrece una solución poderosa pero simple, que le permite leer sin esfuerzo líneas desde una entrada estándar (o un descriptor de archivo específico) en una variable de matriz. mapfile está disponible en Bash versión 4.0 y posteriores. La estructura de mando es la siguiente:
mapfile [options] array_variable < input_file
En el siguiente ejemplo, veremos cómo procesar datos CSV. Supongamos que tenemos un archivo CSV con los siguientes datos.
|
1 2 |
Alice,25,alice@example.com Bob,30,bob@example.com |
Al proceesar el archivo CVS «data.cvs», necesitamos separar las filas y tambien las columnas. Esto para mostarr los campos por separado de cada linea
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#!/bin/bash input_file="data.csv" mapfile -t csv_data < "$input_file" for line in "${csv_data[@]}"; do mapfile -t -d ‘,’ fields_array <<< “$line” name=”${fields_array[0]}” age=”${fields_array[1]}” email=”${fields_array[2]}” echo "Name: $name, Age: $age, Email: $email" done |
Al ejecutarlo nos mostrara el siguiente resultado :
|
1 2 3 |
bash cvs.sh Name: Alice, Age: 25, Email: alice@example.com Name: Bob, Age: 30, Email: bob@example.com |
El ‘readarray’ es uno de los comandos más útiles en Bash. Este, lee líneas de un archivo o entrada estándar y las asigna a una matriz. Este comando solo está disponible en versiones de bash 4.0 o superior.
La sintaxis para usar ‘readarray’ es la siguiente:
|
1 |
readarray [-d DELIM] [-n COUNT] [-O ORIGIN] [-s COUNT] [-t] array |
Las opciones disponibles para el comando ‘readarray’ son:
‘-d DELIM’: establece el delimitador que se utilizará al dividir líneas en elementos de matriz y, de forma predeterminada, el delimitador es un carácter de nueva línea.
‘-n COUNT’: especifica el número máximo de líneas para leer en la matriz.
‘-O ORIGIN’: establece el índice inicial de la matriz.
‘-s COUNT’: especifica el número de líneas que se saltan antes de leer en la matriz.
‘-t’: elimina el carácter de nueva línea final de cada línea leída en la matriz.
Suponga que tiene una matriz que contiene una combinación de caracteres alfabéticos y numéricos. Para realizar la clasificación en esta matriz, debe comparar el valor ASCII del carácter.
El código para nuestro ejemplo será como el siguiente.
|
1 2 3 |
MyArray=(n a c b 6 7 5) readarray -t MyArray < <(printf '%s\n' "${MyArray[@]}" | sort) echo "The sorted list is: ${MyArray[*]}" |
Después de ejecutar el script, obtendrá un resultado como el que se muestra a continuación.
|
1 |
The sorted list is: 5 6 7 a b c n |
Otro ejemplo del uso de ‘readarray’ para leer líneas de un archivo en una matriz 2D y para eso he creado un testfile.txt cuyo contenido es:
1 2 3
4 5 6
7 8 9
Script bash, que demuestra el uso del comando ‘readarray’:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
#!/bin/bash # Read lines from a file into the array readarray -t lines < testfile.txt # Declare a 2D array with 3 rows and 3 columns declare -A array # Iterate over the lines and split each line into elements for i in "${!lines[@]}"; do IFS=' ' read -r -a elements <<< "${lines[i]}" for j in "${!elements[@]}"; do if [[ -n "${elements[j]}" ]]; then array[$i,$j]=${elements[j]} fi done done # Print the array for ((i=0;i<3;i++)); do for ((j=0;j<3;j++)); do echo -n "${array[$i,$j]} " done echo done |
Primero se declara una matriz 2D llamada ‘matriz’ y luego uso el comando ‘readarray’ para leer líneas de un archivo llamado ‘testfile.txt’ en la matriz ‘líneas’. A continuación, el código itera sobre la matriz de «líneas» y divide cada línea en elementos usando los comandos «IFS» y «leer».
Después de eso, almacena los elementos en la matriz 2D ‘matriz’ y luego usa el comando de lectura para dividir cada línea en elementos. Ahora cada elemento se asigna al elemento correspondiente en la matriz ‘matriz’ y, finalmente, se imprimen los contenidos de la matriz ‘matriz’ utilizando bucles for anidados.
|
1 2 3 4 |
bash bashfile.sh 123 456 789 |
El comando ‘readarray’ facilita la manipulación de grandes cantidades de datos en scripts de Bash. Siguiendo los ejemplos proporcionados en este artículo, puede comenzar a usar ‘readarray’ en sus propios scripts de Bash para leer líneas de archivos y procesarlos en matrices 2D.
Si bien es cierto, Bash es programa usado principalmente para interpretar órdenes que deberán actuar directamente sobre el sistema operativo que lo soporte como es el caso de UNIX. La sintaxis de órdenes de bash está compuesta por ideas que fueron tomadas de Korn Shell (ksh) y el C Shell (csh) y fue de cierta manera enriquecida gracias a la variedad de sentencias heredadas de sus predecesores.
El realizar a manera de práctica e introducción a Bash los métodos de ordenamiento más comunes que se suelen implementar al aprender un lenguaje de programación, sirve exclusivamente para aprender el funcionamiento de las estructuras repetitivas y de flujo, arreglos, operaciones lógicas y aritméticas y sentencias que son básicas para poder involucrarse en la programación en bash, el cual, posteriormente debería ser llevada a una dimensión real realizando scripts que permitirán la automatización de tareas recurrentes que realizamos dentro del sistema operativo como operaciones con ficheros, procesos, comandos, etc.
A continuación, se detallan los métodos de ordenamiento:
1.- Ordenamiento de Burbuja.
El método de ordenamiento burbuja consiste en comparar cada elemento de la estructura con el siguiente e intercambiándolos si corresponde. El proceso se repite hasta que la estructura esté ordenada. El orden se establece de acuerdo con la clave y la estructura tiene que tener acceso directo a sus componentes.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
#!/bin/bash function burbuja { lista=$1 tam=${#lista[@]} for i in $(seq 1 $[$tam-1]); do for j in $(seq 0 $[$tam - $i - 1]); do if [ ${lista[$j]} -gt ${lista[$j+1]} ] ; then k=${lista[$[$j+1]]} lista[$j+1]=${lista[$j]} lista[$j]=$k fi done done } lista=(5 4 3 2 1) burbuja $lista for i in ${lista[@]};do echo $i; done |
2.- Ordenamiento Shell.-
El método de ordenamiento Shell consiste en dividir el arreglo (o la lista de elementos) en intervalos (o bloques) de varios elementos para organizarlos después por medio del ordenamiento de inserción directa. El proceso se repite, pero con intervalos cada vez más pequeños, de tal manera que al final, el ordenamiento se haga en un intervalo de una sola posición, similar al ordenamiento por inserción directa, la diferencia entre ambos es qué, al final, en el método ShellSu nombre proviene de su creador, Donald Shell, y no tiene que ver en la forma como funciona el algoritmo. los elementos ya están casi ordenados.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
#!/bin/bash function shell { lista=$1 tam=${#lista[@]} for inc in $(seq 1 $[$[inc*3]+1] $[$tam-1]) ; do while [ $inc -gt 0 ] ; do for i in $(seq $inc $[$tam-1]) ; do j=$i temp=${lista[$i]} while [[ $j -ge $inc && ${lista[$[$j-$inc]]} -gt $temp ]] ; do lista[$j]=${lista[$[$j-$inc]]} j=$[$j-$inc] done lista[$j]=$temp done inc=$[$inc/2] done done } lista=(5 4 3 2 1) shell $lista for i in ${lista[@]};do echo $i; done |
3.- Ordenamiento Quicksort.-
El método Quick Sort es actualmente el más eficiente y veloz de los métodos de ordenación interna. Es también conocido con el nombre del método rápido y de ordenamiento por partición.
Este método es una mejora sustancial del método de intercambio directo y recibe el nombre de Quick Sort, por la velocidad con la que ordena los elementos del arreglo.
Quicksort es un algoritmo basado en la técnica de divide y vencerás, que permite, en promedio, ordenar n elementos en un tiempo proporcional a n log n.
Quicksort es actualmente el más eficiente y veloz de los métodos de ordenación interna.
Este método fue creado por el científico británico Charles Antony Richard Hoare, también conocido como Tony Hoare en 1960, su algoritmo Quicksort es el algoritmo de ordenamiento más ampliamente utilizado en el mundo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
#!/bin/bash function quicksort { lista=$1 izq=$2 der=$3 i=$izq; j=$der; x=${lista[$[$[$izq + $der]/2]]} while [ $i -le $j ] ; do while [[ ${lista[$i]} -lt $x && $j -le $der ]] ; do i=$[$i+1] done while [[ $x -lt ${lista[$j]} && $j -gt $izq ]] ; do j=$[$j-1] done if [ $i -le $j ] ; then aus=${lista[$i]}; lista[$i]=${lista[$j]}; lista[$j]=$aus; i=$[$i+1]; j=$[$j-1] fi done if [ $izq -lt $j ] ; then quicksort $lista $izq $j fi if [ $i -lt $der ] ; then quicksort $lista $i $der fi } lista=(5 4 3 2 1) quicksort $lista 0 $[${#lista[@]}-1] for i in ${lista[@]};do echo $i; done |
4.- Ordenamiento por Inserción Directa. –
El método de ordenación por inserción directa consiste en recorrer todo el array comenzando desde el segundo elemento hasta el final. Para cada elemento, se trata de colocarlo en el lugar correcto entre todos los elementos anteriores a él o sea entre los elementos a su izquierda en el array.
Dada una posición actual p, el algoritmo se basa en que los elementos A[0], A[1], …, A[p-1] ya están ordenados.
En el peor de los casos, el tiempo de ejecución en O(n2).
En el mejor caso (cuando el array ya estaba ordenado), el tiempo de ejecución de este método de ordenamiento es O(n).
El caso medio dependerá de cómo están inicialmente distribuidos los elementos. Cuanto más ordenada esté inicialmente más se acerca a O(n) y cuanto más desordenada, más se acerca a O(n2).
El peor caso el método de inserción directa es igual que en los métodos de burbuja y selección, pero el mejor caso podemos tener ahorros en tiempo de ejecución.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
#!/bin/bash function inserciondirecta { lista=$1 tam=${#lista[@]} for i in $(seq 1 $[$tam-1]) ; do v=${lista[$i]} j=$[$i-1] while [[ $j -ge 0 && ${lista[$j]} -gt $v ]] ; do lista[$[$j+1]]=${lista[$j]} j=$[$j-1] done lista[$[$j+1]]=$v done } lista=(5 4 3 2 1) inserciondirecta $lista for i in ${lista[@]};do echo $i; done |
5.- Ordenamiento por Inserción Binaria. –
El ordenamiento binario es un algoritmo de ordenación de tipo comparación. Es una modificación del algoritmo de ordenamiento por inserción. En este algoritmo, también mantenemos una submatriz ordenada y otra sin ordenar. La única diferencia es que encontramos la posición correcta de un elemento utilizando la búsqueda binaria en lugar de la búsqueda lineal. Esto ayuda a acelerar el algoritmo de ordenación reduciendo el número de comparaciones necesarias.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
#!/bin/bash function insercionbinaria { lista=$1 tam=${#lista[@]} for i in $(seq 1 $[$tam-1]) ; do aus=${lista[$i]} izq=0; der=$[$i-1] while [ $izq -le $der ] ; do m=$[$[$izq+$der]/2] if [ $aus -lt ${lista[$m]} ] ; then der=$[$m-1] else izq=$[$m+1] fi done j=$[$i-1] while [ $j -ge $izq ] ; do lista[$[$j+1]]=${lista[$j]} j=$[$j-1] done lista[$izq]=$aus done } lista=(5 4 3 2 1) insercionbinaria $lista for i in ${lista[@]};do echo $i; done |
6.- Ordenamiento por Selección. –
Este algoritmo mejora ligeramente el algoritmo de la burbuja. En el caso de tener que ordenar un vector de enteros, esta mejora no es muy sustancial, pero cuando hay que ordenar un vector de estructuras más complejas, la operación de intercambiar los elementos sería más costosa en este caso.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#!/bin/bash function selectionsort { lista=$1 tam=${#lista[@]} for i in $(seq 0 $[$tam-2]) ; do min=$i for j in $(seq $[$i+1] $[$tam-1]) ; do if [ ${lista[$min]} -gt ${lista[$j]} ] ; then min=$j fi done aus=${lista[$min]} lista[$min]=${lista[$i]} lista[$i]=$aus done } lista=(5 4 3 2 1) selectionsort $lista for i in ${lista[@]};do echo $i; done |
Si es necesario ver en que rangos de horas han habido peticiones al minuto se puede usar este script. Solo funciona en el caso de ser logs de apache.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
#!/bin/bash #Usage #bash namesript.sh "día" "mes" "año" "log.log" #example #bash conectionsDays.sh 2 Nov "access.log" declare range declare noRequest for i in 0{0..9} {10..23} do for j in 0{0..9} {10..59} do if [[ $(zgrep -c "$1/$2/$3:$i:$j:" $4 ) = 0 ]];then noRequest=true else noRequest=false fi if [ $noRequest = true ];then if [[ -z $range ]];then range="$1/$2 $i:$j" fi else if [[ ! -z $range ]];then echo $range"- $1/$2 $i:$j" range="" fi fi done done if [[ ! -z $range ]];then echo $range"- $1/$2 23:59" fi |
|
1 2 3 4 5 6 7 8 |
#!/bin/bash directorio="/path/to/directory" usodisco=90 usado=$(df -P "$directorio" | awk 'NR==2 {print $5}' | tr -d '%') if [ "$usado" -gt "$usodisco" ]; then echo "Monitoreo $directorio a excedido el %usodisco % de uso" | mail -s "ALERTA uso de disco $directorio" admin@example.com fi |
|
1 2 3 4 5 |
#!/bin/bash directorio_log="/path/to/log/files" dias_antiguedad=7 find "$directorio_log" -type f -mtime +"$dias_antiguedad" -exec gzip {} \; |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
#!/bin/bash numbers=(22 5 13 23 55 9 16 7 25 4 12 11) max=${numbers[0]} min=${numbers[0]} for num in "${numbers[@]}"; do if [ "$num" -gt "$max" ]; then max=$num fi if [ "$num" -lt "$min" ]; then min=$num fi done echo "Numero Menor : $min" echo "Numero mayor : $max" |
Al ejecutar este script obtendremos el siguiente resultado :
|
1 2 |
Numero Menor : 4 Numero mayor : 55 |
En Bash, una matriz asociativa es una colección de pares clave-valor, donde cada clave es única y se puede acceder a cada valor usando su clave correspondiente. Para crear una matriz asociativa en Bash, debe usar la siguiente sintaxis:
|
1 |
declare -A <array-name> |
El comando declare se usa para definir la variable como una matriz asociativa, y la opción -A se usa para especificar que la matriz es asociativa. Para agregar un elemento a una matriz asociativa en Bash, debe usar la siguiente sintaxis:
|
1 |
<array-name>[key]=<value> |
Aquí [clave] es la clave del elemento, y es el valor asociado con la clave, aquí hay un ejemplo de cómo crear y agregar elementos a una matriz asociativa en Bash:
|
1 2 3 4 |
declare -A cars cars["BMW"]="M5" cars["VOLVO"]="X70" cars["LEXUS"]="LX470" |
Aquí, he creado una matriz asociativa denominada coches con tres elementos, cada uno de los cuales contiene el modelo de coche respectivo del fabricante correspondiente. Como ejemplo de cómo obtener el valor de un elemento en una matriz asociativa en Bash, aquí se muestra cómo recuperar la clave de un elemento en una matriz asociativa:
|
1 2 3 4 5 6 |
#!bin/bash declare -A cars cars["BMW"]="M5" cars["VOLVO"]="X70" cars["LEXUS"]="LX470" echo ${cars["LEXUS"]} |
Se puede usar un bucle for para iterar repetidamente a través de todas las claves en una matriz asociativa. Aquí hay un ejemplo en Bash que muestra cómo hacer esto:
|
1 2 3 4 5 6 7 8 9 |
#!bin/bash declare -A cars cars["BMW"]="M5" cars["VOLVO"]="X70" cars["LEXUS"]="LX470" for key in "${!cars[@]}" do echo "The model of ${key} is ${cars[$key]}" done |
Aquí he usado la sintaxis $ {!cars[@]} para obtener todas las claves en la matriz asociativa y luego usé un ciclo for para iterar sobre todas las claves e imprimir los valores correspondientes. Las matrices asociativas son una estructura de datos poderosa que le permite almacenar pares clave-valor en Bash. Puede crear una matriz asociativa usando la sintaxis declare -A, agregarle elementos usando la sintaxis array[key]=value y acceder a los elementos usando sus claves correspondientes. Las matrices asociativas pueden ser útiles para organizar y manipular datos en sus scripts de Bash.
Este método es un poco complejo. Este método discutirá una matriz especial de secuencias de comandos Bash denominada matriz asociativa.
Una matriz asociativa es una matriz especial que puede almacenar un valor de cadena como clave o índice. Es similar a los otros lenguajes de programación.
La sintaxis general para declarar una matriz asociativa es declare -A ArrayName.
Nuestro ejemplo a continuación creará una matriz 2D que contiene cinco filas y seis columnas. A continuación se muestra el código de nuestro ejemplo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
#!/bin/bash declare -A Array2D RowNum=5 ColumnNum=6 for ((i=1;i<=RowNum;i++)) do for ((j=1;j<=ColumnNum;j++)) do Array2D[$i,$j]=$RANDOM done done f1="%$((${#RowNum}+1))s" f2=" %9s" printf "$f1" '' for ((i=1;i<=RowNum;i++)) do printf "$f2" $i done echo for ((j=1;j<=ColumnNum;j++)) do printf "$f1" $j for ((i=1;i<=RowNum;i++)) do printf "$f2" ${Array2D[$i,$j]} done echo done |
En el ejemplo anterior, declaramos una matriz asociativa llamada Array2D.
Después de eso, creamos dos variables y les asignamos un valor entero. Este valor entero especifica el número de filas y columnas.
Luego creamos un ciclo anidado que llenó la matriz con el número aleatorio.
Ahora hemos terminado de declarar y organizar la matriz. Es hora de ver cómo se ve nuestra matriz 2D.
Lo hacemos usando algunos bucles, como se ve en el código. Cuando ejecute el script anterior, verá un resultado como el siguiente.
|
1 2 3 4 5 6 7 |
1 2 3 4 5 1 16700 5241 2599 24330 1662 2 23264 19557 10425 13413 25606 3 17987 4199 13598 23897 26734 4 24420 27830 24855 8165 13531 5 15495 18790 13347 12947 11826 6 23458 22838 137 32454 32441 |
Una matriz multidimensional es un elemento muy importante para cualquier programa. Se utiliza principalmente para crear una vista de tabla de los datos y para muchos otros fines.
Este es el método más básico para crear una matriz multidimensional. En nuestro ejemplo a continuación, crearemos una matriz bidimensional muy básica.
A continuación, se muestra el código de nuestro ejemplo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
#!/bin/bash ArrayOfArray_1=("Alen" "24") ArrayOfArray_2=("Walker" "31") MainArray=( ArrayOfArray_1[@] ArrayOfArray_2[@] ) ArrayLength=${#MainArray[@]} for ((i=0; i<$ArrayLength; i++)) do name=${!MainArray[i]:0:1} age=${!MainArray[i]:1:1} echo "Name : ${name}" echo "Age : ${age}" done |
El código anterior muestra que declaramos dos matrices diferentes llamadas ArrayOfArray_1 y ArrayOfArray_2. Después de eso, declaramos nuestra matriz principal, cuyo elemento son estas dos matrices que declaramos recientemente.
Luego calculamos la longitud de la matriz para un bucle. Dentro del bucle, extraemos los datos de estos dos subconjuntos indexando el conjunto principal.
Por último, nos hacemos eco del resultado final. Después de ejecutar el script, obtendrá un resultado como el que se muestra a continuación. Al ejecutar este script, obtendremos lo siguiente :
|
1 2 3 4 |
Name : Alen Age : 24 Name : Walker Age : 31 |
|
1 2 3 4 5 6 7 8 9 10 11 |
#!/bin/bash function Iterate() { arr=("$@") for IDX in "${arr[@]}"; do echo "$IDX" done } array=("arg1" "arg-2" "arg 3") Iterate "${array[@]}" |
O también puede ser, pasarselo por referencia. Es más entendible :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
#!/bin/bash get_arr() { declare -n array_param="$1" echo "Elementos: ${array_param[@]}" } arr1=(a be ce de) arr2=(uno dos tres cuatro) get_arr arr1 get_arr arr2 |
Al ejecutarlo obtendriamos lo siguiente :
|
1 2 3 |
$ ./array_params.sh Elementos: a be ce de Elementos: uno dos tres cuatro |
De todas maneras, en ninguno de los casos le pasas el array como parametro. En el primer SCRIPT, desempaquetas el array enfrente de tu función, y le pasas los elementos separados por un espacio; en el segundo SCRIPT, le pasas el nombre de la variable; ya adentro, el nombre se expande y se le referencia a esa otra variable externa para que pueda ser manipulada indirectamente.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
Por defecto, una variable, en cualquier script en Bash, con independencia de su contenido, es tratada como una cadena de texto, y no como un número. Esto, como te puedes imaginar, complica esto de las operaciones matemáticas. Así, en primera instancia podrías pensar que es mejor utilizar algún otro lenguaje de programación para estos menesteres. Sin embargo, no es necesario, con el paso de las versiones de Bash, poco a poco, se ha ido mejorando. Sin embargo, una observación importante, Bash solo opera con enteros. Para realizar operaciones matemáticas en Bash con números reales, necesitas utilizar bc. Así básicamente tienes hasta cinco opciones, al menos, para facilitarte el trabajo con las operaciones matemáticas. Se trata de declare, expr, let, dobles paréntesis y bc tal y como te he adelantado en el párrafo anterior. DECLARE La primera de las opciones que tienes para realizar operaciones matemáticas es declare. Así, con declare defines algunas propiedades de la variable. -r define la variable como de solo lectura. Es decir, que tu variable es inmutable, de forma que si intentas cambiar su valor te arrojará un error. -i te permite declarar la variable como un entero. -a lo utilizarás para declarar arrays. -f te permite declarar una función. Además si ejecuta declare -f, así sin argumentos, obtendrás un listado de las funciones declaradas previamente. Una observación importante es que al definir una variable con declare estás restringiendo su ámbito a la función donde lo hayas declarado. Es decir, básicamente es como si utilizas local. Así algunos ejemplos, declare -ir entero=10 echo "Este es un entero de valor $entero" entero=10.5 Al ejecutar las instrucciones anteriores, te aparecerá un mensaje de error con el siguiente texto -bash: entero: variable de sólo lectura. EXPR La segunda de las opciones para realizar operaciones matemáticas en Bash es utilizando expr. Se trata de un antigua aplicación de Unix, utilizada cuando Bourne Shell, no soportaba operaciones matemáticas. Sin embargo, hoy por hoy no tiene tanto sentido su uso. Ten en cuenta que necesitarás espacios entre los operandos y el operador. Así por ejemplo, echo $(expr 1+1) te devolverá 1+1, mientras que echo $(expr 1 + 1) te devolverá, como esperas, 2. Así algunos ejemplos, echo $(expr 5 \* 5) devuelve 25, y si, hay que escapar el signo de multiplicación. d=1;echo $(expr $d + 1 ) devuelve 2. LET Otra opción para realizar operaciones matemáticas es let. let evalua cada argumento como una expresión aritmética. Las operaciones se evaluan como enteros, mientras que una división por cero arrojará un error. De nuevo, las cosas se ven mas claras con unos ejemplos, let z=25; echo $z Devuelve 25 let z++; echo $z Devuelve 26 let z=z+10; echo $z. Devuelve 36 DOBLES PARENTESIS. Como ya viste en un capítulo anterior del tutorial, otra opción para realizar operaciones matemáticas, es el uso de los dobles paréntesis. Al fin y al cabo, los dobles paréntesis se comportan como let que acabas de ver. Aunque tienen la ventaja de que un doble paréntesis puede incluir a otro doble paréntesis. De esta manera, los ejemplos que te he indicado para let se pueden hacer exactamente igual para el caso de los dobles paréntesis, ((z=25)); echo $z Devuelve 25 ((z++)); echo $z Devuelve 26 ((z=z+10)); echo $z. Devuelve 36 Pero además, si quieres devolver el resultado de una operación simplemente tienes que preceder el doble paréntesis con $, es decir, puedes simplificar los ejemplos anteriores de la siguiente manera, echo $((z=25)); Devuelve 25 echo $((z++)); Devuelve 26 echo $((z=z+10));. Devuelve 36 Esto ta va a permitir, como he adelantado anteriormente, incluir una operación matemática dentro de otra. Por ejemplo, `echo $((25 + $((5+5)))) o incluso echo $((25 + $((diez=5+5))));echo $diez MATEMATICAS EN BASH CON BC. Como ya te has dado cuenta, todas las operaciones matemáticas realizadas hasta el momento solo implican números enteros. Sin embargo, ¿que sucede cuando quieres realizar operaciones matemáticas con números reales?. En este caso necesitarás recurrir a una herramienta como es bc. bc es una herramienta que funciona exactamente como una calculadora matemática. Tu le pasas una serie de operaciones, y esta herramienta se encarga de evaluarla. Un par de ejemplos sencillos, echo '4.1+5.2' | bc devuelve 9.3 echo '4.1*5.2' | bc devuelve 21.3 Si quieres guardar el resultado de la operación en una variable, tienes que modificar los ejemplos anteriores como sigue, z=$(echo '4.1+5.2' | bc);echo $z devuelve 9.3 z=$(echo '4.1*5.2' | bc);echo $z devuelve 21.3 También es posible definir variables. Sin embargo, estas variables son locales a bc, es decir, luego no las vas a poder utilizar fuera de la expresión que le has pasado a la herramienta bc. Es decir, echo 'var=10;var++;var' | bc te devolverá 11. Sin embargo si ejecutas echo $var no obtendrás valor alguno. bc admite operadores incrementales y decrementales, incluidos los precedentes. Me refiero a ++ y --. Así, echo 'var=10;++var' | bc devolverá 11 echo 'var=10;var++' | bc devolverá 10 COMPARACIONES. bc soporta comparaciones, teneiendo en cuenta que en todos los casos 1 es quivalente a True y 0 es equivalente a False, como puedes ver en los siguientes ejemplos, echo '2 > 1' | bc devuelve 1 echo '1 != 2' | bc devuelve 1 echo '2 > 1 && 2 != 1' | bc devuelve 1 FUNCIONES MATEMATICAS Igualmente bc soporta algunas funciones matemáticas que te pueden resultar de gran utilidad. Algunas de estas funciones matemáticas son las siguientes, s(x) para calcular el seno de un ángulo en radianes c(x) para calcular el coseno de un ánguno en radianes a(x) te permite calcular el arcotangente l(x) para calcular el logaritmo e(x) esta función te permite calcular la exponencial de un número sqrt(x) para cacular la raíz cuadrada Por otro lado tienes un par de funciones que seguro te serán de gran utilidad, length(x) te indica el número de dígitos de un valor scale(x) si la función anterior te permite saber los dígitos de un valor, con esta función puedes establecer el número de dígitos con los que se devolverán los resultados. |
En NagiosQL, al definir un servicio a monitorear, especificamente al ingresar un argumento, no permite poner espacios en blanco. Esto da un error al ejecutar el proceso, ya que al encontrar espacios en blanco, asume que es un nuevo argumento. Para solucionar esto se debe definir uno o varios caracteres que indicaran que corresponde a un espacio en blanco y luego en el SCRIPTS ubicado en el equipo a monitorear. Para este ejemplo, definire que la cadena «-b-» corresponde a un espacio en blanco. Luego el script ubicado en el servidor a monitorear, procede a transformar la cadena (proceso) y pone los espacios en blanco donde corresponde.
El siguiente SCRIPT puede utilizarse para monitorear cualquier proceso que este corriendo en un servidor. Utiliza 3 argumentos, el proceso a monitorear, el usuario con que corre el proceso y el minomo y maximo de procesos que corren simultaneamente (Formato min:max) :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
#!/bin/bash # parametro1 Corresponde al proceso a monitorear # parametro2 Corresponde al usuario dueñel proceso a monitorear # parametro3 Corresponde corresponde al minimo y maximo de procesos (min:max) proceso=$1 usuario=$2 minmaxi=$3 # Saca el valor minimo y maximo de proceso a monitorear. min=`echo $minmaxi | cut -d: -f1` max=`echo $minmaxi | cut -d: -f2` #Cambia el patron "-b-" por un espacio en blanco proceso=`sed 's/-b-/ /g' <<< $proceso` # El siguiente comando busca el proceso en que el paarametro2 esta al final y comienza con el usuario # y Cuenta el numero de proceso encontrados ps=`ps -fu $usuario | grep "$proceso" | wc -l"` # Eliminamos los espacios en blanco, delante y detras de la variable num=`echo $ps | sed 's/ //g'` if [ "$num" -ge "$min" ] && [ "$num" -le "$max" ]; then echo "OK - $num Proceso $1 $2 ($3) $4" exit 0 else echo "CRITICAL - $num Proceso $1 $2 ($3) $4" exit 2 fi |
