info twelve

Procesamiento de registros con AWK

Estas construcciones presentan la siguiente sintaxis:

BEGIN {sentencias}  Preprocesamiento
{sentencias}  Procesamiento
END {sentencias}  Postprocesamiento

un ejemplo, el sencillo script “suma.awk” pone a cero la variable “total” antes de iniciar el proceso del archivo de entrada, añade a esa variable el valor correspondiente al contenido del primer campo de cada registro, y muestra el valor de la variable al final:

BEGIN {total=0}
{total += $1}
END {print “Total=“,total}

Para ejecutarlo podríamos usar:

[alumno@localhost ~]$ echo -e "10\n10\n10\n70" ¦ awk -f ./suma.awk
Total=100

Para contar y desplegar en pantalla la cantidad de líneas y palabras de un archivo arch, usaremos el script AWK “contar.awk”:

BEGIN {lines=0; words=0}
{
lines++;
words += NF;
}
END {print “Líneas=“,lines,” Palabras=“,words}

Para ejecutarlo podríamos usar:

[alumno@localhost ~]$ awk -f ./contar.awk arch
Líneas=3 Palabras=12




Veamos algunos ejemplos de uso de EXPRESIONES REGULARES en AWK:
Para obtener el tamaño promedio de los archivos del directorio actual, podemos usar:

ls -al ¦ awk ′BEGIN {total=0;count=0}
/^[^d]/ {total += $5; count++}
END {print total/count}′

Notar que la expresión regular o patrón es /^[^d]/ donde el primer ^ indica “coincidencia al principio de la línea” y el [^d] indica “cualquier cosa que no sea una d”.

Variables y datos en PERL
Las cadenas de caracteres se especifican literalmente por medio de un sucesión de caracteres delimitada por comillas ("..") o apóstrofes ('..').
Estas dos representaciones se distinguen por la interpretación hecha por PERL de las cadenas de caracteres. Cuando van delimitadas por comillas (".."), toda variable referenciada en el interior de la cadena se evalúa y se reemplaza por su valor.

Una lista es una colección ordenada de escalares; una variable que almacena una lista se llama array o arreglo.
Un hash, o memoria asociativa, es un mapeo de strings a escalares; los strings se llaman claves y los escalares valores.
Por ejemplo, para definir variables escalares podemos usar:

$num=10;
$hexa=0x1A;
$msg=“Hola Mundo!”

Una lista se define listando sus elementos, separados por comas y rodeados por paréntesis donde así sea requerido por la precedencia de los operadores.
Para definir una lista podemos usar:

@lista= (7, 15, “hola”, “chao”);

Los elementos individuales de una lista son accedidos utilizando un índice numérico (que inicia en 0), dentro de corchetes.
Por ejemplo, a $lista[0] le corresponde el 7, a $lista[1] le corresponde el 15, a $lista[2] le corresponde “hola” y a $lista[3] le corresponde “chao”.

Arreglos en PERL
Los arreglos o lista de PERL comienzan con el signo “@“ y contienen una lista de valores escalares (números y/o textos).
Al ser una lista de valores, para acceder a cada de uno estos se utiliza un número que indica su posición dentro de la lista.
La numeración empieza en 0, y se coloca entre corchetes [ ].

A este número que indica la posición de un valor dentro de la lista del arreglo se le denomina índice.
Como se vio anteriormente, para la asignación de un arreglo se usa el caracter “@”, y para acceder a un valor individualmente se utiliza el signo “$”, ya que en definitiva un arreglo está formado por distintas variables escalares.
Veamos un programa PERL que usa arreglos:

clear;
@A=(7,15,”hola”,”chao”);
print $A[1],”\n”;

Si este programa tiene como nombre “prg1”, para ejecutarlo usaríamos:

[alumno@localhost ~]$ perl prg1
15
[alumno@localhost ~]$

Asociados a los arreglos, existen algunas funciones en PERL que ayudan a poner o sacar elementos de la lista de datos del arreglo:
push – Colocar nuevos elementos al final de la lista: push(@arreglo, valores).
pop – Sacar el último elemento del arreglo. Se puede asignar a una variable tipo escalar: $variable=pop(@arreglo).

unshift - Reemplazar el primer elemento del arreglo: unshift(@arreglo, valor).
shift - Sacar el primer elemento del arreglo. Se puede asignar a una variable de tipo escalar: $variable=shift(@arreglo).
También se tiene una notación especial para conocer el último índice del arreglo, por medio de $#nombre_arreglo.

Veamos un ejemplo en donde se muestran los efectos de la aplicación de estas funciones sobre un arreglo.
Para efectos de comprensión se han especificado los valores impresos por los print y se han “dibujado” los arreglos y sus contenidos, en la medida que se aplican las funciones sobre él.

clear;
@A=(7,15,”hola”,”chao”); - - - - - -
print $A[1],”\n”;  15
push(@A,10,”Perl”); - - - - - - - - - -
print $A[5],”\n”;  Perl
print “Último Índice=”,$#A,”\n”;  5
shift (@A); - - - - - - - - - - - - - - - - -
print $A[0],”\n”;  15

Entrada/Salida en PERL
El print es la instrucción básica para mostrar el valor de las variables en pantalla.
Existen muchos modificadores para la salida de los valores de las variables en pantalla, entre algunos de estos, podemos nombrar: “\n” para nueva línea, “\t” para tabulación, “\r” para retorno de carro, xN para repetir un caracter o texto anterior N veces, etc.
Veamos algunos ejemplos de uso de print:

print “hola PERL \n”;  hola PERL
print “5x3”;  555 (muestra 3 veces el 5)
print “hola”x2;  hola hola

Para asignar un valor desde el teclado a una variable, se asigna a la variable la representación del teclado , de acuerdo con el siguiente formato:

$variable=;

Por ejemplo, veamos un simple programa PERL con E/S:

clear;
print “Ingrese Nombre: “;
$nom=;
print “Nombre=$nom”;

La función chop se utiliza para eliminar el último caracter de una entrada de datos, normalmente nueva línea.
chop(...) elimina el último caracter de una entrada por teclado. Un ejemplo de uso sería: $nom=chop($nom);.

Control del flujo en PERL
La mayoría de las estructuras de control en PERL, han sido heredadas del lenguaje C/C++.
La estructura condicional más simple es el IF:

if (condición){
sentencias…
}
else{
sentencias…
}

En la evaluación de las condiciones del IF (y de cualquier sentencia de control del flujo) podemos usar <, <=, >, >=, == y != para comparar números y lt, le, gt, ge, eq y ne para comparar literales.
Veamos un ejemplo de uso de estos operadores:

clear;
print “Número: “;
$num=;
chop($num);
if ($num >= 0){
print $num,” es positivo \n”;
}
else{
print $num,” es negativo\n”;
}

La sentencia iterativa WHILE presenta el siguiente formato:

while (condición){
sentencias…
}

Veamos un ejemplo de uso de la sentencia WHILE:

clear;
$i=1;
while ($i <= 5){
print $i*$i,”\n”;
$i=$i + 1;
}

La sentencia FOREACH se utiliza comúnmente para recorrer los valores de los arreglos o listas. Los elementos del arreglo o lista actúan como contadores del ciclo, ejecutándose el ciclo una vez por cada uno de estos elementos. La sintaxis para FOREACH es la siguiente:

foreach $variable (lista){
sentencias…
}

#Llenar arreglo con datos clear; @A=(); while (1){ print “Ingrese dato: “; $dato=;
chop($dato);
push(@A,$dato);
print “Más datos [Si/No]: “;
$opc=;
if ( chop($opc) eq “No”){
last;
}
}

#Listar los datos del arreglo
clear;
print “Listado de datos \n\n”;
foreach $a (@A){
print $a,”\n”;
}

#Mostrar cantidad de datos
print “Cantidad de datos=“,$#A+1,”\n”;

#Sumar los datos del arreglo
clear;
$sum=0;
foreach $a (@A){
$sum = $sum + $a;
}
print “Suma=“,$sum,”\n”;

Veamos un ejemplo de uso de la sentencia FOREACH:

clear;
@A=(1,7,”Hola”,10);
foreach $a (@A){
print $a,”\n”;