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.
