¿Cómo uso las variables booleanas en Perl?

Question

Yo he tratado:

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

Ninguno de estos trabajos. Me sale el mensaje de error

Bareword "false" not allowed while "strict subs" is in use.

Answer 1

En Perl, lo siguiente se evalúa como falso en condicionales:

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

El resto es verdad. No hay palabras peladas para true o false .

Answer 2

Encontré un tutorial que explica bien qué valores son verdaderos y falsos en Perl . Afirma que:

Los siguientes valores escalares se consideran falsos:

• undef - el valor indefinido
• 0 el número 0, incluso si lo escribes como 000 o 0.0
• '''' la cadena vacía.
• ''0'' la cadena que contiene un solo 0 dígitos.

Todos los demás valores escalares, incluidos los siguientes, son verdaderos:

• 1 cualquier número que no sea 0
• '' '' la cadena con un espacio en ella
• ''00'' dos o más 0 caracteres en una cadena
• "0/n" a 0 seguido de una nueva línea
• ''true''
• ''false'' sí, incluso la cadena ''false'' se evalúa como verdadera.

Hay otro buen tutorial que explica sobre Perl verdadero y falso .

Answer 3

Hermosa explicación dada por bobf de valores booleanos: Verdadero o Falso? Una guía de referencia rápida

Pruebas de verdad para diferentes valores.

                       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

Answer 4

La definición más completa y concisa de falso que he encontrado es:

Cualquier cosa que stringifies a la cadena vacía o la cadena `0` es falsa. Todo lo demás es verdad.

Por lo tanto, los siguientes valores son falsos:

• La cadena vacia
• Valor numerico cero
• Un valor indefinido
• Un objeto con un operador booleano sobrecargado que evalúa uno de los anteriores.
• Una variable mágica que evalúa a uno de los anteriores en la búsqueda.

Tenga en cuenta que un literal de lista vacía se evalúa como un valor indefinido en un contexto escalar, por lo que se evalúa como algo falso.

Una nota sobre "ceros verdaderos"

Mientras que los números que stringify a 0 son falsas, cadenas que numify a cero no son necesariamente. Las únicas cadenas falsas son 0 y la cadena vacía. Cualquier otra cadena, incluso si se numera a cero, es verdadera.

Los siguientes son cadenas que son verdad como un valor lógico y cero como un número.

• Sin peligro:
  • "0.0"
  • "0E0"
  • "00"
  • "+0"
  • "-0"
  • " 0"
  • "0/n"
  • ".0"
  • "0."
  • "0 but true"
  • "/t00"
  • "/n0e1"
  • "+0.e-9"
• Con una advertencia:
  • Cualquier cadena que Scalar::Util::looks_like_number devuelve falso. (por ejemplo, "abc" )

Answer 5

Mis favoritos siempre han sido

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

Que es completamente independiente de la representación interna.

Answer 6

Perl no tiene un tipo booleano nativo, pero puede usar la comparación de enteros o cadenas para obtener el mismo comportamiento. El ejemplo de Alan es una buena manera de hacerlo utilizando la comparación de enteros. Aquí un ejemplo

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

Una cosa que he hecho en algunos de mis programas se añade el mismo comportamiento utilizando una 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";
}

Las líneas marcadas en "constante de uso" definen una constante con nombre verdadero que siempre se evalúa como 1 y una constante con nombre falso que siempre se evalúa con 0. Debido a la forma en que se definen las constantes en Perl, las siguientes líneas de código también fallan:

true = 0;
true = false;

El mensaje de error debería decir algo como "No se puede modificar la asignación constante en escalar."

Vi que en uno de los comentarios que preguntaste acerca de comparar cadenas. Debe saber que, dado que Perl combina cadenas y tipos numéricos en variables escalares, tiene una sintaxis diferente para comparar cadenas y números:

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 diferencia entre estos operadores es una fuente muy común de confusión en Perl.

Answer 7

Recomiendo use boolean; . Tienes que instalar el módulo boolean desde cpan sin embargo.

Answer 8

use el siguiente prefijo de archivo, esto se agregará a su script de perl eTRUE y eFALSE, en realidad será REAL (!) verdadero y falso (como 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'' )
             };

Hay, en realidad, algunas razones por las que deberías usar eso.

Mi razón es que al trabajar con JSON, tengo 0 y 1 como valores para las claves, pero este truco asegurará que los valores correctos se mantengan a lo largo de su script.