¿Qué significa el uso de un solo tubo? En un argumento de función ¿hacer?

Tomemos, por ejemplo, el siguiente código:

phpinfo(INFO_MODULES | INFO_ENVIRONMENT | INFO_VARIABLES);

Se está utilizando un solo argumento, pero estoy proporcionando una lista de opciones separadas por un solo símbolo de tubería.

• ¿Qué está sucediendo exactamente con el valor del argumento en la función?
• ¿Puedo usar lo mismo en mis propias funciones?
• ¿Es así cómo, y hay beneficios en esto sobre decir pasar una matriz en su lugar?

Operadores bit a bit

Los operadores bit a bit modifican los bits de los valores involucrados. ORBásicamente, un bit a bit combina cada bit del argumento izquierdo y derecho. Por ejemplo:

5 | 2

Se traduciría a bits / binario como:

101 | 10

Lo que resultaría en:

111

Porque:

1 || 0 = 1
0 || 1 = 1
1 || 0 = 1

Y como un entero, esa es la representación de 7, que es exactamente lo que obtienes si:

echo 5 | 2;

En palabras de Eddie Izzard ... ¡Bandera!

Como dice Ignacio, esto se usa con mayor frecuencia en PHP (y otros idiomas) como una forma de combinar múltiples banderas. Cada bandera generalmente se define como una constante cuyo valor normalmente se establece en un número entero que representa solo un bit en un desplazamiento diferente:

define('FLAG_A', 1); /// 0001
define('FLAG_B', 2); /// 0010
define('FLAG_C', 4); /// 0100
define('FLAG_D', 8); /// 1000

Luego, cuando ORestos juntos, operan cada uno en su propio desplazamiento de bits y nunca colisionarán:

FLAG_A | FLAG_C

Se traduce a:

1 | 100

Entonces terminas encendiendo:

101

Que representa el número entero 5.

Entonces, todo lo que tiene que hacer el código, el código que reaccionará a los diferentes indicadores que se configuran, es lo siguiente (usando un bit a bit AND):

$combined_flags = FLAG_A | FLAG_C;

if ( $combined_flags & FLAG_A ) {
  /// do something when FLAG_A is set
}

if ( $combined_flags & FLAG_B ) {
  /// this wont be reached with the current value of $combined_flags
}

if ( $combined_flags & FLAG_C ) {
  /// do something when FLAG_C is set
}

Al final del día, simplemente hace que las cosas sean más fáciles de leer al tener constantes con nombre y, en general, es más óptimo al confiar en valores enteros en lugar de cadenas o matrices. Otro beneficio de usar constantes es que si alguna vez se escriben mal cuando se usan, el compilador está en una mejor situación para decir y lanzar una advertencia ... si se usa un valor de cadena, no tiene forma de saber que algo está mal.

define('MY_FLAG_WITH_EASY_TYPO', 1);

my_function_that_expects_a_flag( MY_FLAG_WITH_EASY_TPYO );

/// if you have strict errors on the above will trigger an error

my_function_that_expects_a_flag( 'my_string_with_easy_tpyo' );

/// the above is just a string, the compiler knows nowt with 
/// regard to it's correctness, so instead you'd have to
/// code your own checks.

Estás pasando un argumento que es el OR bit a bit de varios indicadores . Puede utilizar el operador en cualquier lugar que desee.