¿Cómo uso variables booleanas en Perl?

La definición más completa y concisa de falso que he encontrado es: {[18]]}

Cualquier cosa que stringifies a la cadena vacía o a la cadena `0` es false. 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 evalúa a uno de los arriba en fetch.

Tenga en cuenta que un literal de lista vacía 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 stringify a 0 son falsos, las cadenas que numify a cero no lo son necesariamente. Las únicas cadenas falsas son 0 y la cadena vacía. Cualquier otra cadena, incluso si numifica a cero, es verdadera.

Las siguientes son cadenas que son verdaderas como una booleano y cero como número.

• Sin previo aviso:
  • "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_number devuelve false. (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. He 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 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 evalúa a 1, y una constante llamada false que siempre evalúa por 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."

Lo vi en uno de los comentarios que preguntaste sobre comparar 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, tienes que 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.

Me encontré con un tutorialque tiene una explicación bien acerca de 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 dígito 0.

Todos los demás valores escalares, incluyendo los siguientes son verdadero:

• 1 cualquier número distinto de 0
• ' ' la cadena 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 'false' se evalúa como true.

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 se 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' )
             };

Hay, en realidad, pocas 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 los valores correctos se mantengan a lo largo de su script.