update_option page_for_posts php null

page_for_posts - Nulo vs. Falso vs. 0 en PHP



page_for_posts wordpress (17)

Me dijeron que los buenos desarrolladores pueden detectar / utilizar la diferencia entre Null y False y 0 y todas las demás buenas entidades de "nada".
¿Cuál es la diferencia, específicamente en PHP? ¿Tiene algo que ver con === ?

Es un lenguaje específico, pero en PHP:

Null significa " nada ". La var no se ha inicializado.

False significa " no verdadero en un contexto booleano ". Se usa para mostrar explícitamente que se trata de problemas lógicos.

0 es un int . Nada que ver con el resto de arriba, usado para las matemáticas.

Ahora, lo que es complicado, es que en los lenguajes dinámicos como PHP, todos ellos tienen un valor en un contexto booleano , que (en PHP) es False .

Si lo prueba con == , está probando el valor booleano, por lo que obtendrá la igualdad. Si lo prueba con === , probará el tipo, y obtendrá desigualdad.

Entonces, ¿por qué son útiles?

Bueno, mira la función strrpos() . Devuelve False si no encontró nada, pero 0 si ha encontrado algo al principio de la cadena.

<?php // pitfall : if (strrpos("Hello World", "Hello")) { // never exectuted } // smart move : if (strrpos("Hello World", "Hello") !== False) { // that works ! } ?>

Y por supuesto, si lidias con estados:

Desea marcar la diferencia entre DebugMode = False (desactivado), DebugMode = True (configurado en on) y DebugMode = Null (no configurado en absoluto, dará lugar a una depuración rigurosa ;-)).

¡Acabo de perder 1/2 día tratando de obtener 0, nulo, falso retorno de strpos!

Esto es todo lo que estaba tratando de hacer, antes de encontrar que la lógica no fluía en la dirección correcta, pareciendo que había un agujero negro en la codificación de php:

El concepto toma un nombre de dominio alojado en un servidor, y se asegura de que no sea nivel raíz, OK varias formas diferentes de hacerlo, pero elegí diferente debido a otras funciones / construcciones de PHP que he hecho.

De todos modos, aquí estaba la base del cálculo:

if (strpos($_SERVER [''SERVER_NAME''], dirBaseNAME ()) { do this } else {or that} { echo strpos(mydomain.co.uk, mydomain); if ( strpos(mydomain, xmas) == null ) {echo "/n1 is null"; } if ( (strpos(mydomain.co.uk, mydomain)) == 0 ) {echo "/n2 is 0"; }else {echo "/n2 Something is WRONG"; } if ( (mydomain.co.uk, mydomain)) != 0 ) {echo "/n3 is 0"; }else {echo "/n3 it is not 0"; } if ( (mydomain.co.uk, mydomain)) == null ) {echo "/n4 is null"; }else {echo "/n4 Something is WRONG"; } }

¡FINALMENTE después de leer este Tema, encontré que esto funcionó!

{ if ((mydomain.co.uk, mydomain)) !== false ) { echo "/n5 is True"; } else { echo "/n5 is False"; } }

Gracias por este artículo, ahora entiendo que, aunque es Navidad, puede que no sea Navidad como falsa, ¡porque también puede ser un día nulo!

Después de haber desperdiciado un día de depuración de un código simple, deseé haberlo sabido antes, ya que habría sido capaz de identificarme con el problema en lugar de ir por todo el lugar tratando de que funcione, donde no funcionó de todos modos como Falso , Nulo y 0 no son todos iguales True o False o null?

A continuación hay un ejemplo:

Comparisons of $x with PHP functions Expression gettype() empty() is_null() isset() boolean : if($x) $x = ""; string TRUE FALSE TRUE FALSE $x = null; NULL TRUE TRUE FALSE FALSE var $x; NULL TRUE TRUE FALSE FALSE $x is undefined NULL TRUE TRUE FALSE FALSE $x = array(); array TRUE FALSE TRUE FALSE $x = false; boolean TRUE FALSE TRUE FALSE $x = true; boolean FALSE FALSE TRUE TRUE $x = 1; integer FALSE FALSE TRUE TRUE $x = 42; integer FALSE FALSE TRUE TRUE $x = 0; integer TRUE FALSE TRUE FALSE $x = -1; integer FALSE FALSE TRUE TRUE $x = "1"; string FALSE FALSE TRUE TRUE $x = "0"; string TRUE FALSE TRUE FALSE $x = "-1"; string FALSE FALSE TRUE TRUE $x = "php"; string FALSE FALSE TRUE TRUE $x = "true"; string FALSE FALSE TRUE TRUE $x = "false"; string FALSE FALSE TRUE TRUE

Consulte esto para obtener más referencias de las comparaciones de tipos en PHP y le dará una comprensión clara.

Bueno, no puedo recordar lo suficiente de mis días PHP para responder la parte "===", pero para la mayoría de los lenguajes estilo C, NULL debe usarse en el contexto de valores de puntero, falso como booleano y cero como valor numérico tal como un int. ''/ 0'' es el valor habitual para un contexto de caracteres. Por lo general, también prefiero usar 0.0 para carrozas y dobles.

Entonces ... la respuesta rápida es: contexto.

Creo que los desarrolladores malos encuentran todos los usos diferentes de null / 0 / false en el código.

Por ejemplo, uno de los errores más comunes que cometen los desarrolladores es devolver el código de error en forma de datos con una función.

// On error GetChar returns -1 int GetChar()

Este es un ejemplo de una interfaz de azúcar. Esto se explica en el libro "Depuración del proceso de desarrollo del software" y también en otro libro "escribir el código correcto".

El problema con esto es la implicación o suposiciones hechas en el tipo de caracteres. En algunos compiladores, el tipo de caracteres puede no estar firmado. Entonces, aunque devuelva un -1, el compilador puede devolver 1 en su lugar. Este tipo de suposiciones de compilador en C ++ o C son difíciles de detectar.

En cambio, la mejor manera es no mezclar el código de error con sus datos. Entonces la siguiente función.

char GetChar()

ahora se vuelve

// On success return 1 // on failure return 0 bool GetChar(int &char)

Esto significa que no importa cuán joven sea el desarrollador en su tienda de desarrollo, él o ella nunca lo entenderá mal. Aunque esto no está hablando de redudancy o dependies en el código.

Entonces, en general, intercambiar bool como el tipo de primera clase en el idioma está bien y creo que Joel habló de ello con su postcast reciente. Pero trate de no utilizar mix y match bools con sus datos en sus rutinas y debería estar perfectamente bien.

De la documentación en línea de PHP :

"* Para convertir explícitamente un valor a booleano, use los moldes (bool) o (booleanos). Sin embargo, en la mayoría de los casos el casteo es innecesario, ya que un valor se convertirá automáticamente si un operador, función o estructura de control requiere un argumento booleano Al convertir a booleano, los siguientes valores se consideran FALSO: * el booleano FALSO en sí * el entero 0 (cero) * el flotante 0.0 (cero) * la cadena vacía, y la cadena "0" * una matriz con cero elementos * un objeto con cero variables miembro (solo PHP 4) * el tipo especial NULL (incluidas las variables no configuradas) * Objetos SimpleXML creados a partir de etiquetas vacías Todos los demás valores se consideran VERDADERO (incluido cualquier recurso). * "

Entonces, en la mayoría de los casos, es lo mismo.

Por otro lado, el "===" y el "==" no son lo mismo. Regularmente, solo necesita el operador "igual". Para aclarar:

$a == $b //Equal. TRUE if $a is equal to $b. $a === $b //Identical. TRUE if $a is equal to $b, and they are of the same type.

Para obtener más información, consulte la página " Operadores de comparación " en los documentos en línea de PHP.

Espero que esto ayude.

En PHP depende de si está validando tipos:

( ( false !== 0 ) && ( false !== -1 ) && ( false == 0 ) && ( false == -1 ) && ( false !== null ) && ( false == null ) )

Técnicamente nulo es 0x00 pero en PHP ( null == 0x00 ) && ( null !== 0x00 ) .

0 es un valor entero.

En PHP puede usar operadores === y! == para verificar no solo si los valores son iguales sino también si sus tipos coinciden. Entonces, por ejemplo: 0 == false es true , pero 0 === false es false . Lo mismo vale para != Versus !== . También en caso de que compare null con los otros dos utilizando los operadores mencionados, espere resultados similares.

Ahora en PHP, esta calidad de valores generalmente se utiliza al devolver un valor que a veces puede ser 0 (cero), pero a veces puede ser que la función falle. En tales casos, en PHP, devuelve false y debe verificar estos casos utilizando el operador de identidad === . Por ejemplo, si está buscando una posición de una cadena dentro de la otra y está utilizando strpos() , esta función devolverá la posición numérica que puede ser 0 si la cadena se encuentra al principio, pero si la cadena es no encontrado en absoluto, entonces strpos() devolverá false y debes tener esto en cuenta cuando se trate del resultado.

Si va a utilizar la misma técnica en sus funciones, cualquiera que esté familiarizado con la biblioteca PHP estándar entenderá lo que está sucediendo y cómo comprobar si el valor devuelto es lo que se desea o si se produjo algún error durante el procesamiento. Lo mismo ocurre con los params de funciones, puedes procesarlos de forma diferente dependiendo de si son matrices o cadenas o no, y esta técnica también se usa en todo PHP, por lo que todos la obtendrán con bastante facilidad. Así que supongo que ese es el poder.

En casi todos los idiomas modernos, null se refiere lógicamente a punteros (o referencias) que no tienen un valor, o una variable que no se inicializa. 0 es el valor entero de cero, y falso es el valor booleano de, bueno, falso. Para complicar las cosas, en C, por ejemplo, null, 0 y false están representados de la misma manera. No sé cómo funciona en PHP.

Luego, para complicar más las cosas, las bases de datos tienen un concepto de nulo, lo que significa que falta o no es aplicable, y la mayoría de los lenguajes no tienen una forma directa de asignar un DBNull a su valor nulo. Hasta hace poco, por ejemplo, no había ninguna distinción entre un int que fuera nulo y que fuera cero, pero eso se cambió con ints que aceptan nulos.

Perdón por hacer que esto suene complicado. Es solo que este ha sido un punto difícil en los idiomas durante años, y hasta hace poco, no tenía una resolución clara en ningún lado. Las personas acostumbraban juntar las cosas o dejarlas en blanco o 0 representar valores nulos en la base de datos, lo que no siempre funciona muy bien.

Falso y 0 son conceptualmente similares, es decir, son isomorfos. 0 es el valor inicial para el álgebra de los números naturales, y False es el valor inicial para el álgebra de Boole.

En otras palabras, 0 se puede definir como el número que, cuando se agrega a un número natural, produce el mismo número:

x + 0 = x

Del mismo modo, False es un valor tal que una disyunción de este y cualquier otro valor tiene el mismo valor:

x || False = x

Null es conceptualmente algo totalmente diferente. Dependiendo del idioma, hay una semántica diferente para él, pero ninguno de ellos describe un "valor inicial" como Falso y 0 son. No hay álgebra para Null. Pertenece a variables, generalmente para indicar que la variable no tiene un valor específico en el contexto actual. En la mayoría de los idiomas, no hay operaciones definidas en Nulo, y es un error usar Nulo como un operando. En algunos idiomas, hay un valor especial llamado "inferior" en lugar de "nulo", que es un marcador de posición para el valor de un cálculo que no termina.

He escrito más extensamente sobre las implicaciones de NULL en otros lugares.

Las diferencias entre estos valores siempre se reducen a reglas detalladas específicas del idioma. Lo que aprendes para PHP no es necesariamente cierto para Python, Perl, C, etc. Aunque es valioso aprender las reglas para el / los idioma (s) con el que estás trabajando, confiar en ellos demasiado es pedir problemas . El problema surge cuando el próximo programador necesita mantener tu código y has utilizado alguna construcción que aprovecha algunos pequeños detalles de Nulo vs. Falso (por ejemplo). Su código debería verse correcto (y, a la inversa, el código incorrecto debería verse mal ).

Null se usa en bases de datos para representar "sin registro" o "sin información". Por lo tanto, es posible que tenga un campo de bits que describa "¿quiere este usuario que le enviemos correos electrónicos?", Donde Verdadero significa que sí, Falso significa que no quiere que le envíen nada, pero Nulo significa que no lo hace lo sé Pueden surgir a través de uniones externas y cosas por el estilo.

Las implicaciones lógicas de Null suelen ser diferentes: en algunos idiomas NULL no es igual a nada, por lo que si (a == NULL) siempre será falso.

Personalmente, siempre inicializaba un booleano en FALSE, y la inicialización de uno a NULL se vería un poco asqueroso (incluso en C, donde los dos son solo 0 ... simplemente una cosa de estilo).

Nulo no es nada, Falso es un poco, y 0 es (probablemente) 32 bits.

No es un experto en PHP, pero en algunos de los idiomas más modernos no son intercambiables. Extraño tener 0 y false ser intercambiable, pero con boolean como un tipo real, puede tener métodos y objetos asociados, así que eso es solo una compensación. Nulo es nulo, la ausencia de algo esencialmente.

Un hecho interesante sobre NULL en PHP: si establece una var igual a NULL, es lo mismo que si hubiera llamado a unset () en ella.

NULL significa esencialmente que una variable no tiene ningún valor asignado; falso es un valor booleano válido, 0 es un valor entero válido, y PHP tiene una conversión bastante fea entre 0, "0", "" y falso.

null es null . false es false . Triste pero cierto.

no hay mucha consistencia en PHP. los desarrolladores TRATAN de hacer que null signifique "desconocido" o "inexistente". pero a menudo False servirá como ''inexistente'' (por ejemplo, strrpos (''fail'', ''search'') devolverá falso, y no nulo)

a menudo verá que se usa nulo cuando ya están usando falso para algo. por ejemplo, filter_input () Devuelven falso si la variable falla el filtro. y nulo si la variable no existe (¿no existe significa que también falló el filtro? entonces ¿por qué incluso devolver nulo?!?)

php tiene la conveniencia de devolver datos en las funciones. y ofrecen a los desarrolladores un montón de todo tipo de estado de falla en lugar de los datos.

Y no hay una manera sensata en PHP para detectar datos (int, str, etc.) de fallas (falso, nulo)

casi siempre tienes que probar si === nulo o === falso, dependiendo de la función. o para ambos, en casos como filter_input () / filter_var ()

y aquí hay algo de diversión con malabares tipo. ni siquiera incluye matrices y objetos.

var_dump( 0<0 ); #bool(false) var_dump( 1<0 ); #bool(false) var_dump( -1<0 ); #bool(true) var_dump( false<0 ); #bool(false) var_dump( null<0 ); #bool(false) var_dump( ''''<0 ); #bool(false) var_dump( ''a''<0 ); #bool(false) echo "/n"; var_dump( !0 ); #bool(true) var_dump( !1 ); #bool(false) var_dump( !-1 ); #bool(false) var_dump( !false ); #bool(true) var_dump( !null ); #bool(true) var_dump( !'''' ); #bool(true) var_dump( !''a'' ); #bool(false) echo "/n"; var_dump( false == 0 ); #bool(true) var_dump( false == 1 ); #bool(false) var_dump( false == -1 ); #bool(false) var_dump( false == false ); #bool(true) var_dump( false == null ); #bool(true) var_dump( false == '''' ); #bool(true) var_dump( false == ''a'' ); #bool(false) echo "/n"; var_dump( null == 0 ); #bool(true) var_dump( null == 1 ); #bool(false) var_dump( null == -1 ); #bool(false) var_dump( null == false ); #bool(true) var_dump( null == null ); #bool(true) var_dump( null == '''' ); #bool(true) var_dump( null == ''a'' ); #bool(false) echo "/n"; $a=0; var_dump( empty($a) ); #bool(true) $a=1; var_dump( empty($a) ); #bool(false) $a=-1; var_dump( empty($a) ); #bool(false) $a=false; var_dump( empty($a) ); #bool(true) $a=null; var_dump( empty($a) ); #bool(true) $a=''''; var_dump( empty($a) ); #bool(true) $a=''a''; var_dump( empty($a)); # bool(false) echo "/n"; #new block suggested by @thehpi var_dump( null < -1 ); #bool(true) var_dump( null < 0 ); #bool(false) var_dump( null < 1 ); #bool(true) var_dump( -1 > true ); #bool(false) var_dump( 0 > true ); #bool(false) var_dump( 1 > true ); #bool(true) var_dump( -1 > false ); #bool(true) var_dump( 0 > false ); #bool(false) var_dump( 1 > true ); #bool(true)

Falso, nulo, nada, 0, indefinido , etc., etc.

Cada uno de estos tiene significados específicos que se correlacionan con conceptos reales. A veces, los significados múltiples se sobrecargan en una sola palabra clave o valor.

En C y C ++ , NULL , False y 0 están sobrecargados con el mismo valor. En C # son 3 conceptos distintos.

null o NULL generalmente indica una falta de valor, pero generalmente no especifica por qué. 0 indica el número natural cero y tiene equivalencia de tipo a 1, 2, 3, etc. y en los lenguajes que admiten conceptos separados de NULL debe tratar solo un número.

Falso indica que no es verdad. Y lo usó en valores binarios . No significa que no esté desarmado ni significa 0 . Simplemente indica uno de los dos valores binarios.

Nada puede indicar que el valor está configurado específicamente para no ser nada, lo que indica lo mismo que nulo, pero con intención.

No definido en algunos idiomas indica que aún no se ha establecido el valor porque ningún código ha especificado un valor real.