Comment utiliser les variables booléennes en Perl?

J'ai essayé:

$var = false;
$var = FALSE;
$var = False;

Aucun de ces travaux. Je reçois le message d'erreur

Les mots nus "false" ne sont pas autorisés lorsque "strict subs" est utilisé.

En Perl, ce qui suit est évalué à faux dans les conditions:

0
'0'
undef
''  # Empty scalar
()  # Empty list
('')

Le reste est vrai. Il n'y a pas de mots nus pour trueou false.

La définition la plus complète et concise de faux que j'ai rencontrée est:

Tout ce qui se transforme en chaîne vide ou en chaîne 0est faux. Tout le reste est vrai.

Par conséquent, les valeurs suivantes sont fausses:

• La chaîne vide
• Valeur numérique zéro
• Une valeur indéfinie
• Un objet avec un opérateur booléen surchargé qui évalue l'un des éléments ci-dessus.
• Une variable magique qui s'évalue à l'une des précédentes lors de la récupération.

Gardez à l'esprit qu'un littéral de liste vide est évalué à une valeur indéfinie dans un contexte scalaire, il est donc évalué à quelque chose de faux.

Une note sur les "vrais zéros"

Alors que les nombres qui se stratifient en 0sont faux, les chaînes qui se chiffrent en zéro ne le sont pas nécessairement. Les seules fausses chaînes sont0 la chaîne vide. Toute autre chaîne, même si elle est de zéro, est vraie.

Les chaînes suivantes sont vraies en tant que booléen et zéro en tant que nombre:

• Sans avertissement:
  • "0.0"
  • "0E0"
  • "00"
  • "+0"
  • "-0"
  • " 0"
  • "0\n"
  • ".0"
  • "0."
  • "0 but true"
  • "\t00"
  • "\n0e1"
  • "+0.e-9"
• Avec un avertissement:
  • Toute chaîne pour laquelle Scalar::Util::looks_like_numberrenvoie false. (par exemple "abc")

Perl n'a pas de type booléen natif, mais vous pouvez utiliser la comparaison d'entiers ou de chaînes afin d'obtenir le même comportement. L'exemple d'Alan est une belle façon de le faire en utilisant la comparaison d'entiers. Voici un exemple

my $boolean = 0;
if ( $boolean ) {
    print "$boolean evaluates to true\n";
} else {
    print "$boolean evaluates to false\n";
}

Une chose que j'ai faite dans certains de mes programmes est d'ajouter le même comportement en utilisant une constante:

#!/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";
}

Les lignes marquées "use constant" définissent une constante nommée true qui évalue toujours à 1 et une constante nommée false qui évalue toujours par 0. En raison de la façon dont les constantes sont définies en Perl, les lignes de code suivantes échouent également:

true = 0;
true = false;

Le message d'erreur doit dire quelque chose comme «Impossible de modifier la constante dans l'affectation scalaire».

Je l'ai vu dans l'un des commentaires que vous avez demandé sur la comparaison des chaînes. Vous devez savoir que parce que Perl combine des chaînes et des types numériques dans des variables scalaires, vous avez une syntaxe différente pour comparer les chaînes et les nombres:

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 différence entre ces opérateurs est une source de confusion très courante en Perl.

Je recommande use boolean;. Vous devez cependant installer le module booléen depuis cpan.

Mes favoris ont toujours été

use constant FALSE => 1==0;
use constant TRUE => not FALSE;

qui est complètement indépendant de la représentation interne.

Je suis tombé sur un tutoriel qui a une bonne explication sur les valeurs vraies et fausses en Perl . Il déclare que:

Les valeurs scalaires suivantes sont considérées comme fausses:

• undef - la valeur indéfinie
• 0 le nombre 0, même si vous l'écrivez en 000 ou 0,0
• '' la chaîne vide.
• '0' la chaîne qui contient un seul chiffre 0.

Toutes les autres valeurs scalaires, y compris les suivantes, sont vraies:

• 1 tout numéro différent de 0
• ' ' la chaîne avec un espace
• '00' deux ou plusieurs 0 caractères dans une chaîne
• "0\n" un 0 suivi d'une nouvelle ligne
• 'true'
• 'false' oui, même la chaîne 'false' a la valeur true.

Il existe un autre bon tutoriel qui explique le vrai et le faux de Perl .

Belle explication donnée par bobf pour les valeurs booléennes: Vrai ou faux? Un guide de référence rapide

Tests de vérité pour différentes valeurs

                       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

utilisez le préfixe de fichier suivant, cela ajoutera à votre script perl eTRUE et eFALSE, ce sera en fait REAL (!) vrai et faux (tout comme 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' )
             };

Il y a, en fait, peu de raisons pour lesquelles vous devriez utiliser cela.

Ma raison est qu'en travaillant avec JSON, j'ai 0 et 1 comme valeurs pour les clés, mais ce hack s'assurera que les valeurs correctes sont conservées tout au long de votre script.