operadores - binario a decimal php

¿Cómo implementar una máscara de bits en php?

Question

No estoy seguro de si la máscara de bits es el término correcto. Dejame explicar:

En php, la función error_reporting se puede llamar de varias maneras:

// Report simple running errors
error_reporting(E_ERROR | E_WARNING | E_PARSE);
// Reporting E_NOTICE can be good too (to report uninitialized
// variables or catch variable name misspellings ...)
error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
// Report all errors except E_NOTICE
// This is the default value set in php.ini
error_reporting(E_ALL ^ E_NOTICE);

Obtuve el término máscara de bits de la página de php.net aquí

De todos modos, el punto de esto es que he implementado un método SIMPLE llamado ls que devuelve el contenido de un directorio.

Esta función requiere 3 argumentos ... ($ include_hidden = false, $ return_absolute = false, $ ext = false)

Entonces cuando llamo a la función, establezco cómo quiero los resultados. Si quiero que los resultados devuelvan directorios ocultos, si solo quiero basenames, etc.

así que cuando llamo a la función estoy escribiendo

ls(true, false, true)
ls(false, false, true)
ls(true, true, true)
etc...

Pensé que sería mucho más legible si pudiera indicar cómo quiero que se devuelvan los datos.

algo así como:

ls( INCLUDE_HIDDEN | HIDE_EXTS );
ls( SHOW_ABSOLUTE_PATHS | HIDE_EXTS );

etc ...

¿Cómo implementaría esto en términos de probar qué banderas se han llamado?

Answer 1

Es bastante simple en realidad. Primero, un poco de código para demostrar cómo se puede implementar. Si no comprende nada sobre lo que está haciendo este código o cómo funciona, no dude en hacer preguntas adicionales en los comentarios:

const FLAG_1 = 0b0001; // 1
const FLAG_2 = 0b0010; // 2
const FLAG_3 = 0b0100; // 4
const FLAG_4 = 0b1000; // 8
// Can you see the pattern? ;-)
function show_flags ($flags) {
if ($flags & FLAG_1) {
echo "You passed flag 1!<br>/n";
}
if ($flags & FLAG_2) {
echo "You passed flag 2!<br>/n";
}
if ($flags & FLAG_3) {
echo "You passed flag 3!<br>/n";
}
if ($flags & FLAG_4) {
echo "You passed flag 4!<br>/n";
}
}
show_flags(FLAG_1 | FLAG_3);

Manifestación

Como los indicadores son enteros, en una plataforma de 32 bits define hasta 32 indicadores. En una plataforma de 64 bits, es 64. También es posible definir las banderas como cadenas, en cuyo caso el número de banderas disponibles es más o menos infinito (dentro de los límites de los recursos del sistema, por supuesto). Así es como funciona en formato binario (reducido a enteros de 8 bits para simplificar).

FLAG_1
Dec: 1
Binary: 00000001
FLAG_2
Dec: 2
Binary: 00000010
FLAG_3
Dec: 4
Binary: 00000100
// And so on...

Cuando combina las banderas para pasarlas a la función, usted O ellas juntas. Echemos un vistazo a lo que ocurre cuando pasamos FLAG_1 | FLAG_3 FLAG_1 | FLAG_3

 00000001
| 00000100
= 00000101

Y cuando quiera ver qué banderas se establecieron, usted Y la máscara de bits con la bandera. Por lo tanto, tomemos el resultado anterior y veamos si se configuró FLAG_3 :

 00000101
& 00000100
= 00000100

... obtenemos el valor de la bandera, un entero distinto de cero, pero si vemos si se configuró FLAG_2 :

 00000101
& 00000010
= 00000000

... obtenemos cero. Esto significa que puede simplemente evaluar el resultado de la operación Y como un booleano al verificar si se pasó el valor.

Answer 2

Los otros han ofrecido buenas sugerencias, pero en estos días es mucho más común pasar matrices asociativas en lugar de máscaras de bits. Es mucho más legible y le permite pasar otras variables que no sean solo valores verdaderos / falsos. Algo como esto:

myFunction([''includeHidden'' => true, ''fileExts'' => false, ''string'' => ''Xyz'']);
function myFunction($options) {
// Set the default options
$options += [
''includeHidden'' => false,
''fileExts'' => true,
''string'' => ''Abc'',
];
if ($options[''includeHidden'']) {
...
}
...
}

Answer 3

define( "INCLUDE_HIDDEN", 0x1 );
define( "HIDE_EXTS", 0x2 );
define( "SHOW_ABSOLUTE_PATHS", 0x4 );
//And so on, 0x8, 0x10, 0x20, 0x40, 0x80, 0x100, 0x200, 0x400, 0x800 etc..

A continuación, puede verificar si hay indicadores individuales en su función ls :

if( $flags & INCLUDE_HIDDEN ) { //<-- note just a single &, bitwise and
//$flags have INCLUDE_HIDDEN
}