Funzione defined() in Perl

Nel linguaggio di programmazione Perl ci sono built-in funzione di defined().

Spesso questa funzione viene utilizzata per distinguere il valore undef da qualsiasi altro valore. Ma ancora con l'aiuto di defined() è possibile sapere se la funzione è definita.

Controllo undef

Fondamentale l'introduzione della funzione defined() è il controllo del valore in undef.

Se trasferire la funzione defined() valore undef, la funzione restituisce false. La funzione restituirà true se il valore che ha trasmesso è quello che vuoi, ma non undef. Ecco un esempio di codice:

▶ Run
#!/usr/bin/perl

use Data::Dumper;

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

Il risultato del lavoro di questo codice:

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

Verifica che la funzione è definita

Spesso la funzione defined() viene utilizzato per distinguere undef da un altro valore. Ma oltre a questo, con l'aiuto di defined() è possibile sapere se la funzione è definita. Ecco un esempio di codice:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

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

Funzione check() non è definita, in modo che defined() restituirà false, Ed ecco la funzione Dumper ci sono nel pacchetto Data::Dumper e defined() restituirà la verità. Ecco cosa porterà questo programma sullo schermo:

$VAR1 = '';
$VAR1 = 1;

Argomenti

Nel caso in cui la funzione defined() non trasmessi gli argomenti, la funzione funziona con una variabile $_:

Se trasferire la funzione defined() più di un argomento, quello è un errore e l'esecuzione del programma sarà interrotta:

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

Il valore restituito

Il risultato del lavoro funzione defined() è sempre un valore booleano. Vero o falso.

L'uso di un array e хешом

Molto tempo fa la funzione defined() ha lavorato in modo particolare se dirle array o hash come argomento. Ma già in Perl 5.8 tale uso ha pubblicato un avviso, e a partire dal 5.22 tale uso è diventato generare un errore.

Ecco un esempio di codice in cui in defined() viene passato un array:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

my @arr;

print Dumper defined(@arr);

Il risultato del lavoro di questo codice in perl versione 5.8:

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

E il risultato del lavoro di questo stesso quando in perl 5.30:

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

E lo stesso codice, ma hash:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

my %h;

print Dumper defined(%h);

I risultati del lavoro in perl 5.8 e 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 documentazione ufficiale di

Ecco l'output del comando 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".

Temi correlati

Altri articoli