Funktion defined() in Perl

In der Programmiersprache Perl gibt es die eingebaute Funktion defined().

Meistens wird diese Funktion verwendet, um zu unterscheiden der Wert undef von jedem anderen Wert. Aber noch mit Hilfe von defined() können Sie wissen bestimmt ob die Funktion.

Überprüfung auf undef

Das grundlegende примение Funktionen defined() ist die überprüfung der Werte auf undef.

Wenn diese Funktion defined() Wert undef, gibt die Funktion zurück, ist eine Lüge. Funktion gibt die Wahrheit in diesem Fall, wenn der Wert, der Ihr übergeben wird ist alles, aber nicht undef. Hier ist der Beispielcode:

▶ Run
#!/usr/bin/perl

use Data::Dumper;

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

Das Ergebnis dieses Codes:

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

Die überprüfung auf die Tatsache, dass die Funktion definiert ist

Am häufigsten Funktion defined() verwendet, um zu unterscheiden undef von anderen Werte. Aber darüber hinaus mit Hilfe defined() können Sie wissen bestimmt ob die Funktion. Hier ist der Beispielcode:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

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

Funktion check() nicht definiert, so dass defined() wieder eine Lüge, Aber die Funktion Dumper es gibt im Paket Data::Dumper und defined() bringt die Wahrheit. Das ist, was dieses Programm zeigt auf dem Bildschirm:

$VAR1 = '';
$VAR1 = 1;

Argumente

Wenn die Funktion defined() nicht übertragen, keine Argumente, wird die Funktion arbeitet mit einer Variablen $_:

Wenn an die Funktion übergeben defined() mehr als ein argument, dann wird der Fehler und die Ausführung des Programms wird gestoppt:

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

Der Rückgabewert

Das Ergebnis der Arbeit der Funktion defined() — es ist immer ein boolescher Wert. Die Wahrheit oder die Lüge.

Verwendung mit einem array und хешом

Sehr lange Funktion defined() arbeitete in besonderer Weise, wenn Sie übergeben ein array oder ein Hash als argument. Aber schon in Perl 5.8 ist die Verwendung von gab eine Warnung und ab 5.22 ist diese Nutzung wurde einen Fehler erzeugen.

Hier ist ein Beispiel Code, der in defined() übergeben wird ein array:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

my @arr;

print Dumper defined(@arr);

Das Ergebnis dieses Codes in der perl-Version 5.8:

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

Und das Ergebnis dieser Arbeit, wenn in perl 5.30:

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

Und der gleiche Code, sondern über Hash:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

my %h;

print Dumper defined(%h);

Die Ergebnisse der Arbeit auf perl 5.8 und 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.

Die offizielle Dokumentation

Hier ist die Ausgabe des Befehls 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".

Verwandte Themen

Andere Artikel