if I have a hash
my %foo = ( foo => 1, bar => 1 );
I want to check if any key of %foo is in a comparison array (and obviously keys %foo is just an array ). I keep thinking some weird syntax that does't exist like.
my @cmp0 = qw( foo baz );
my @cmp1 = qw( baz blargh );
if keys %foo in @cmp0 # returns true because key foo is in the array
if keys %foo in @cmp1 # returns false because no key in foo is an element of cmp1
What is the simplest way to do this?
List::MoreUtils has a function called any that uses a syntax similar to grep, but stops its internal loop the first time the criteria are met. The advantage to this behavior is that far fewer iterations will be required (assuming random distribution of intersections).
An additional advantage of any is code clarity: It is named for what it does. Perl Best Practices discourages using grep in Boolean context because the assumed use for grep is to return a list of elements that match. It works in Boolean context, but the intent of the code is less clear to a reader than any, which is designed specifically for Boolean usage.
It is true that any adds a dependency on List::MoreUtils. However, List::MoreUtils is one of those modules that is so ubiquitous, it is highly likely to already be installed.
Here's an example:
use List::MoreUtils qw( any );
my %foo = ( foo => 1, bar => 1 );
my @cmp0 = qw( foo baz );
my @cmp1 = qw( baz blargh );
print "\@cmp0 and %foo have an intersection.\n"
if any { exists $foo{$_} } @cmp0;
print "\@cmp1 and %foo have an intersection.\n"
if any { exists $foo{$_} } @cmp1;
Another option is the ~~ Smart Match Operator, which became available in Perl 5.10.0 and newer. It could be used like this:
my %foo = ( foo => 1, bar => 1 );
my @cmp0 = qw( foo baz );
my @cmp1 = qw( baz blargh );
print "\@cmp0 and %foo have an intersection.\n" if @cmp0 ~~ %foo;
print "\@cmp1 and %foo have an intersection.\n" if @cmp1 ~~ %foo;
With smartmatch, you eliminate the List::MoreUtils dependency in favor of a minimum Perl version dependency. It's up to you to decide whether the code is as clear as any.
List::MoreUtils::any doesn't require the full iteration, my performance benchmarks show that it is 10x slower than grep on my machine, even with XS. List::Util::first is a little faster, but still not as fast as grep.
grep would consume 10,000 iterations, any would consume 5,000. It might be an interesting discussion as a meditation over at PerlMonks, where more in-depth discussion is encouraged.
The tidiest way to write this is to use grep together with the exists operator.
This code
my %foo = ( foo => 1, bar => 1 );
my @cmp0 = qw( foo baz );
my @cmp1 = qw( baz blargh );
print "YES 0\n" if grep { exists $foo{$_} } @cmp0;
print "YES 1\n" if grep { exists $foo{$_} } @cmp1;
gives this output
YES 0
grep is a good idea, and probably the cleanest. You can however also use the logical OR assignment operator ||=:
my $found;
$found ||= exists $foo{$_} for @cmp1;
These are simple set operations.
use strictures;
use Set::Scalar qw();
⋮
my $foo = Set::Scalar->new(keys %foo);
$foo->intersection(Set::Scalar->new(@cmp0))->size; # 1
$foo->intersection(Set::Scalar->new(@cmp1))->size; # 0
There are - as usual - more ways to solve this. You could do it like this:
#!/usr/bin/perl
use strict ;
use warnings ;
my %hash = ( foo => 1 , bar => 1 ) ;
my %cmp = ( cmp0 => [ qw(foo baz) ] ,
cmp1 => [ qw(baz blargh) ] ) ;
my @hash_keys = keys %hash ;
foreach my $compare ( keys %cmp ) {
my %tmp ;
# Generate a temporary hash from comparison keys via hash slice
@tmp{@{$cmp{$compare}}} = undef ;
INNER:
foreach my $hash_key ( @hash_keys ) {
if( exists $tmp{$hash_key} ) {
printf "Key '%s' is part of '%s'.\n" , $hash_key , $compare ;
last INNER ;
}
}
}
This gives:
Key 'foo' is part of 'cmp0'.
keys %foois a list and very much not an array. An array is a Perl variable which can take the place of a list, but it can also do a lot of things an array can't do. See What is the difference between a list and an array?