Foro - Perl en Español

Buenas tardes.

Tengo que comparar un par de archivos de texto con la siguiente estructura:



En el archivo nuevo puede haber cambiado la edad o dirección de algún registro, por lo que en el resultado debo guardar tanto la línea del archivo viejo como la del nuevo. Si no ha cambiado nada, no guardo nada en el resultado.

La estrategia que he seguido es la siguiente:

1. leo el archivo viejo y lo meto en un hash
2. abro el archivo nuevo y, para cada línea, veo si existe la clave en el hash anterior
   
   1. Si existe la clave, no guardo nada
   2. Si no existe, guardo la línea en un archivo intermedio llamado "Diferencias.txt"
3. una vez tengo el archivo de diferencias completado, lo vuelvo a abrir y, para cada línea, leo un valor que no se repite, que es el "alias"
4. abro el archivo viejo, busco la línea que contiene ese alias y la guardo en el resultado final "Comparado.txt" con el indicador "Archivo viejo" al inicio de la línea
5. abro el archivo nuevo, busco la línea que contiene ese alias y la guardo en el resultado final "Comparado.txt" con el indicador "Archivo nuevo" al inicio de la línea.

De esta forma, en el archivo final "Comparado.txt" he guardado un registro del valor que tenía la línea en el archivo viejo y del que tiene ahora en el archivo nuevo.

El problema es que los archivos que estoy comparando tienen sobre 2000 líneas y he visto que hay "alias" que, a pesar de estar en el archivo intermedio "Diferencias.txt" han desaparecido en el archivo de resultados. Y algún "alias" que, a pesar de existir una sola vez en el archivo "Diferencias.txt", aparece duplicado en el resultado.

Como no tengo mucha experiencia con Perl, seguro que he metido la pata en algo. ¿Alguna sugerencia? Os dejo aquí el código empleado, por si a alguien le puede servir. Gracias de antemano.

Si entendí bien, ambos ficheros tienen los mismos registros o tuplas, solo que en el segundo fichero el campo 'Dirección' o el campo 'Edad' de algunas de esas tuplas, fueron modificados. Si es así, tu algoritmo es correcto, aunque ineficiente. Si las tuplas están en el mismo orden en ambos ficheros, comparas línea a línea y si estuvieran en orden distinto (teniendo en cuenta que el alias es el identificador), podrías guardar dos hashes: %hash1 y %hash2 en los que la clave sea el alias (ya que es único) y el valor sea la línea correspondiente a ese alias. Luego recorres la lista de aliases y comparas los campos 'Dirección' y 'Edad' de $hash1{$alias} con los de $hash2{$alias} y si son distintos, imprimes.

En cuanto a tu código, probablemente el error esté en cómo determinas que el registro $linea corresponde al alias $alias. Lo haces mediante


Imagínate que $alias es "Lau" y una de las líneas es:


Esa línea no se corresponde con una persona de alias 'Lau' (sino que su alias es 'anne') y sin embargo es matcheada por /Lau/. La regexp tendría que ser algo más sofisticada, por ejemplo,

bvayap escribiste:

Sintáxis: [ Descargar ] [ Ocultar ]

Sintáxis: [ Descargar ] [ Mostrar ]

Using perl Syntax Highlighting

1. my %a_lineas;
2.  
3. while ( my $linea1 = <$afile> ) {
4.     chomp $linea1;
5.     $a_lineas{$linea1} = 1;
6. }
7.  

Coloreado en 0.001 segundos, usando GeSHi 1.0.8.4

Yo escribiría eso mismo de esta manera:

En efecto, si guardas la información en hashes, no necesitas grabar y volver a leer el archivo de diferencias. Y el proceso será más rápido.

Te basta con hacer un split() usando el delimitador ';', y luego guardar la línea indexada por el alias (que se supone que es el valor que no se repite).

Lo que queda es recorrer las líneas del otro archivo y compararla con los valores almacenados. Si son líneas distintas, entonces es que hay algún cambio.

Al menos, eso entiendo que hay que hacer.

Por ejemplo, si tenemos estos dos archivos:


Con este programa:
Sale este resultado:

Gracias a ambos. Mañana intentaré probar vuestras soluciones.

La verdad es que anoche se me encendió la neurona y encontré una solución. No tengo el código delante, pero básicamente es:

1. Meto ambos archivos de texto en un hash cada uno.
2. Recorro el primer hash buscando si las claves existen en el segundo. Sí no existen, guardó la clave en un tercer hash de resultados.
3. Ídem recorriendo ahora el hash del segundo archivo y buscando las claves en el hash del primero.
4. Ordeno el hash de resultados.

Lo dicho, muchas gracias por vuestra aportación.
Saludos

¡Qué pulcritud inmaculada la del script de explorer! (válgase el pleonasmo). Lo único que cambiaría sería quizás

por

dado que ";" no es un metacaracter de las regexps como lo es, por ejemplo, un '.' (si fuera un punto, sí que justificaría poner '[.]' como alternativa a '\.').

Es mejor que lo yo había propuesto, dado que recorre el primer archivo para crear el hash %registros, y luego recorre el segundo archivo ya comparando con los registros antes guardados (yo había sugerido crear otro hash para el segundo archivo y luego hacer una tercer recorrida sobre los aliases comparando los registros de un hash con los del otro; es más eficiente lo que propone explorer).

bvayap escribiste:La verdad es que anoche se me encendió la neurona y encontré una solución. No tengo el código delante, pero básicamente es:

1. Meto ambos archivos de texto en un hash cada uno.
2. Recorro el primer hash buscando si las claves existen en el segundo. Sí no existen, guardó la clave en un tercer hash de resultados.
3. Ídem recorriendo ahora el hash del segundo archivo y buscando las claves en el hash del primero.
4. Ordeno el hash de resultados.

Yo supuse que la cantidad de registros en ambos ficheros era la misma y si hay un registro con alias 'X' en el fichero viejo, hay un registro con alias 'X' en el fichero nuevo. En cambio, explorer va un poco más allá y muestra también en el resultado los registros que están en el fichero nuevo y no están en el viejo (pero NO muestra los que están en el viejo y no están en el nuevo). No obstante, en la parte del if donde comenta "# Los registros son iguales: no se hace nada", se puede borrar del hash ese registro con lo que al final quedarían en él sólo los que están en el viejo y no están en el nuevo (y puedes desplegarlos al final). Tu solución es también correcta, y se puede optimizar teniendo en cuenta lo siguiente: si sabes que ciertas claves del primer hash están entre las claves del segundo hash, puedes excluirlas de la lista cuando te fijas en qué claves del segundo hash están entre las del primero (con lo cual te quedarán las que sabes de antemano que no están).

A veces pienso que explorer inventó Perl

Bueno, aquí os dejo mi código para que sea "criticado"

bvayap escribiste:

Sintáxis: [ Descargar ] [ Ocultar ]

Sintáxis: [ Descargar ] [ Mostrar ]

Using perl Syntax Highlighting

1. # Metemos cada fichero en su Hash
2. while (my $linea1 = <$a_file>) {
3.     chomp $linea1;
4.     $a_lineas{$linea1} = "Fichero Viejo;";
5. }
6. while (my $linea2 = <$b_file>) {
7.     chomp $linea2;
8.     $b_lineas{$linea2} = "Fichero Nuevo;";
9. }

Coloreado en 0.001 segundos, usando GeSHi 1.0.8.4

¿Por qué en el valor de los hashes guardas "Fichero Viejo;" o "Fichero Nuevo;" si después no usas esa información en ningún momento? Esto es cuestión de gustos, pero lo mismo que escribiste en forma de dos bucles, puede ser reescrito así:

bvayap escribiste:

Sintáxis: [ Descargar ] [ Ocultar ]

Sintáxis: [ Descargar ] [ Mostrar ]

Using perl Syntax Highlighting

1. # Recorremos el fichero nuevo para ver si la línea existe en el viejo
2. my $a;
3. my $b;
4. foreach $b (keys %b_lineas) {
5.         if (exists $a_lineas {$b}) {
6.                 next;
7.         } else {
8.                 $results {$b} = "Fichero nuevo;";
9.         }
10. }
11.  
12. # Recorremos el fichero viejo para ver si la línea existe en el nuevo
13. foreach $a (keys %a_lineas) {
14.         if (exists $b_lineas {$a}) {
15.                 next;
16.         } else {
17.                 $results {$a} = "Fichero viejo;";
18.         }
19. }

Coloreado en 0.001 segundos, usando GeSHi 1.0.8.4

Como dije en mi anterior mensaje, la segunda recorrida es innecesaria:


Otro pequeño detalle es que en tu archivo de resultados quizá en un caso aparece la línea del fichero nuevo y luego la del viejo, y en otro caso al revés (porque despliegas por orden ASCII).

Me parece mejor modificar ligeramente el script de explorer:

Si yo no hago chomp(), será por algo

El ponerle corchetes al ';' es para que... se note más. Pero... aún se puede hacer más escandaloso (Regla "Separated Data" del PBP, pág. 157). Ver código más abajo.

No es recomendable el uso de las variables $a y $b en cualquier código, ya que son "especiales" para el caso de los miniprogramas de sort{}.

Si se usa un Perl igual o superior a v5.12, el modo 'strict' y 'warnings' están activados por defecto. Por eso con una línea use v5.14;, basta para tener un entorno de desarrollo.

Si se usa 'autodie', no es necesario poner la coletilla 'or die "...";' en los open(), ya que, precisamente, ese es su trabajo.

No se pueden recorrer los registros usándolos como claves, ya que la clave del asunto es el 'alias', por ser el identificador único en los registros. Si no lo hacemos, dos registros serán "distintos" cuando haya un cambio pequeño (edad, por ejemplo).

La barra diagonal inversa '\' se suele usar para escapar, pero no siempre es necesario escapar... (ver código siguiente).

Es mejor usar #!/usr/bin/env perl ya que así podemos usar un perl distinto de el del sistema.

Otra solución, con otra forma de filtrar los registros:
La salida es: