J'essaie de trouver un moyen de vérifier l'existence d'une valeur dans un tableau sans parcourir le tableau.

Je lis un fichier pour un paramètre. J'ai une longue liste de paramètres que je ne veux pas traiter. J'ai placé ces paramètres indésirables dans un tableau @badparams.

Je veux lire un nouveau paramètre et s'il n'existe pas @badparams, le traiter. S'il existe @badparams, passez à la lecture suivante.

Transformez simplement le tableau en hachage:

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

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

Vous pouvez également ajouter d'autres paramètres (uniques) à la liste:

$params{$newparam} = 1;

Et plus tard, récupérez une liste de paramètres (uniques):

@badparams = keys %params;

Meilleur usage général - Tableaux particulièrement courts (1000 éléments ou moins) et codeurs qui ne savent pas quelles optimisations répondent le mieux à leurs besoins.

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

Il a été mentionné que grep passe par toutes les valeurs même si la première valeur du tableau correspond. C'est vrai, cependant grep est toujours extrêmement rapide dans la plupart des cas . Si vous parlez de tableaux courts (moins de 1000 éléments), la plupart des algorithmes seront de toute façon assez rapides. Si vous parlez de tableaux très longs (1 000 000 éléments), grep est suffisamment rapide, que l'élément soit le premier, le milieu ou le dernier du tableau.

Cas d'optimisation pour les baies plus longues:

Si votre tableau est trié , utilisez une "recherche binaire".

Si le même tableau est recherché plusieurs fois à plusieurs reprises, copiez-le d'abord dans un hachage, puis vérifiez le hachage. Si la mémoire est un problème, déplacez chaque élément du tableau dans le hachage. Plus efficace en mémoire mais détruit la baie d'origine.

Si les mêmes valeurs sont recherchées à plusieurs reprises dans le tableau, créez paresseusement un cache. (comme chaque élément est recherché, vérifiez d'abord si le résultat de la recherche a été stocké dans un hachage persistant. si le résultat de la recherche n'est pas trouvé dans le hachage, puis recherchez dans le tableau et placez le résultat dans le hachage persistant de sorte que la prochaine fois nous le trouver dans le hachage et sauter la recherche).

Remarque: ces optimisations ne seront plus rapides que pour les tableaux longs. N'optimisez pas trop.

Vous pouvez utiliser la fonction smartmatch dans Perl 5.10 comme suit:

Pour la recherche de valeur littérale, faire ci-dessous fera l'affaire.

if ( "value" ~~ @array ) 

Pour la recherche scalaire, faire ci-dessous fonctionnera comme ci-dessus.

if ($val ~~ @array)

Pour le tableau en ligne faisant ci-dessous, fonctionnera comme ci-dessus.

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

Dans Perl 5.18, smartmatch est marqué comme expérimental, vous devez donc désactiver les avertissements en activant le pragma expérimental en ajoutant ci-dessous à votre script / module:

use experimental 'smartmatch';

Alternativement, si vous voulez éviter l'utilisation de smartmatch - alors comme Aaron l'a dit, utilisez:

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

Ce billet de blog discute des meilleures réponses à cette question.

En résumé, si vous pouvez installer des modules CPAN, les solutions les plus lisibles sont:

any(@ingredients) eq 'flour';

ou

@ingredients->contains('flour');

Cependant, un idiome plus courant est:

any { $_ eq 'flour' } @ingredients

Mais n'utilisez pas la first()fonction! Il n'exprime pas du tout l'intention de votre code. N'utilisez pas l' ~~opérateur "Smart match": il est cassé. Et n'utilisez grep()ni la solution avec un hachage: ils parcourent toute la liste.

any() s'arrêtera dès qu'il trouvera votre valeur.

Consultez le billet de blog pour plus de détails.

Méthode 1: grep (peut faire attention alors que la valeur devrait être une expression régulière).

Essayez d'éviter d'utiliser grep, si vous regardez les ressources.

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

Méthode 2: recherche linéaire

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

Méthode 3: utilisez un hachage

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

Méthode 4: smartmatch

(ajouté en Perl 5.10, marqué est expérimental en Perl 5.18).

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

Méthode 5: utilisez le module List::MoreUtils

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

Le benchmark de @ eakssjo est cassé - mesure la création de hachages en boucle vs la création de regex en boucle. Version fixe (plus j'ai ajouté List::Util::firstet 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} );
        },
    });

Et résultat (c'est pour 100_000 itérations, dix fois plus que dans la réponse de @ 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ême si elle est pratique à utiliser, il semble que la solution de conversion en hachage coûte beaucoup de performances, ce qui était un problème pour moi.

#!/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
            }
        },
});

Sortie du test de référence:

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 est un tableau existant

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

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

print "\n";

/^2[\d diplomate .\\d diplomatiqueA-za-z

Vous voulez certainement un hachage ici. Placez les mauvais paramètres comme clés dans le hachage, puis décidez si un paramètre particulier existe dans le hachage.

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

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

Si vous êtes vraiment intéressé à le faire avec un tableau, regardez List::UtilouList::MoreUtils

Vous pouvez procéder de deux manières. Vous pouvez utiliser le jeter les valeurs dans un hachage pour une table de recherche, comme suggéré par les autres articles. (Je vais ajouter juste un autre idiome.)

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

Mais s'il s'agit principalement de données de mots et pas trop de méta, vous pouvez les vider dans une alternance d'expressions régulières:

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/;

Cette solution devrait être réglée pour les types de «mauvaises valeurs» que vous recherchez. Et encore une fois, cela pourrait être totalement inapproprié pour certains types de cordes, donc avertissez 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";
    }
}

Vous pouvez vérifier la cohérence des espaces de début numériques