Tôi đang cố gắng tìm ra cách kiểm tra sự tồn tại của một giá trị trong một mảng mà không lặp qua mảng đó.

Tôi đang đọc một tập tin cho một tham số. Tôi có một danh sách dài các tham số mà tôi không muốn xử lý. Tôi đặt các tham số không mong muốn này trong một mảng @badparams.

Tôi muốn đọc một tham số mới và nếu nó không tồn tại @badparams, hãy xử lý nó. Nếu nó tồn tại trong @badparams, đi đến đọc tiếp theo.

Đơn giản chỉ cần biến mảng thành hàm băm:

my %params = map { $_ => 1 } @badparams;

if(exists($params{$someparam})) { ... }

Bạn cũng có thể thêm nhiều thông số (duy nhất) vào danh sách:

$params{$newparam} = 1;

Và sau đó nhận được một danh sách các thông số (duy nhất) trở lại:

@badparams = keys %params;

Mục đích chung tốt nhất - Đặc biệt là các mảng ngắn (1000 mục trở xuống) và các lập trình viên không chắc chắn về những gì tối ưu hóa phù hợp nhất với nhu cầu của họ.

# $value can be any regex. be safe
if ( grep( /^$value$/, @array ) ) {
  print "found it";
}

Nó đã được đề cập rằng grep đi qua tất cả các giá trị ngay cả khi giá trị đầu tiên trong mảng khớp. Điều này là đúng, tuy nhiên grep vẫn cực kỳ nhanh đối với hầu hết các trường hợp . Nếu bạn đang nói về mảng ngắn (dưới 1000 mục) thì hầu hết các thuật toán sẽ khá nhanh. Nếu bạn đang nói về mảng rất dài (1.000.000 mục) thì grep có thể chấp nhận nhanh chóng bất kể mục đó là mục đầu tiên hay phần giữa hoặc phần cuối trong mảng.

Các trường hợp tối ưu hóa cho các mảng dài hơn:

Nếu mảng của bạn được sắp xếp , sử dụng "tìm kiếm nhị phân".

Nếu cùng một mảng được tìm kiếm nhiều lần, hãy sao chép nó vào hàm băm trước rồi kiểm tra hàm băm. Nếu bộ nhớ là một mối quan tâm, sau đó di chuyển từng mục từ mảng vào hàm băm. Bộ nhớ hiệu quả hơn nhưng phá hủy mảng ban đầu.

Nếu các giá trị tương tự được tìm kiếm lặp đi lặp lại trong mảng, lười biếng xây dựng bộ đệm. (vì mỗi mục được tìm kiếm, trước tiên hãy kiểm tra xem kết quả tìm kiếm có được lưu trong hàm băm không. Nếu kết quả tìm kiếm không được tìm thấy trong hàm băm, sau đó tìm kiếm mảng và đưa kết quả vào hàm băm bền tìm nó trong hàm băm và bỏ qua tìm kiếm).

Lưu ý: những tối ưu hóa này sẽ chỉ nhanh hơn khi xử lý các mảng dài. Đừng tối ưu hóa quá mức.

Bạn có thể sử dụng tính năng smartmatch trong Perl 5.10 như sau:

Đối với tra cứu giá trị theo nghĩa đen, làm dưới đây sẽ thực hiện các mẹo.

if ( "value" ~~ @array ) 

Đối với tra cứu vô hướng, làm dưới đây sẽ làm việc như trên.

if ($val ~~ @array)

Đối với mảng nội tuyến làm dưới đây, sẽ làm việc như trên.

if ( $var ~~ ['bar', 'value', 'foo'] ) 

Trong Perl 5.18 smartmatch được gắn cờ là thử nghiệm, do đó bạn cần tắt các cảnh báo bằng cách bật pragma thử nghiệm bằng cách thêm bên dưới vào tập lệnh / mô-đun của bạn:

use experimental 'smartmatch';

Ngoài ra, nếu bạn muốn tránh sử dụng smartmatch - thì như Aaron đã nói hãy sử dụng:

if ( grep( /^$value$/, @array ) ) {
  #TODO:
}

Bài đăng trên blog này thảo luận các câu trả lời tốt nhất cho câu hỏi này.

Tóm lại, nếu bạn có thể cài đặt các mô-đun CPAN thì các giải pháp dễ đọc nhất là:

any(@ingredients) eq 'flour';

hoặc là

@ingredients->contains('flour');

Tuy nhiên, một thành ngữ phổ biến hơn là:

any { $_ eq 'flour' } @ingredients

Nhưng xin vui lòng không sử dụng first()chức năng! Nó hoàn toàn không thể hiện ý định của mã của bạn. Không sử dụng ~~toán tử "Kết hợp thông minh": nó bị hỏng. Và không sử dụng grep()cũng không phải là giải pháp với hàm băm: chúng lặp đi lặp lại trong toàn bộ danh sách.

any() sẽ dừng lại ngay khi nó tìm thấy giá trị của bạn.

Kiểm tra bài viết trên blog để biết thêm chi tiết.

Phương pháp 1: grep (có thể cẩn thận trong khi giá trị được dự kiến ​​là regex).

Cố gắng tránh sử dụng grep, nếu nhìn vào tài nguyên.

if ( grep( /^$value$/, @badparams ) ) {
  print "found";
}

Phương pháp 2: Tìm kiếm tuyến tính

for (@badparams) {
    if ($_ eq $value) {
       print "found";
       last;
    }
}

Phương pháp 3: Sử dụng hàm băm

my %hash = map {$_ => 1} @badparams;
print "found" if (exists $hash{$value});

Phương pháp 4: smartmatch

(được thêm vào trong Perl 5.10, được đánh dấu là thử nghiệm trong Perl 5.18).

use experimental 'smartmatch';  # for perl 5.18
print "found" if ($value ~~ @badparams);

Phương pháp 5: Sử dụng mô-đun List::MoreUtils

use List::MoreUtils qw(any);
@badparams = (1,2,3);
$value = 1;
print "found" if any {$_ == $value} @badparams;

Điểm chuẩn của @ eakssjo bị hỏng - các biện pháp tạo băm trong vòng lặp so với tạo biểu thức chính quy trong vòng lặp. Đã sửa phiên bản (cộng với tôi đã thêm List::Util::firstvà List::MoreUtils::any):

use List::Util qw(first);
use List::MoreUtils qw(any);
use Benchmark;

my @list = ( 1..10_000 );
my $hit = 5_000;
my $hit_regex = qr/^$hit$/; # precompute regex
my %params;
$params{$_} = 1 for @list;  # precompute hash
timethese(
    100_000, {
        'any' => sub {
            die unless ( any { $hit_regex } @list );
        },
        'first' => sub {
            die unless ( first { $hit_regex } @list );
        },
        'grep' => sub {
            die unless ( grep { $hit_regex } @list );
        },
        'hash' => sub {
            die unless ( $params{$hit} );
        },
    });

Và kết quả (đó là cho 100_000 lần lặp, gấp mười lần so với câu trả lời của @ eakssjo):

Benchmark: timing 100000 iterations of any, first, grep, hash...
       any:  0 wallclock secs ( 0.67 usr +  0.00 sys =  0.67 CPU) @ 149253.73/s (n=100000)
     first:  1 wallclock secs ( 0.63 usr +  0.01 sys =  0.64 CPU) @ 156250.00/s (n=100000)
      grep: 42 wallclock secs (41.95 usr +  0.08 sys = 42.03 CPU) @ 2379.25/s (n=100000)
      hash:  0 wallclock secs ( 0.01 usr +  0.00 sys =  0.01 CPU) @ 10000000.00/s (n=100000)
            (warning: too few iterations for a reliable count)

Mặc dù nó thuận tiện để sử dụng, nhưng có vẻ như giải pháp convert-to-hash tốn khá nhiều hiệu năng, đây là một vấn đề đối với tôi.

#!/usr/bin/perl
use Benchmark;
my @list;
for (1..10_000) {
    push @list, $_;
}

timethese(10000, {
  'grep'    => sub {
            if ( grep(/^5000$/o, @list) ) {
                # code
            }
        },
  'hash'    => sub {
            my %params = map { $_ => 1 } @list;
            if ( exists($params{5000}) ) {
                # code
            }
        },
});

Đầu ra của bài kiểm tra điểm chuẩn:

Benchmark: timing 10000 iterations of grep, hash...
          grep:  8 wallclock secs ( 7.95 usr +  0.00 sys =  7.95 CPU) @ 1257.86/s (n=10000)
          hash: 50 wallclock secs (49.68 usr +  0.01 sys = 49.69 CPU) @ 201.25/s (n=10000)

@files là một mảng hiện có

my @new_values =  grep(/^2[\d].[\d][A-za-z]?/,@files);

print join("\n", @new_values);

print "\n";

/ ^ 2 [\ dTHER.[\d[[A-za-zTHER?/ = vaues bắt đầu từ 2 ở đây, bạn có thể đặt bất kỳ biểu thức chính quy nào

Bạn chắc chắn muốn một hàm băm ở đây. Đặt các tham số xấu làm khóa trong hàm băm, sau đó quyết định xem một tham số cụ thể có tồn tại trong hàm băm không.

our %bad_params = map { $_ => 1 } qw(badparam1 badparam2 badparam3)

if ($bad_params{$new_param}) {
  print "That is a bad parameter\n";
}

Nếu bạn thực sự thích làm việc đó với một mảng, hãy nhìn vào List::UtilhoặcList::MoreUtils

Có hai cách bạn có thể làm điều này. Bạn có thể sử dụng ném các giá trị vào hàm băm cho bảng tra cứu, như được đề xuất bởi các bài đăng khác. (Tôi sẽ chỉ thêm một thành ngữ.)

my %bad_param_lookup;
@bad_param_lookup{ @bad_params } = ( 1 ) x @bad_params;

Nhưng nếu đó là dữ liệu của hầu hết các ký tự từ và không có quá nhiều meta, bạn có thể chuyển nó thành một thay thế regex:

use English qw<$LIST_SEPARATOR>;

my $regex_str = do { 
    local $LIST_SEPARATOR = '|';
    "(?:@bad_params)";
 };

 # $front_delim and $back_delim being any characters that come before and after. 
 my $regex = qr/$front_delim$regex_str$back_delim/;

Giải pháp này sẽ phải được điều chỉnh cho các loại "giá trị xấu" mà bạn đang tìm kiếm. Và một lần nữa, nó có thể là hoàn toàn không phù hợp cho một số loại dây, vì vậy caveat emptor .

my @badparams = (1,2,5,7,'a','zzz');

my $badparams = join('|',@badparams);   # '|' or any other character not present in params

foreach my $par (4,5,6,7,'a','z','zzz')
{
    if ($badparams =~ /\b$par\b/)
    {
        print "$par is present\n";
    }
    else
    {
        print "$par is not present\n";
    }
}

Bạn có thể muốn kiểm tra tính nhất quán của không gian hàng đầu số