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
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,
Extraer titulos de URL.
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
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-tcsv_data<"$input_file"
forline 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 :
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:
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.
Después de ejecutar el script, obtendrá un resultado como el que se muestra a continuación.
1
The sorted list is:567abcn
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-tlines<testfile.txt
# Declare a 2D array with 3 rows and 3 columns
declare-Aarray
# Iterate over the lines and split each line into elements
foriin"${!lines[@]}";do
IFS=' 'read-r-aelements<<<"${lines[i]}"
forjin"${!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
Conclusión
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
functionburbuja{
lista=$1
tam=${#lista[@]}
foriin$(seq1$[$tam-1]);do
forjin$(seq0$[$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=(54321)
burbuja$lista
foriin${lista[@]};doecho$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.
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.
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
functioninserciondirecta{
lista=$1
tam=${#lista[@]}
foriin$(seq1$[$tam-1]);do
v=${lista[$i]}
j=$[$i-1]
while[[$j-ge0&&${lista[$j]}-gt$v]];do
lista[$[$j+1]]=${lista[$j]}
j=$[$j-1]
done
lista[$[$j+1]]=$v
done
}
lista=(54321)
inserciondirecta$lista
foriin${lista[@]};doecho$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
functioninsercionbinaria{
lista=$1
tam=${#lista[@]}
foriin$(seq1$[$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=(54321)
insercionbinaria$lista
foriin${lista[@]};doecho$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.
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:
Shell
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:
Shell
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:
Shell
1
2
3
4
declare-Acars
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:
Shell
1
2
3
4
5
6
#!bin/bash
declare-Acars
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:
Shell
1
2
3
4
5
6
7
8
9
#!bin/bash
declare-Acars
cars["BMW"]="M5"
cars["VOLVO"]="X70"
cars["LEXUS"]="LX470"
forkey 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.
Shell
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-AArray2D
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.
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.
Shell
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 :
O también puede ser, pasarselo por referencia. Es más entendible :
Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
#!/bin/bash
get_arr(){
declare-narray_param="$1"
echo"Elementos: ${array_param[@]}"
}
arr1=(abe ce de)
arr2=(uno dos tres cuatro)
get_arr arr1
get_arr arr2
Al ejecutarlo obtendriamos lo siguiente :
Shell
1
2
3
$./array_params.sh
Elementos:abe 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.
Por defecto,una variable,en cualquier script en Bash,con independencia de su contenido,es tratada como una cadena de texto,yno como unnúmero.Esto,como te puedes imaginar,complica esto de las operaciones matemáticas.Así,en primera instancia podríaspensar que es mejor utilizar algúnotro lenguaje de programaciónpara estos menesteres.Sin embargo,no es necesario,con el paso de las versiones de Bash,pocoapoco,se ha ido mejorando.
Sin embargo,una observaciónimportante,Bashsolo opera con enteros.Para realizar operaciones matemáticas en Bashconnú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éntesisybctalycomo te he adelantado en elpárrafo anterior.
DECLARE
La primera de las opciones que tienes para realizar operaciones matemáticas es declare.Así,con declaredefines algunas propiedades de la variable.
-rdefine 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.
-ite permite declarar la variable como un entero.
-alo utilizaráspara declarar arrays.
-fte permite declarar una función.Ademássi ejecuta declare-f,asísin argumentos,obtendrásun listado de las funciones declaradas previamente.
Una observaciónimportante es que al definir una variable con declareestásrestringiendo suámbitoala funcióndonde 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 desólo lectura.
EXPR
La segunda de las opciones para realizar operaciones matemáticas en Bashes utilizando expr.Se trata de un antigua aplicaciónde 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ásespacios entre los operandosyel operador.Asípor ejemplo,echo$(expr1+1)te devolverá1+1,mientras que echo$(expr1+1)te devolverá,como esperas,2.
Asíalgunos ejemplos,
echo$(expr5\*5)devuelve25,ysi,hay que escapar el signo de multiplicación.
d=1;echo$(expr$d+1)devuelve2.
LET
Otra opciónpara realizar operaciones matemáticas es let.let evalua cada argumento como una expresiónaritmética.Las operaciones se evaluan como enteros,mientras que una divisiónpor cero arrojaráun error.
De nuevo,las cosas se ven mas claras con unos ejemplos,
letz=25;echo$zDevuelve25
letz++;echo$zDevuelve26
letz=z+10;echo$z.Devuelve36
DOBLES PARENTESIS.
Como ya viste en un capítulo anterior del tutorial,otra opciónpara realizar operaciones matemáticas,es el uso de los dobles paréntesis.Al finyal cabo,los dobles paréntesis se comportan como let que acabas de ver.Aunque tienen la ventaja de que un doble paréntesis puede incluiraotro 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$zDevuelve25
((z++));echo$zDevuelve26
((z=z+10));echo$z.Devuelve36
Pero además,si quieres devolver el resultado de una operaciónsimplemente tienes que preceder el doble paréntesis con$,es decir,puedes simplificar los ejemplos anteriores de la siguiente manera,
echo$((z=25));Devuelve25
echo$((z++));Devuelve26
echo$((z=z+10));.Devuelve36
Esto ta vaapermitir,como he adelantado anteriormente,incluir una operaciónmatemática dentro de otra.Por ejemplo,
`echo$((25+$((5+5))))
oincluso echo$((25+$((diez=5+5))));echo$diez
MATEMATICAS EN BASHCON BC.
Como ya te has dado cuenta,todas las operaciones matemáticas realizadas hasta el momento solo implicannúmeros enteros.Sin embargo,¿que sucede cuando quieres realizar operaciones matemáticas connúmeros reales?.En este caso necesitarásrecurrirauna herramienta como es bc.
bces una herramienta que funciona exactamente como una calculadora matemática.Tu le pasas una serie de operaciones,yesta herramienta se encarga de evaluarla.
Un par de ejemplos sencillos,
echo'4.1+5.2'|bcdevuelve9.3
echo'4.1*5.2'|bcdevuelve21.3
Si quieres guardar el resultado de la operaciónen una variable,tienes que modificar los ejemplos anteriores como sigue,
z=$(echo'4.1+5.2'|bc);echo$zdevuelve9.3
z=$(echo'4.1*5.2'|bc);echo$zdevuelve21.3
Tambiénes posible definir variables.Sin embargo,estas variables son localesabc,es decir,luego no las vasapoder utilizar fuera de la expresiónque le has pasadoala herramienta bc.Es decir,
echo'var=10;var++;var'|bcte devolverá11.Sin embargo si ejecutas echo$varno obtendrásvalor alguno.
bcadmite operadores incrementalesydecrementales,incluidos los precedentes.Me refieroa++y--.Así,
echo'var=10;++var'|bcdevolverá11
echo'var=10;var++'|bcdevolverá10
COMPARACIONES.
bcsoporta comparaciones,teneiendo en cuenta que en todos los casos1es quivalenteaTruey0es equivalenteaFalse,como puedes ver en los siguientes ejemplos,
echo'2 > 1'|bcdevuelve1
echo'1 != 2'|bcdevuelve1
echo'2 > 1 && 2 != 1'|bcdevuelve1
FUNCIONES MATEMATICAS
Igualmente bcsoporta 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ónte permite calcular la exponencial de unnúmero
sqrt(x)para cacular la raízcuadrada
Por otro lado tienes un par de funciones que seguro te seránde gran utilidad,
length(x)te indica elnúmero dedígitos de un valor
scale(x)si la funciónanterior te permite saber losdígitos de un valor,con esta funciónpuedes establecer elnúmero dedígitos con los que se devolveránlos 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) :
Shell
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
El procesamiento en paralelo en Bash se refiere a la ejecución simultánea de múltiples tareas o comandos en un script de Bash. Esto permite aprovechar al máximo los recursos disponibles en un sistema y puede acelerar considerablemente la ejecución de un programa o script.
Hay varias formas de lograr el procesamiento en paralelo en Bash. Una de las formas más comunes es utilizando subprocesos en segundo plano (background processes) y el comando wait para esperar a que todos los subprocesos terminen antes de continuar con el script principal.
Aquí hay un ejemplo simple que muestra cómo ejecutar múltiples comandos en paralelo usando subprocesos en segundo plano,
Shell
1
2
3
4
5
6
7
8
9
10
11
12
#!/bin/bash
# Comando 1 en segundo plano
comando1&
pid1=$!
# Comando 2 en segundo plano
comando2&
pid2=$!
# Esperar a que los subprocesos terminen
wait$pid1
wait$pid2
# Continuar con el script principal
echo"Todos los subprocesos han terminado."
Es importante tener en cuenta que el número de subprocesos en paralelo que se pueden ejecutar al mismo tiempo puede estar limitado por el sistema operativo y los recursos disponibles en el sistema. Además, el procesamiento en paralelo puede introducir complejidad adicional debido a posibles problemas de concurrencia, como la competencia por recursos compartidos. Por lo tanto, es importante diseñar y probar cuidadosamente el uso de procesamiento en paralelo en un script de Bash.
Un ejemplo
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,
Shell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/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
Por si estás programando algun script en bash o necesitar imprimir algun texto en consola de manera especial y no recuerdas cual era la combinación, El siguiente script (color-bash.sh) te imprime una tabla de colores en bash:
Shell
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
#!/bin/bash
# prints a color table of 8bg * 8fg * 2 states (regular/bold)
Grep (por sus siglas en inglés Globally Search For Regular Expression and Print out) es una herramienta de líneas de comando usada para buscar cadenas de texto y encontrar coincidencias dentro de este. También puede ser utilizada para encontrar una palabra o combinación de palabras dentro de un fichero.
Esta herramienta requiere de dos parámetros básicos como el patrón a buscar y el archivo en el que se realizará la búsqueda. Además, es importante que conozcamos las expresiones regulares, debido a que estos patrones nos permitirán introducir combinaciones y caracteres para mejorar las búsquedas que hagamos. Una expresión regular usualmente es tomada por el comando de una línea de comandos, lee la lista de archivos e imprime las líneas que contienen coincidencias con la expresión regular.
Shell
1
2
3
4
5
6
CLASES DE CARACTERES EN GREP.
[:blank:]Coincide con caracteres en blanco,tales como un espaciooun tabulador.
[:digit:]Coincide con caracteres numéricos.Equivalea[0-9]
[:lower:]Coincide con caracteres alfabéticos en minúscula.Equivalea[a-z]
[:upper:]Coincide con caracteres alfabéticos en mayúsculas.Equivalea[A-Z]
[:punct:]Coincide con signos de puntuacióntales como!,#, $ y @
1.- Podemos filtrar únicamente aquellas líneas que contengan números con el siguiente comando:
grep [[:digit:]] /tmp/archivo.txt
2.- Otra funcionalidad interesante es la de buscar varios patrones en uno o varios archivos. Supongamos que tenemos un archivo de texto denominado /tmp/usuarios.txt, que contiene lo siguiente:
Power
Docker
Y quisiéramos buscar dentro del archivo /etc/group aquellas líneas que
contengan las palabras «power» o «docker». Podríamos hacer lo siguiente:
grep -f /tmp/usuarios.txt /etc/group
3.- Este comando filtra, del archivo /etc/passwd, aquellas líneas que incluyan la palabra «root» o «dbus» al principio de la línea.
grep -E «^root|^dbus» /etc/passwd
4.- Buscar los número con 1 o 2 dígitos…
grep -E «^[0-9][0-9]?$» numeros.txt
Si cambiamos por un * aparecerá 0 veces o más veces por lo tanto mostrara todos los números.
$ grep -E «^[0-9][0-9]*$» numeros.txt
Podemos decir que los primeros números sean del 0 al 9 y los segundos del 0 al 5 por ejemplo. Eso excluirá los 2°, 3° y 4° dígito superior a 5 …
$ grep -E «^[0-9][0-5]*$» numeros.txt
Determinar el número exacto de veces que deseamos que se repita el rango.
$ grep -E «^[0-9]{3}$» numeros.txt
144
233
Especificamos un rango de veces. Por ejemplo los números que contengan 2 a 4 veces.
$ grep -E «^[0-9]{2,4}$» numeros.txt
55
89
144
987
1597
6765
Agrupar expresiones.
Si queremos los números de 1 dígito y los de 3 dígitos, podemos usar dos expresiones regulares dentro de grep con la opción -e por ejemplo…
8.- Sacar 2 lineas por encima y 2 lineas por debajo del output :
Cat /etc/passwd | grep -i “ROOT” -C 2
9.- Si al inicio de la salida del comando quieren añadir el nombre del fichero en que se halla la línea mostrada en pantalla deberán usar la opción -H del siguiente modo:
grep -H -F ‘the’ .bashrc
10.- Pero si queremos obtener únicamente aquellas líneas cuyo único contenido sea la palabra blanco añadiremos la opción -x del siguiente modo:
grep -w -x «blanco» /home/joan/opciones.txt
11.- Con él podemos buscar, por ejemplo, secuencias de varios números seguidos que empiecen con «:».
grep -E ‘:[0-9]+’ regex
12.- Primero vamos a buscar todas las secuencias de cuatro dígitos que haya:
grep ‘[0-9]\{4\}’ regex
13.- Ahora el otro ejemplo con las llaves. Supongamos que queremos encontrar palabras que tengan entre 3 y 6 letras minúsculas. Podríamos hacer lo siguiente:
grep ‘[a-z]\{3,6\}’ regex
14.- Extraer la lista de direcciones de correo electrónico de un archivo:
21.- Cantidad de líneas que comiencen con una o ninguna c seguida de la cadena ati.
grep -cE «^c?ati» /usr/share/hunspell/en_US.dic
22.- Vamos con cosas un poco más complicadas. El carácter «+» empareja con el carácter que aparece a su izquierda repetido al menos una vez. Este carácter sólo está disponible con las expresiones regulares extendidas. Con él podemos buscar, por ejemplo, secuencias de varios números seguidos que empiecen con «:».
grep -E ‘:[0-9]+’ regex
23.- Buscar todas las secuencias de cuatro dígitos que haya:
Si es un lector habitual de este blog y le gusta su contenido quizá quiera contribuir a su mantenimiento. Cualquier cantidad por pequeña que sea será bien recibida.