Fonction defined() en Perl

Dans le langage de programmation Perl, il ya une fonction intégrée defined().

Le plus souvent cette fonction est utilisée pour différencier les la valeur de undef de n'importe quelle autre valeur. Mais encore avec l'aide de defined() , vous pouvez savoir si la fonction est définie.

La vérification des undef

La principale utilité de la fonction defined() est une vérification de la valeur de la undef.

Si vous passez de la fonction defined() valeur undef, alors la fonction retourne false. La fonction retourne vrai si la valeur qui lui est transmise est ce que vous voulez, mais ne undef. Voici un exemple de code:

▶ Run
#!/usr/bin/perl

use Data::Dumper;

print Dumper defined(8);
print Dumper defined(0);
print Dumper defined('');
print Dumper defined(undef);

Le résultat de ce code:

$VAR1 = 1;
$VAR1 = 1;
$VAR1 = 1;
$VAR1 = '';

Vérifier que la fonction est définie

Le plus souvent la fonction defined() est utilisé pour distinguer undef de toute autre valeur. Mais outre cela, avec l'aide defined() , vous pouvez savoir si la fonction est définie. Voici un exemple de code:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

print Dumper defined(&check);
print Dumper defined(&Data::Dumper::Dumper);

La fonction check() n'est pas définie, de sorte que defined() retourne false, Et voici la fonction Dumper il ya un paquet de Data::Dumper et defined() retourne vrai. Voici ce qu'affiche ce programme sur l'écran:

$VAR1 = '';
$VAR1 = 1;

Les arguments

Dans ce cas, si la fonction defined() n'est pas transmises à aucun des arguments, fonctionne avec une variable $_:

Si vous passez de la fonction defined() plus de un argument, ce serait une erreur et l'exécution du programme sera arrêté:

Too many arguments for defined operator at script.pl line 3, near "3)"
Execution of script.pl aborted due to compilation errors.

La valeur de retour

Le résultat du travail de la fonction defined() — c'est toujours une valeur booléenne. La vérité ou un mensonge.

Utilisation avec un tableau et хешом

Très longtemps la fonction defined() a travaillé de façon particulière si lui transmettre un tableau ou un hachage en tant qu'argument. Mais déjà en Perl 5.8 cette utilisation a publié un avertissement, et à partir du 5.22 une telle utilisation est de générer une erreur.

Voici un exemple de code dans lequel defined() un tableau est passé:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

my @arr;

print Dumper defined(@arr);

Le résultat de ce code dans la version de perl 5.8:

defined(@array) is deprecated at script.pl line 10.
    (Maybe you should just omit the defined()?)
    $VAR1 = '';

Et le résultat de ce même lorsque perl 5.30:

Can't use 'defined(@array)' (Maybe you should just omit the defined()?) at script.pl line 10.

Et le même code, mais à propos de hachage:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

my %h;

print Dumper defined(%h);

Les résultats des travaux de perl 5.8 et 5.30:

defined(%hash) is deprecated at script.pl line 10.
    (Maybe you should just omit the defined()?)
    $VAR1 = '';
Can't use 'defined(%hash)' (Maybe you should just omit the defined()?) at script.pl line 10.

La documentation officielle

Voici la sortie de la commande perldoc -f defined:

       defined EXPR
       defined Returns a Boolean value telling whether EXPR has a value other
               than the undefined value "undef".  If EXPR is not present, $_
               is checked.

               Many operations return "undef" to indicate failure, end of
               file, system error, uninitialized variable, and other
               exceptional conditions.  This function allows you to
               distinguish "undef" from other values.  (A simple Boolean test
               will not distinguish among "undef", zero, the empty string, and
               "0", which are all equally false.)  Note that since "undef" is
               a valid scalar, its presence doesn't necessarily indicate an
               exceptional condition: "pop" returns "undef" when its argument
               is an empty array, or when the element to return happens to be
               "undef".

               You may also use "defined(&func)" to check whether subroutine
               &func has ever been defined.  The return value is unaffected by
               any forward declarations of &func.  A subroutine that is not
               defined may still be callable: its package may have an
               "AUTOLOAD" method that makes it spring into existence the first
               time that it is called; see perlsub.

               Use of "defined" on aggregates (hashes and arrays) is
               deprecated.  It used to report whether memory for that
               aggregate had ever been allocated.  This behavior may disappear
               in future versions of Perl.  You should instead use a simple
               test for size:

                   if (@an_array) { print "has array elements\n" }
                   if (%a_hash)   { print "has hash members\n"   }

               When used on a hash element, it tells you whether the value is
               defined, not whether the key exists in the hash.  Use "exists"
               for the latter purpose.

               Examples:

                   print if defined $switch{D};
                   print "$val\n" while defined($val = pop(@ary));
                   die "Can't readlink $sym: $!"
                       unless defined($value = readlink $sym);
                   sub foo { defined &$bar ? &$bar(@_) : die "No bar"; }
                   $debugging = 0 unless defined $debugging;

               Note:  Many folks tend to overuse "defined" and are then
               surprised to discover that the number 0 and "" (the zero-length
               string) are, in fact, defined values.  For example, if you say

                   "ab" =~ /a(.*)b/;

               The pattern match succeeds and $1 is defined, although it
               matched "nothing".  It didn't really fail to match anything.
               Rather, it matched something that happened to be zero
               characters long.  This is all very above-board and honest.
               When a function returns an undefined value, it's an admission
               that it couldn't give you an honest answer.  So you should use
               "defined" only when questioning the integrity of what you're
               trying to do.  At other times, a simple comparison to 0 or ""
               is what you want.

               See also "undef", "exists", "ref".

Thèmes connexes

Autres articles