Comment trier des lignes dans un fichier texte en Perl?

Question

J'ai deux fichiers texte (A.txt et B.txt) qui ressemblent à ceci (pourrait avoir ~ 10000 lignes chacun)

processa,id1=123,id2=5321 
processa,id1=432,id2=3721 
processa,id1=3,id2=521 
processb,id1=9822,id2=521 
processa,id1=213,id2=1 
processc,id1=822,id2=521 

Je dois vérifier si chaque ligne dans le fichier A.txt est présent dans B.txt aussi bien (B.txt pourrait avoir plus aussi, c'est correct).

La chose est que les lignes peuvent être dans un ordre quelconque dans les deux fichiers, donc je pense que je vais les trier dans un ordre particulier dans les deux fichiers dans O(nlogn) puis correspondre à chaque ligne A.txt aux lignes suivantes dans B.txt au O(n). Je pourrais mettre en place un hachage, mais les fichiers sont gros et cette comparaison ne se produit qu'une seule fois après laquelle ces fichiers sont régénérés, donc je ne pense pas que ce soit une bonne idée.

Quelle est la meilleure façon de trier les fichiers en Perl? Toute commande ferait, il faut juste une commande.

Par exemple, Comme je l'ai mentionné dans le dictionnaire commande, ce serait

processa,id1=123,id2=5321 
processa,id1=213,id2=1 
processa,id1=3,id2=521 
processa,id1=432,id2=3721 
processb,id1=9822,id2=521 
processc,id1=822,id2=521 

avant, toute commande serait tout aussi bien, aussi longtemps que Perl est rapide à le faire.

Je veux le faire à partir du code Perl, après l'ouverture du fichier comme si

open (FH, "<A.txt"); 

commentaires, idées, etc. seraient utiles.

Answer 1

Eh bien, j'analyse régulièrement de très gros fichiers journaux Apache quotidiens (600 Mo) avec Perl, et pour stocker les informations, j'utilise un hachage. Je passe également en revue environ 30 de ces fichiers, dans une instance de script, en utilisant le même hachage. Ce n'est pas un gros problème en supposant que vous avez assez de RAM.

Answer 2

Pour trier le fichier dans votre script, vous devrez tout charger dans la mémoire. Si vous faites cela, je ne suis pas sûr de savoir quel est l'avantage de le trier par rapport à un simple hachage?

Quelque chose comme ça fonctionnerait:

my %seen; 
open(A, "<A.txt") or die "Can't read A: $!"; 
while (<A>) { 
    $seen{$_}=1; 
} 
close A; 

open(B, "<B.txt") or die "Can't read B: $!"; 
while(<B>) { 
    delete $seen{$_}; 
} 
close B; 

print "Lines found in A, missing in B:\n"; 
join "\n", keys %seen; 

Answer 3

Puis-je vous demander pourquoi vous devez le faire en Perl natif? Si le coût de l'appel d'un appel système ou 3 n'est pas un problème (par exemple, vous le faites souvent et non pas dans une boucle serrée), pourquoi ne pas simplement faire:

my $cmd = "sort $file1 > $file1.sorted"; 
$cmd .= "; sort $file2 > $file2.sorted"; 
$cmd .= "; comm -23 $file1.sorted $file2.sorted |wc -l"; 
my $count = `$cmd`; 
$count =~ s/\s+//g; 
if ($count != 0) { 
    print "Stuff in A exists that aren't in B\n"; 
} 

S'il vous plaît noter que le paramètre comm peut être différent, selon sur ce que tu veux exactement.

Answer 4

test si A.txt est un sous-ensemble de B.txt

open FILE.B, "B.txt"; 
open FILE.A, "A.txt"; 

my %bFile; 

while(<FILE.B>) { 
    ($process, $id1, $id2) = split /,/; 
    $bFile{$process}{$id1}{$id2}++; 
} 

$missingRows = 0; 

while(<FILE.A>) { 
    $missingRows++ unless $bFile{$process}{$id1}{$id2}; 
    # If we've seen a given entry already don't add it 
    next if $missingRows; # One miss means they aren't all verified 
} 

$is_Atxt_Subset_Btxt = $missingRows?FALSE:TRUE; 

Cela vous donnera un test pour toutes les lignes A être en B à la lecture que dans tous B puis tester chaque membre du réseau lors de la lecture A.

Answer 5

Comme d'habitude, CPAN a une réponse pour cela. Soit Sort::External ou File::Sort semble que cela fonctionnerait.Je n'ai jamais eu l'occasion d'essayer non plus, alors je ne sais pas ce qui serait mieux pour vous.

Une autre possibilité consiste à utiliser AnyDBM_File pour créer un hachage sur disque pouvant dépasser la mémoire disponible. Sans l'essayer, je ne pourrais pas dire si l'utilisation d'un fichier DBM serait plus rapide ou plus lente que le tri, mais le code serait probablement plus simple.

Answer 6

Voici une autre façon de le faire. L'idée est de créer une structure de données flexible qui vous permet de répondre facilement à de nombreux types de questions avec grep.

use strict; 
use warnings; 

my ($fileA, $fileB) = @ARGV; 

# Load all lines: $h{LINE}{FILE_NAME} = TALLY 
my %h; 
$h{$_}{$ARGV} ++ while <>; 

# Do whatever you need. 
my @all_lines = keys %h; 
my @in_both = grep {  keys %{$h{$_}} == 2  } keys %h; 
my @in_A  = grep {  exists $h{$_}{$fileA}  } keys %h; 
my @only_in_A = grep { not exists $h{$_}{$fileB}  } @in_A; 
my @in_A_mult = grep {   $h{$_}{$fileA} > 1 } @in_A;