Ich habe versucht:
$var = false;
$var = FALSE;
$var = False;
Keine dieser Arbeiten. Ich erhalte die Fehlermeldung
Barwort "false" ist nicht zulässig, solange "strict subs" verwendet wird.
Ich habe versucht:
$var = false;
$var = FALSE;
$var = False;
Keine dieser Arbeiten. Ich erhalte die Fehlermeldung
Barwort "false" ist nicht zulässig, solange "strict subs" verwendet wird.
Antworten:
In Perl wird Folgendes unter Bedingungen als falsch bewertet:
0
'0'
undef
'' # Empty scalar
() # Empty list
('')
Der Rest ist wahr. Es gibt keine Barwörter für true
oder false
.
undef
.
('')
und ''
sind der gleiche Wert. Ich denke, Sie wollten eine Liste mit einem Element implizieren, das aus einer leeren Zeichenfolge besteht (obwohl Parens keine Listen erstellen), aber wie ich bereits erwähnt habe, ist es unmöglich zu überprüfen, ob eine Liste wahr oder falsch ist.
!0
aka PL_sv_yes
) und false ( !1
aka PL_sv_no
). Oder sagen Sie, Perl sollte krächzen, wenn etwas anderes als diese beiden Werte auf Wahrhaftigkeit geprüft werden? Das wäre völlig schrecklich. zB würde es verhindern$x ||= $default;
Die vollständigste und prägnanteste Definition von falsch ist mir begegnet:
Alles, was mit der leeren Zeichenfolge oder der Zeichenfolge verknüpft wird,
0
ist falsch. Alles andere ist wahr.
Daher sind die folgenden Werte falsch:
Beachten Sie, dass ein leeres Listenliteral im skalaren Kontext einen undefinierten Wert ergibt, sodass es einen falschen Wert ergibt.
Ein Hinweis zu "wahren Nullen"
Während Zahlen, zu denen eine Zeichenfolge führt, 0
falsch sind, sind Zeichenfolgen, die zu Null nummerieren, nicht unbedingt falsch. Die einzigen falschen Zeichenfolgen sind 0
und die leere Zeichenfolge. Jede andere Zeichenfolge, auch wenn sie auf Null nummeriert ist, ist wahr.
Die folgenden Zeichenfolgen sind als Boolescher Wert und als Zahl als Null wahr:
"0.0"
"0E0"
"00"
"+0"
"-0"
" 0"
"0\n"
".0"
"0."
"0 but true"
"\t00"
"\n0e1"
"+0.e-9"
Scalar::Util::looks_like_number
false zurückgegeben wird. (zB "abc"
)my $value = do { package XXX; use overload q[""] => sub { "XXX" }, q[bool] => sub { 0 }; bless [] };
. Jetzt $value
wird auf "XXX" gesetzt, aber auf false boolifiziert.
bool
Zeichenfolge enthält 0
. Sie werden auch davon abgehalten, inkonsistente Überladungen zu erstellen, und die von Ihnen zurückgegebenen Werte können als solche angesehen werden. (zB &&
kann a in a optimiert werden. ||
Wenn diese also inkonsistent wären, hätten Sie ein Problem.)
0x00
hier behandelt wird.
0x00
Wert (der numerische Wert Null) oder die Zeichenfolge 0x00
(für die looks_like_number
falsch ist)? In jedem Fall ist es bereits abgedeckt.
Perl hat keinen nativen booleschen Typ, aber Sie können Ganzzahlen oder Zeichenfolgen vergleichen, um das gleiche Verhalten zu erzielen. Alans Beispiel ist eine gute Möglichkeit, dies durch den Vergleich von ganzen Zahlen zu tun. Hier ist ein Beispiel
my $boolean = 0;
if ( $boolean ) {
print "$boolean evaluates to true\n";
} else {
print "$boolean evaluates to false\n";
}
Eine Sache, die ich in einigen meiner Programme getan habe, ist das gleiche Verhalten unter Verwendung einer Konstante:
#!/usr/bin/perl
use strict;
use warnings;
use constant false => 0;
use constant true => 1;
my $val1 = true;
my $val2 = false;
print $val1, " && ", $val2;
if ( $val1 && $val2 ) {
print " evaluates to true.\n";
} else {
print " evaluates to false.\n";
}
print $val1, " || ", $val2;
if ( $val1 || $val2 ) {
print " evaluates to true.\n";
} else {
print " evaluates to false.\n";
}
Die unter "Konstante verwenden" markierten Zeilen definieren eine Konstante mit dem Namen true, die immer mit 1 ausgewertet wird, und eine Konstante mit dem Namen false, die immer mit 0 bewertet wird. Aufgrund der Art und Weise, wie Konstanten in Perl definiert werden, schlagen auch die folgenden Codezeilen fehl:
true = 0;
true = false;
Die Fehlermeldung sollte etwa "Konstante in Skalarzuweisung kann nicht geändert werden" lauten.
Ich habe das in einem der Kommentare gesehen, die Sie zum Vergleichen von Zeichenfolgen angefordert haben. Da Perl Zeichenfolgen und numerische Typen in skalaren Variablen kombiniert, sollten Sie wissen, dass Sie unterschiedliche Syntax zum Vergleichen von Zeichenfolgen und Zahlen haben:
my $var1 = "5.0";
my $var2 = "5";
print "using operator eq\n";
if ( $var1 eq $var2 ) {
print "$var1 and $var2 are equal!\n";
} else {
print "$var1 and $var2 are not equal!\n";
}
print "using operator ==\n";
if ( $var1 == $var2 ) {
print "$var1 and $var2 are equal!\n";
} else {
print "$var1 and $var2 are not equal!\n";
}
Der Unterschied zwischen diesen Operatoren ist eine sehr häufige Quelle der Verwirrung in Perl.
use warnings;
statt#! perl -w
if ($exitstatus) { exit; }
vs if ($exitstatus == true) { exit; }
, was für einen zufälligen Beobachter möglicherweise nicht offensichtlich ist. (Und ja, das letzte Beispiel ist ein schlechter Programmierstil, aber das ist nebensächlich).
Ich empfehle use boolean;
. Sie müssen das boolesche Modul jedoch von cpan aus installieren.
if ($my_true_value == true)
. Das Vorgeben, dass es eine wahre Wahrheit gibt, ist meiner Erfahrung nach ein Weg zum Schmerz und ineffizienter Code.
Meine Favoriten waren schon immer
use constant FALSE => 1==0;
use constant TRUE => not FALSE;
das ist völlig unabhängig von der internen Darstellung.
Ich bin auf ein Tutorial gestoßen, das gut erklärt, welche Werte in Perl wahr und was falsch sind . Darin heißt es:
Folgende Skalarwerte gelten als falsch:
undef
- der undefinierte Wert0
die Zahl 0, auch wenn Sie sie als 000 oder 0,0 schreiben''
die leere Zeichenfolge.'0'
Die Zeichenfolge, die eine einzelne 0-Ziffer enthält.Alle anderen Skalarwerte, einschließlich der folgenden, sind wahr:
1
eine beliebige Nicht-0-Zahl' '
die Zeichenfolge mit einem Leerzeichen'00'
zwei oder mehr 0 Zeichen in einer Zeichenfolge"0\n"
eine 0 gefolgt von einem Zeilenumbruch'true'
'false'
Ja, sogar die Zeichenfolge 'false' wird als true ausgewertet.Es gibt ein weiteres gutes Tutorial, das Perl als wahr und falsch erklärt .
Schöne Erklärung von bobf für boolesche Werte: Richtig oder falsch? Eine Kurzanleitung
Wahrheitstests für verschiedene Werte
Result of the expression when $var is:
Expression | 1 | '0.0' | a string | 0 | empty str | undef
--------------------+--------+--------+----------+-------+-----------+-------
if( $var ) | true | true | true | false | false | false
if( defined $var ) | true | true | true | true | true | false
if( $var eq '' ) | false | false | false | false | true | true
if( $var == 0 ) | false | true | true | true | true | true
Verwenden Sie das folgende Dateipräfix. Dies wird Ihrem Perl-Skript eTRUE und eFALSE hinzugefügt. Es ist tatsächlich REAL (!) true und false (genau wie Java).
#!/usr/bin/perl
use strict;
use warnings;
use constant { #real true false, compatible with encode_json decode_json for later (we don't want field:false... will be field:0...)
eTRUE => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
eFALSE => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' )
};
Es gibt eigentlich nur wenige Gründe, warum Sie das verwenden sollten.
Mein Grund ist, dass ich bei der Arbeit mit JSON 0 und 1 als Werte für Schlüssel habe, aber dieser Hack stellt sicher, dass die korrekten Werte in Ihrem Skript beibehalten werden.