Fungsi defined() di Perl

Dalam bahasa pemrograman Perl memiliki fungsi built-in defined().

Paling sering fitur ini digunakan untuk membedakan nilai undef dari nilai lain. Tetapi bahkan dengan bantuan defined() , anda dapat mengetahui apakah anda telah menetapkan fungsi.

Cek undef

Utama menerapkan fungsi defined() adalah memeriksa nilai undef.

Jika fungsi transfer defined() nilai undef, fungsi akan mengembalikan false. Fungsi akan mengembalikan 'true' jika nilai yang ditransfer adalah apa-apa tapi undef. Berikut adalah contoh kode:

▶ Run
#!/usr/bin/perl

use Data::Dumper;

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

Hasil dari kode ini:

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

Periksa bahwa fungsi yang didefinisikan

Paling sering, fungsi defined() ini digunakan dalam rangka untuk membedakan undef dari nilai lain. Tetapi selain menggunakan defined() anda dapat mengetahui apakah anda telah menetapkan fungsi. Berikut adalah contoh kode:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

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

Fungsi check() tidak didefinisikan, sehingga defined() returns false, Tetapi fungsi Dumper bundel Data::Dumper dan defined() kembali 'benar'. Itulah program ini menampilkan pada layar:

$VAR1 = '';
$VAR1 = 1;

Argumen

Jika fungsi defined() tidak diberikan tidak ada argumen, fungsi bekerja dengan default variabel $_:

Jika fungsi transfer defined() lebih dari satu argumen, itu akan menjadi sebuah kesalahan dan eksekusi program akan dihentikan:

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

Nilai kembali

Hasil dari fungsi defined() adalah selalu sebuah nilai Boolean. Benar atau palsu.

Penggunaan dengan array dan Hesham

Sangat panjang fungsi defined() bekerja dengan cara yang khusus jika anda katakan padanya array atau hash sebagai argumen. Tapi di Perl 5.8 ini menggunakan mengeluarkan peringatan, dan sejak 5.22 penggunaan ini mulai gagal.

Berikut adalah contoh kode yang di defined() adalah melewati sebuah array:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

my @arr;

print Dumper defined(@arr);

Hasil dari kode ini dalam versi perl 5.8:

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

Hasil ini ketika 5.30 perl:

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

Dan kode yang sama, tapi tentang hash:

▶ Run
#!/usr/bin/perl

use strict;
use warnings;

use Data::Dumper;

my %h;

print Dumper defined(%h);

Hasil pekerjaan pada perl 5.8 dan 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.

Dokumentasi resmi

Berikut ini adalah output dari perintah 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".

Topik terkait

Artikel lainnya