¿Cómo uso variables booleanas en Perl?

Yo he tratado:

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

Ninguno de estos trabajos. Me sale el mensaje de error

No se permiten palabras falsas "falsas" mientras se usan "subs estrictos".

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

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

Lo demás es verdad. No hay palabras vacías para trueo false.

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

Todo lo que se convierte en cadena vacía o cadena 0es falso. Todo lo demás es verdad.

Por lo tanto, los siguientes valores son falsos:

• La cadena vacía
• Valor numérico cero
• Un valor indefinido
• Un objeto con un operador booleano sobrecargado que evalúa uno de los anteriores.
• Una variable mágica que se evalúa como una de las anteriores en la búsqueda.

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

Una nota sobre "ceros verdaderos"

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

Las siguientes son cadenas que son verdaderas como un booleano 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 para la cual Scalar::Util::looks_like_numberdevuelve falso. (por ejemplo "abc")

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 usando la comparación de enteros. Aquí hay 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 es agregar el mismo comportamiento usando 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 "usar constante" definen una constante llamada true que siempre se evalúa en 1, y una constante llamada false que siempre se evalúa en 0. Debido a la forma en que las constantes se definen 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 constante en la asignación escalar".

Vi eso en uno de los comentarios que preguntaste sobre la comparación de cadenas. Debe saber que debido a 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.

Recomiendo use boolean;. Sin embargo, debe instalar el módulo booleano desde cpan.

Mis favoritos siempre han sido

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

que es completamente independiente de la representación interna.

Encontré un tutorial que tiene una buena explicación sobre qué valores son verdaderos y falsos en Perl . Establece que:

Los siguientes valores escalares se consideran falsos:

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

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

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

Hay otro buen tutorial que explica acerca de Perl verdadero y falso .

Hermosa explicación dada por bobf para los 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

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

En realidad, hay 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 se asegurará de que se mantengan los valores correctos a lo largo de su secuencia de comandos.