Re^3: removing same entries between 2 files

Ouch! Not sure what that was supposed to mean either, I was in a little of a rush and just typed the program into the input form; my apologies. Here is a more 'refined' version of what I meant:

#!/usr/bin/perl

use strict;
use warnings;

open FILE, 'file.1.dat';
my $hist = {map{ chomp; $_ => 1 } @{[<FILE>]}};
close FILE;

open FILE, 'file.2.dat';
while ( my $line = <FILE> ) {
     chomp( $line );
     my ( $file, $account, @other ) = split( /\t/, $line );
     next if ( exists( $hist->{$account} ) );
     print "$account:\t$file\n";
}
close FILE;

exit;
__END__
[download]

My apologies for the confusion again, and Good Luck!!

---hA||ta----
print map{$_.' '}grep{/\w+/}@{[reverse(qw{Perl Code})]} or die while ( 'trying' );

Comment on Re^3: removing same entries between 2 files Select or Download Code

Replies are listed 'Best First'.
Re^4: removing same entries between 2 files by sbp (Initiate) on Nov 30, 2005 at 03:12 UTC
Thank you both for your help. Can you explain the following lines of code? `my $hist = {map{ chomp; $_ => 1 } @{[<FILE>]}}; by wazzuteke my %lookup = map {chomp; $_ => undef} <$accnts>; by wfsp` [download] I understand that in both of these lines of code, you're loading the file into a look up table...but i'm not very clear as to what `map{chomp; $_ => 1} or map {chomp; $_ => undef}` is doing specifically as i'm unfamiliar with perl syntax. Thank you!	[reply] [d/l] [select]
Re^5: removing same entries between 2 files by BrowserUk (Patriarch) on Nov 30, 2005 at 03:45 UTC
They both do essentially the same thing--build a hash from the lines in a file. However, there are a couple of differences, and an anomaly. The maps do the same thing--build the key/value pairs that get assigned to the hash, using each line from the file as the key (with the trailing newline removed by chomp), and setting the value to a constant. The first sets all the values to 1, the latter sets them to undef. For lookup purposes, where you are not going to use the value for anything, the latter is a better choice as it saves a little space. No reason to store a bunch of '1's that you will never use. The first example builds an anonymous hash and assigns a reference to it, to the scalar `$hist`. Nothing wrong in that, except that it forces you to indirect through the reference to get at it's elements. Ie. `$hist->{key} = 'value';` which is slightly clumsier that a simple hash, as used in the second example: `$hash{key} = 'value';`. Not much in it, but I find the former easier unless there is a good reason for using a reference. Finally, the anomaly. In the first example, the lines are read into an anonymous array first: `[<FILE>]`. This anonymous array is then dereferenced to produce a list: `map{...} @{ [<FILE>] }`. These two steps are unnecessary as, using readline (the `<FILE>` operator) directly as in the second example achieves exactly the same thing, supplying a list to map, without going through the intermediate steps of creating and dereferencing an anonymous array and thereby temporarily consuming extra space. All in all, the second version is preferable to the first. Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error. Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal? "Science is about questioning the status quo. Questioning authority". In the absence of evidence, opinion is indistinguishable from prejudice.	[reply] [d/l] [select]