Wie kann ich in Perl genau prüfen, ob eine $ -Variable definiert ist und eine Zeichenfolge ungleich Null enthält?

Ich verwende derzeit das folgende Perl, um zu überprüfen, ob eine Variable definiert ist und Text enthält. Ich muss definedzuerst prüfen , um eine Warnung "Nicht initialisierter Wert" zu vermeiden:

if (defined $name && length $name > 0) {
    # do something with $name
}

Gibt es eine bessere (vermutlich prägnantere) Möglichkeit, dies zu schreiben?

Sie sehen häufig die Überprüfung auf Definiertheit, damit Sie sich nicht mit der Warnung für die Verwendung eines undef-Werts befassen müssen (und in Perl 5.10 wird die fehlerhafte Variable angezeigt):

 Use of uninitialized value $name in ...

Um diese Warnung zu umgehen, kommen die Leute auf alle Arten von Code, und dieser Code scheint eher ein wichtiger Teil der Lösung zu sein als der Kaugummi und das Klebeband, die er ist. Manchmal ist es besser zu zeigen, was Sie tun, indem Sie die Warnung, die Sie vermeiden möchten, explizit deaktivieren:

 {
 no warnings 'uninitialized';

 if( length $name ) {
      ...
      }
 }

In anderen Fällen verwenden Sie anstelle der Daten einen Nullwert. Mit dem definierten oder Operator von Perl 5.10 können Sie lengthanstelle der Variablen, die die Warnung auslöst , eine explizite leere Zeichenfolge (definiert und Länge von Null) zurückgeben:

 use 5.010;

 if( length( $name // '' ) ) {
      ...
      }

In Perl 5.12 ist dies etwas einfacher, da lengthbei einem undefinierten Wert auch undefiniert zurückgegeben wird . Das mag ein bisschen albern erscheinen, aber das freut den Mathematiker, den ich vielleicht sein wollte. Das gibt keine Warnung aus, weshalb diese Frage existiert.

use 5.012;
use warnings;

my $name;

if( length $name ) { # no warning
    ...
    }

Wie mobrule angibt, können Sie stattdessen Folgendes für eine kleine Ersparnis verwenden:

if (defined $name && $name ne '') {
    # do something with $name
}

Sie könnten den definierten Scheck fallen lassen und etwas noch kürzeres bekommen, z.

if ($name ne '') {
    # do something with $name
}

Aber in dem Fall, in dem $namenicht definiert ist, obwohl der Logikfluss genau wie beabsichtigt funktioniert warnings, erhalten Sie die folgende Ermahnung , wenn Sie verwenden (und Sie sollten es sein):

Verwendung eines nicht initialisierten Wertes in der Zeichenfolge ne

Wenn es also eine Chance gibt, die $namemöglicherweise nicht definiert ist, müssen Sie in erster Linie die Definiertheit überprüfen, um diese Warnung zu vermeiden. Wie Sinan Ünür hervorhebt, können Sie Scalar :: MoreUtils verwenden , um Code, der genau das tut (prüft auf Definiertheit, prüft dann auf Nulllänge) , sofort über die folgende empty()Methode abzurufen :

use Scalar::MoreUtils qw(empty);
if(not empty($name)) {
    # do something with $name 
}

Erstens, da lengthimmer eine nicht negative Zahl zurückgegeben wird,

if ( length $name )

und

if ( length $name > 0 )

sind gleichwertig.

Wenn Sie einen undefinierten Wert durch eine leere Zeichenfolge ersetzen können, können Sie den //=Operator von Perl 5.10 verwenden , der die RHS der LHS zuweist, sofern die LHS nicht definiert ist:

#!/usr/bin/perl

use feature qw( say );
use strict; use warnings;

my $name;

say 'nonempty' if length($name //= '');
say "'$name'";

Beachten Sie das Fehlen von Warnungen zu einer nicht initialisierten Variablen, da $namedie leere Zeichenfolge zugewiesen wird, wenn sie nicht definiert ist.

Wenn Sie jedoch nicht von der Installation von 5.10 abhängig sein möchten, verwenden Sie die von Scalar :: MoreUtils bereitgestellten Funktionen . Zum Beispiel kann das Obige wie folgt geschrieben werden:

#!/usr/bin/perl

use strict; use warnings;

use Scalar::MoreUtils qw( define );

my $name;

print "nonempty\n" if length($name = define $name);
print "'$name'\n";

Wenn Sie nicht überfallen möchten $name, verwenden Sie default.

In Fällen, in denen es mir egal ist, ob die Variable undefgleich oder gleich ist, fasse ''ich sie normalerweise wie folgt zusammen:

$name = "" unless defined $name;
if($name ne '') {
  # do something with $name
}

Du könntest sagen

 $name ne ""

anstatt

 length $name > 0

Es ist nicht immer möglich, sich wiederholende Dinge auf einfache und elegante Weise zu tun.

Tun Sie einfach das, was Sie immer tun, wenn Sie gemeinsamen Code haben, der in vielen Projekten repliziert wird:

Suchen Sie nach CPAN, möglicherweise hat jemand bereits den Code für Sie. Für diese Ausgabe habe ich Scalar :: MoreUtils gefunden .

Wenn Sie in CPAN nichts finden, was Ihnen gefällt, erstellen Sie ein Modul und fügen Sie den Code in eine Unterroutine ein:

package My::String::Util;
use strict;
use warnings;
our @ISA = qw( Exporter );
our @EXPORT = ();
our @EXPORT_OK = qw( is_nonempty);

use Carp  qw(croak);

sub is_nonempty ($) {
    croak "is_nonempty() requires an argument" 
        unless @_ == 1;

    no warnings 'uninitialized';

    return( defined $_[0] and length $_[0] != 0 );
}

1;

=head1 BOILERPLATE POD

blah blah blah

=head3 is_nonempty

Returns true if the argument is defined and has non-zero length.    

More boilerplate POD.

=cut

Dann nennen Sie es in Ihrem Code:

use My::String::Util qw( is_nonempty );

if ( is_nonempty $name ) {
    # do something with $name
}

Wenn Sie Prototypen ablehnen und keine Einwände gegen die zusätzlichen Parens erheben, überspringen Sie den Prototyp im Modul und nennen Sie ihn wie folgt : is_nonempty($name).

Die ausgezeichnete Bibliothek Type :: Tiny bietet ein Framework, mit dem Sie die Typprüfung in Ihren Perl-Code integrieren können. Was ich hier zeige, ist nur die dünnste Spitze des Eisbergs und verwendet Type :: Tiny auf einfachste und manuellste Weise.

Weitere Informationen finden Sie im Type :: Tiny :: Manual .

use Types::Common::String qw< NonEmptyStr >;

if ( NonEmptyStr->check($name) ) {
    # Do something here.
}

NonEmptyStr->($name);  # Throw an exception if validation fails

Wie wäre es mit

if (length ($name || '')) {
  # do something with $name
}

Dies entspricht nicht ganz Ihrer Originalversion, da es auch false zurückgibt, wenn $nameder numerische Wert 0 oder die Zeichenfolge ist '0', sich aber in allen anderen Fällen gleich verhält.

In Perl 5.10 (oder höher) wäre der geeignete Ansatz, stattdessen den definierten Operator oder Operator zu verwenden:

use feature ':5.10';
if (length ($name // '')) {
  # do something with $name
}

Dies entscheidet darüber, wie lang es sein soll, basierend darauf, ob $namees definiert ist und nicht, ob es wahr ist. 0 / '0'behandelt diese Fälle also korrekt, erfordert jedoch eine neuere Version von Perl, als viele Leute zur Verfügung haben.

if ($ name)
{
    #since undef und '' werden beide als false ausgewertet 
    #dies sollte nur funktionieren, wenn die Zeichenfolge definiert und nicht leer ist ...
    #wenn Sie nicht etwas wie $ name = "0" erwarten, das falsch ist.
    #notice obwohl $ name = "00" nicht falsch ist
}}