view release on metacpan or  search on metacpan

lib/POD2/ES/perlop.pod  view on Meta::CPAN

El binario C<"|"> devuelve la operación OR, bit a bit, de sus operandos.

El binario C<"^"> devuelve la operación XOR, bit a bit, de sus operandos.

A pesar de que no se levante en este momento ninguna advertencia, los
resultados no están bien definidos cuando esta operación actúa en operandos
que no son ni números (vea L<Aritmética entera>) ni cadenas de bits (vea
L<Operadores de bit en cadenas>).

Tenga en cuenta que C<"|"> y C<"^"> tienen menor prioridad que los operadores
relacionales, así que, por ejemplo, los paréntesis son esenciales en una
prueba como

    print "falso\n" if (8 | 2) != 10;

Si está activada la característica experimental "bitwise" por medio de
S<C<use feature 'bitwise'>>, entonces este operador siempre trata a sus
argumentos como números. Esta característica produce una advertencia a menos
que use S<C<no warnings 'experimental::bitwise'>>.

=head2 And lógico al estilo del C
X<&&> X<logical and> X<operator, logical, and> X<and lógico> X<operador, lógico, and>

El binario C<"&&"> realiza una operación lógica AND abreviada. Es decir, si
el operando izquierdo es falso, el operando de la derecha no es ni siquiera
evaluado. Los contextos escalar o lista se propagan hacia el operando de la
derecha si éste es evaluado.

=head2 Or lógico al estilo del C
X<||> X<operator, logical, or> X<operador, lógico, or>

El binario C<"||"> realiza una operación lógica OR abreviada. Es decir, si el
operando izquierdo es verdadero, el operando de la derecha no es ni siquiera
evaluado. Los contextos escalar o lista se propagan hacia el operando de la
derecha si éste es evaluado.

=head2 Defined-Or lógico
X<//> X<operator, logical, defined-or> X<operador, lógico, defined-or>

A pesar de que no tiene equivalente directo en C, el operador Perl C<//> está
relacionado con el operador "or" del C. De hecho, es exactamente lo mismo que
C<||>, excepto que comprueba la definición del lado izquierdo en lugar de su
estado de verdad. Por lo tanto, S<C<< EXPR1 // EXPR2 >>> devuelve el valor de
C<< EXPR1 >> si está definida, de lo contrario, se devuelve el valor de C<<
EXPR2 >>. (C<< EXPR1 >> se evalúa en contexto de escalar, C<< EXPR2 >> en el
propio contexto de C<< // >>). Normalmente, este es el mismo resultado que
S<C<< defined(EXPR1) ? EXPR1 : EXPR2 >>> (salvo que la forma del operador
ternario se puede utilizar como un valor-izquierda, mientras que S<C<< EXPR1 //
EXPR2 >>>, no). Esto es muy útil para proporcionar valores por defecto a las
variables. Si realmente desea probar si al menos uno de los dos, C<$x> o C<$y>,
están definidos, use S<C<defined($x // $y)>>.

Los operadores C<||>, C<//> y C<&&> devuelven el último valor evaluado (a
diferencia de los operadores del C C<||> y C<&&>, que devuelve 0 o 1). Por lo
tanto, un forma razonablemente portátil para averiguar nuestro directorio
principal podría ser:

    $home =  $ENV{HOME}
	  // $ENV{LOGDIR}
	  // (getpwuid($<))[7]
	  // die "¡Eres un sintecho!\n";

En particular, esto significa que usted no debería usar esto para seleccionar
entre dos agregados para hacer una asignación:

    @a = @b || @c;            # Esto no hace lo correcto
    @a = scalar(@b) || @c;    # porque realmente quiere decir esto.
    @a = @b ? @b : @c;        # Aunque esto también funciona.

Como alternativas a C<&&> y C<||> cuando se usan para control de flujo, Perl
proporciona los operadores C<and> y C<or> (vea más adelante). El
comportamiento abreviado es idéntico. Sin embargo, la precedencia de C<"and">
y C<"or"> es mucho menor, de modo que puede usarlos con seguridad después de
un operador de lista sin necesidad de poner paréntesis:

    unlink "alfa", "beta", "gamma"
	    or gripe(), next LINEA;

Con los operadores del estilo del C esto se hubiera escrito así:

    unlink("alfa", "beta", "gamma")
	    || (gripe(), next LINEA);

Sería incluso más claro escribirlo de esta manera:

    unless(unlink("alfa", "beta", "gama")) {
        gripe();
        next LINEA;
    } 

Es poco probable que quiera usar C<"or"> para hacer asignaciones; vea más
abajo.

=head2 Operadores de rango
X<operator, range> X<range> X<..> X<...> X<operador, rango> X<rango>

El binario C<".."> es el operador rango, que en realidad son dos operadores
diferentes dependiente del contexto. En contexto de lista, devuelve una lista
de valores contando (de uno en uno) desde el valor de la izquierda al valor de
la derecha. Si el valor de la izquierda es mayor que el valor de la derecha
entonces devuelve la lista vacía. El operador rango es útil para escribir
bucles S<C<foreach (1..10)>> y para hacer operaciones de troceado en los
arrays. En la implementación actual, no se crea ningún array temporal cuando
el operador rango es usado como expresión en los bucles C<foreach>, pero
versiones anteriores de Perl pueden quemar una gran cantidad de memoria cuando
se escribe algo como esto:

    for (1 .. 1_000_000) {
	# código
    }

El operador rango también trabaja en las cadenas, usando el auto-incremento
mágico. Vea más abajo.

En contexto de escalar, C<".."> devuelve un valor booleano. El operador es
biestable, como un flip-flop, y emula el operador rango-de-línea de B<sed>,
B<awk>, y diversos editores. Cada operador C<".."> mantiene su estado booleano
propio, incluso a través de llamadas a la subrutina que lo contenga. Es falso,
siempre y cuando su operando izquierdo sea falso. Una vez que el operando
izquierdo sea verdadero, el operador rango se mantiene así hasta que el