如何检查 Perl 中数组的所有元素是否相同？

Question

我有一个数组@test。检查数组的每个元素是否是同一个字符串的最佳方法是什么？

我知道我可以使用foreach 循环来做到这一点，但有没有更好的方法来做到这一点？我检查了地图功能，但我不确定这是否是我需要的。

Answer 1

如果字符串已知，则可以在标量上下文中使用grep：

if (@test == grep { $_ eq $string } @test) {
 # all equal
}

否则，使用哈希：

my %string = map { $_, 1 } @test;
if (keys %string == 1) {
 # all equal
}

或更短的版本：

if (keys %{{ map {$_, 1} @test }} == 1) {
 # all equal
}

注意：当在 Perl 中用作字符串时，undefined 值的行为类似于空字符串 ("")。因此，如果数组仅包含空字符串和undefs，则检查将返回 true。

这是一个考虑到这一点的解决方案：

my $is_equal = 0;
my $string   = $test[0]; # the first element

for my $i (0..$#test) {
    last unless defined $string == defined $test[$i];
    last if defined $test[$i] && $test[$i] ne $string;
    $is_equal = 1 if $i == $#test;
}

Answer 2

如果@test = (undef, '')，接受的帖子中的两种方法都会给你错误的答案。也就是说，它们声明一个未定义的值等于空字符串。

这可能是可以接受的。此外，即使早期发现不匹配，使用grep 也会遍历数组的所有元素，并且使用哈希会使数组元素使用的内存增加一倍以上。如果您有小型阵列，这些都不是问题。而且，grep 对于合理的列表大小可能足够快。

但是，这里有一个替代方法，1) 为 (undef, '') 和 (undef, 0) 返回 false，2) 不会增加程序的内存占用，3) 一旦发现不匹配就会短路：

#!/usr/bin/perl

use strict; use warnings;

# Returns true for an empty array as there exist
# no elements of an empty set that are different
# than each other (see
# http://en.wikipedia.org/wiki/Vacuous_truth)

sub all_the_same {
    my ($ref) = @_;
    return 1 unless @$ref;
    my $cmpv = \ $ref->[-1];
    for my $i (0 .. $#$ref - 1)  {
        my $this = \ $ref->[$i];
        return unless defined $$cmpv == defined $$this;
        return if defined $$this
            and ( $$cmpv ne $$this );
    }
    return 1;
}

但是，使用List::MoreUtils::first_index 可能会更快：

use List::MoreUtils qw( first_index );

sub all_the_same {
    my ($ref) = @_;
    my $first = \ $ref->[0];
    return -1 == first_index {
        (defined $$first != defined)
            or (defined and $_ ne $$first)
    } @$ref;
}

Answer 3

TIMTOWTDI，我最近读了很多Mark Jason Dominus。

use strict;
use warnings;

sub all_the_same {
    my $ref = shift;
    return 1 unless @$ref;
    my $cmp = $ref->[0];
    my $equal = defined $cmp ?
        sub { defined($_[0]) and $_[0] eq $cmp } :
        sub { not defined $_[0] };
    for my $v (@$ref){
        return 0 unless $equal->($v);
    }
    return 1;
}

my @tests = (
    [ qw(foo foo foo) ],
    [ '', '', ''],
    [ undef, undef, undef ],
    [ qw(foo foo bar) ],
    [ '', undef ],
    [ undef, '' ]
);

for my $i (0 .. $#tests){
    print "$i. ", all_the_same($tests[$i]) ? 'equal' : '', "\n";
}

Answer 4

您可以通过在哈希 (%seen) 中计数来检查数组 (@test) 中的元素重复了多少次。您可以检查哈希 (%seen) 中存在多少键 ($size)。如果存在超过 1 个键，则表明数组中的元素不相同。

sub all_the_same {
    my @test = @_;
    my %seen;
    foreach my $item (@test){
      $seen{$item}++
    }
    my $size = keys %seen;
    if ($size == 1){
        return 1;
    }
    else{
        return 0;
    }
}

Answer 5

我认为，我们可以使用 List::MoreUtils qw(uniq)

my @uniq_array = uniq @array;
my $array_length = @uniq_array;
$array_length == 1 ? return 1 : return 0;

Answer 6

我将List::Util::first 用于所有类似目的。

# try #0: $ok = !first { $_ ne $string } @test;
# try #1: $ok = !first { (defined $_ != defined $string) || !/\A\Q$string\E\z/ } @test;

# final solution
use List::Util 'first';
my $str = shift @test;
my $ok = !first { defined $$_ != defined $str || defined $str && $$_ ne $str } map \$_, @test;

我在这里使用map \$_, @test 来避免计算结果为假的值出现问题。

注意。正如 cjm 所指出的，使用 map 会破坏第一次短路的优势。所以我用他的first_index 解决方案向思南致敬。