#/usr/bin/perl
use strict;
use warnings;

@ARGV == 2 or die "Must specify 2 files!\n";
my $afile = shift;
my $bfile = shift;

my $ahash = make_hash($afile);
my $bhash = make_hash($bfile);

sub make_hash {
  my $file = shift;
  my %hash = ();
  open IN, "<$file" or die "Can't open '$file': $!\n";
  while (<IN>) {
    chomp;
    my ($key,$val) = split(/,/,$_);
    $hash{$key} = $val;
  }
  return \%hash;
}

print "In A hash but not B hash:\n",
map {"$_\n"} grep {not exists $bhash->{$_}} keys %$ahash;

print "In B hash but not A hash:\n",
map {"$_\n"} grep {not exists $ahash->{$_}} keys %$bhash;

print "In A hash and B hash but different:\n",
map {"$_\n"} grep {exists $bhash->{$_} and $ahash->{$_} ne $bhash->{$_
+}} keys %$ahash;
[download]

Thanks thelenm I like your answer. I did not think to use hashes.

But I see a problem, the files are large, about 500000 lines, each line is up to 1275 characters (avg about 250). That's about 500000 x 250 x 2 = 238 Mbytes of data in the hashes. The data will grow in the future. I think that will be rather stressful for the machine it's running on:) I think I'll try sorting the files beforehand, and keep only two lines in memory. Something like:

#code fragment leaving out parseing, reporting, use strict etc.

my ($leftkey,$leftvalue) = split_line(scalar <LEFTFILE>);
my ($rightkey,$rightvalue) = split_line(scalar <RIGHTFILE>);

# work through both files sequentially matching advances by key
while(defined($leftkey) and defined($rightkey))
{
    my $compare = $leftkey cmp $rightkey;
    if($compare == 0)
    {
        if ($leftvalue ne $rightvalue)
        {
            value_diff($leftkey, $leftvalue, $rightkey, $rightvalue);
        }
        ($leftkey,$leftvalue) = split_line(scalar <LEFTFILE>);
        ($rightkey,$rightvalue) = split_line(scalar <RIGHTFILE>);
        next;
    }
    elsif($compare > 0)
    {
        missing_left($rightkey,$rightvalue);
        ($rightkey,$rightvalue) = split_line(scalar <RIGHTFILE>);
        next;
    }
    else
    {
        missing_right($leftkey,$leftvalue);
        ($leftkey,$leftvalue) = split_line(scalar <LEFTFILE>);
        next;
    }
}
# are there missing items at end of the files?
while(defined($leftkey))
{
    missing_right($leftkey,$leftvalue);
    ($leftkey,$leftvalue) = split_line(scalar <LEFTFILE>);
}
while(defined($rightkey))
{
    missing_left($rightkey,$rightvalue);
    ($rightkey,$rightvalue) = split_line(scalar <RIGHTFILE>);
}
[download]

It probably doesn't do exactly what you want in your particular case, but it does tend to be very handy for a lot of things...

Here are some sample usages, given your left and right files as input:

# intersection (-i) of key fields:
# (default delimiter is \s+, so use "-d ," here)

$ cmpcol -i -d , left right
1
4
5

# print those records with the combined line
# content from both files:

$ cmpcol -i -d , -lb left right
1,a:<>:1,a
4,f:<>:4,g
5,h:<>:5,h

# keys only in "left" file, which is "#1" on the
# command line (-x1), showing full line (-l1):

$ cmpcol -x1 -l1 -d ,  left right
2,b

# lines with identical content (don't use
# the comma delimiter in this case):

$ cmpcol -i  left right
1,a
5,h

# all lines that are not identical (this
# always shows which file contained each line):

$ cmpcol -x left right
2,b <1
3,c <2
4,f <1
4,g <2

# and so on.  I think the "usage" message is
# the best part (at least I hope so):

$ cmpcol

Usage: cmpcol {-i|-u|-us|-x|-x1|-x2} [options] file1[:col#] file2[:col
+#]

 Comparison modes:
  -i        : produce intersection of file1[:col#] and file2[:col#]
  -u(s)     : produce union (and identify sources)
  -x        : produce exclusive-or, identifying sources
  -x1 (-x2) : produce items unique to file1 (or file2)

 Options:
  -l{1,2,b} : print whole lines from file1,file2 or both (default: pri
+nt column)
  -g(v) ptn : grep (-v) -- only compare lines that (don't) contain /pt
+n/
  -c cchar  : ignore material following cchar
  -d delim  : use /delim/ as column separator (default is white-space)
              use "-d tab" for tab-delimited, "-d dot" for period-deli
+mited

 file1 or file2 may be 'stdin'
 default ':col#' for comparison is first column from each file, which 
+is ':1'
[download]