Ho provato:
$var = false;
$var = FALSE;
$var = False;
Nessuno di questi lavori. Ricevo il messaggio di errore
Bareword "false" non consentito mentre è in uso "sottotitoli rigorosi".
Ho provato:
$var = false;
$var = FALSE;
$var = False;
Nessuno di questi lavori. Ricevo il messaggio di errore
Bareword "false" non consentito mentre è in uso "sottotitoli rigorosi".
Risposte:
In Perl, quanto segue valuta falso in condizionali:
0
'0'
undef
'' # Empty scalar
() # Empty list
('')
Il resto è vero. Non ci sono parole in chiaro per true
o false
.
undef
.
('')
e ''
hanno lo stesso valore. Penso che tu abbia voluto implicare un elenco con un elemento che consiste in una stringa vuota (anche se i genitori non creano elenchi), ma come ho già detto, è impossibile verificare se un elenco è vero per falso.
!0
aka PL_sv_yes
) e false ( !1
aka PL_sv_no
). O stai dicendo che Perl dovrebbe gracchiare ogni volta che qualcosa di diverso da questi due valori viene testato per la verità? Sarebbe del tutto terribile. ad esempio, impedirebbe$x ||= $default;
La definizione più completa e concisa di falso che ho incontrato è:
Tutto ciò che si stringe nella stringa vuota o nella stringa
0
è falso. Tutto il resto è vero.
Pertanto, i seguenti valori sono falsi:
Tieni presente che un elenco vuoto letterale valuta un valore indefinito in un contesto scalare, quindi valuta qualcosa di falso.
Una nota sugli "zeri reali"
Mentre i numeri che si stringono 0
sono falsi, le stringhe che si numerano a zero non lo sono necessariamente. Le uniche stringhe false sono 0
e la stringa vuota. Qualsiasi altra stringa, anche se numera a zero, è vera.
Di seguito sono le stringhe che sono vere come un valore booleano e zero come un numero:
"0.0"
"0E0"
"00"
"+0"
"-0"
" 0"
"0\n"
".0"
"0."
"0 but true"
"\t00"
"\n0e1"
"+0.e-9"
Scalar::Util::looks_like_number
restituisce false. (ad es. "abc"
)my $value = do { package XXX; use overload q[""] => sub { "XXX" }, q[bool] => sub { 0 }; bless [] };
. Ora $value
si stringerà su "XXX" ma boolifica su falso.
bool
Tieni presente che il valore restituito dal tuo si applica a 0
. Inoltre, si è scoraggiati dalla creazione di sovraccarichi incoerenti e i valori restituiti potrebbero essere considerati tali. (es. a &&
può essere ottimizzato in a ||
, quindi se questi fossero incoerenti, avresti un problema.)
0x00
è coperto qui.
0x00
(il valore numerico zero) o dalla stringa 0x00
(per cui looks_like_number
è falso)? Ad ogni modo, è già coperto.
Perl non ha un tipo booleano nativo, ma è possibile utilizzare il confronto di numeri interi o stringhe per ottenere lo stesso comportamento. L'esempio di Alan è un bel modo di farlo usando il confronto di numeri interi. Ecco un esempio
my $boolean = 0;
if ( $boolean ) {
print "$boolean evaluates to true\n";
} else {
print "$boolean evaluates to false\n";
}
Una cosa che ho fatto in alcuni dei miei programmi è l'aggiunta dello stesso comportamento usando una costante:
#!/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";
}
Le righe contrassegnate in "usa costante" definiscono una costante denominata true che restituisce sempre 1 e una costante denominata false che valuta sempre per 0. A causa del modo in cui le costanti sono definite in Perl, anche le seguenti righe di codice falliscono:
true = 0;
true = false;
Il messaggio di errore dovrebbe dire qualcosa come "Impossibile modificare la costante nell'assegnazione scalare".
Ho visto che in uno dei commenti hai chiesto di confrontare le stringhe. Dovresti sapere che, poiché Perl combina stringhe e tipi numerici in variabili scalari, hai una sintassi diversa per confrontare stringhe e numeri:
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";
}
La differenza tra questi operatori è una fonte di confusione molto comune in Perl.
use warnings;
anziché#! perl -w
if ($exitstatus) { exit; }
vs if ($exitstatus == true) { exit; }
, che potrebbe non essere ovvio per un osservatore casuale. (E sì, l'ultimo esempio è uno stile di programmazione scadente, ma non è questo il punto).
Mi raccomando use boolean;
. Tuttavia, devi installare il modulo booleano da cpan.
if ($my_true_value == true)
. Far finta che esista un'unica vera verità è, nella mia esperienza, un percorso verso il dolore e un codice inefficiente.
I miei preferiti sono sempre stati
use constant FALSE => 1==0;
use constant TRUE => not FALSE;
che è completamente indipendente dalla rappresentazione interna.
Mi sono imbattuto in un tutorial che spiega bene quali valori sono veri e falsi in Perl . Si afferma che:
I seguenti valori scalari sono considerati falsi:
undef
- il valore indefinito0
il numero 0, anche se lo scrivi come 000 o 0,0''
la stringa vuota.'0'
la stringa che contiene una singola cifra 0.Tutti gli altri valori scalari, inclusi i seguenti, sono veri:
1
qualsiasi numero diverso da 0' '
la stringa con uno spazio al suo interno'00'
due o più 0 caratteri in una stringa"0\n"
uno 0 seguito da una nuova riga'true'
'false'
sì, anche la stringa 'false' viene valutata vera.C'è un altro buon tutorial che spiega su Perl vero e falso .
Bella spiegazione data da bobf per i valori booleani: vero o falso? Una guida di riferimento rapido
Test di verità per valori diversi
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
usa il seguente prefisso di file, questo aggiungerà al tuo script perl eTRUE ed eFALSE, sarà in realtà REAL (!) vero e falso (proprio come 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' )
};
In realtà, ci sono alcuni motivi per cui dovresti usarlo.
La mia ragione è che lavorando con JSON, ho 0 e 1 come valori per le chiavi, ma questo hack assicurerà che i valori corretti vengano mantenuti lungo il tuo script.