Null vs. Falso vs. 0 em PHP
https://stackoverflow.com/questions/137487
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Dizem-me que bons desenvolvedores podem local / utilizar a diferença entre Null e False e 0 e todas as outras boas entidades "nada".
O é a diferença, especificamente em PHP? Será que ela tem algo a ver com ===?
Solução
É de linguagem específica, mas em PHP:
Null significa " nada ". O var não foi inicializado.
False significa " não é verdade em um contexto booleano ". Usado para explicitamente mostrar que você está lidando com questões lógicas.
0 é um int . Nada a ver com o resto acima, usado para a matemática.
Agora, o que é complicado, é que em linguagens dinâmicas como PHP, todas elas têm um valor em um contexto booleano , que (em PHP) é False.
Se você testá-lo com ==, está testando o valor booleano, então você vai ter igualdade. Se você testá-lo com ===, ele vai testar o tipo, e você obterá a desigualdade.
Então, por que eles são úteis?
Bem, olhe para a função strrpos(). Ele retorna False se ele não encontrou nada, mas 0 se ele encontrou alguma coisa no início da cadeia!
<?php
// pitfall :
if (strrpos("Hello World", "Hello")) {
// never exectuted
}
// smart move :
if (strrpos("Hello World", "Hello") !== False) {
// that works !
}
?>
E, claro, se você lidar com estados:
Você quer fazer uma diferença entre DebugMode = False (definido como off), DebugMode = True (definido como ligado) e DebugMode = Null (não definido em tudo, vai levar a depuração difícil; -))
Outras dicas
null é null. false é false. Triste mas é verdade.
não há muita consistência no PHP. os desenvolvedores TRY para fazer meios nulos "Unkown" ou "não-existente". mas muitas vezes Falso servirá como 'inexistente' (por exemplo strrpos ( 'falha', 'search') irá retornar falso, e não nulo)
Você vai ver muitas vezes nula sendo usado quando eles já estão usando falsa para alguma coisa. por exemplo. filter_input (). Eles retornam false se a variável falhar o filtro. e nulo se a variável não existe (não meios existentes também falhou o filtro? então porque mesmo return null?!?)
php tem a conveniência de enviar dados nas funções. e ofter os desenvolvedores empinar em todo o tipo de estado de falha, em vez dos dados.
E Não há nenhuma maneira sã em PHP para detectar dados (int, str, etc) de falha (falsos, null)
Você praticamente tem que sempre teste para === === nulo ou falso, dependendo da função. ou por ambos, em casos tais como filter_input () / filter_var ()
e aqui está um pouco de diversão com o tipo de malabarismo. nem mesmo incluindo matrizes e 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)
Abaixo está um exemplo:
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
Por favor, veja isso há mais de referência do tipo comparações em PHP. Deve dar-lhe uma compreensão clara.
No PHP você pode usar === e! == operadores de verificar não só se os valores são iguais, mas também se os seus tipos de correspondência. Assim, por exemplo: 0 == false é true, mas 0 === false é false. O mesmo vale para != contra !==. Também no caso de você comparar null aos outros dois usando os operadores mencionados, esperar resultados semelhantes.
Agora, em PHP esta qualidade de valores é geralmente usado quando retornar um valor que por vezes pode ser 0 (zero), mas às vezes pode ser que a função falhou. Em tais casos em PHP você retornar false e você tem que verificar esses casos usando o === operador de identidade. Por exemplo, se você está procurando uma posição de uma corda dentro do outro e você estiver usando strpos(), esta função irá retornar a posição numérica que pode ser 0 se a string é encontrado no início, mas se a cadeia não é encontrado em tudo, então strpos() voltará false e você tem que levar isso em conta quando se lida com o resultado.
Se você vai usar a mesma técnica em suas funções, qualquer um familiarizado com a biblioteca PHP padrão vai entender o que está acontecendo e como verificar se o valor devolvido é o que se deseja ou fez algum erro ocorrer durante o processamento. O mesmo vai realmente para params função, você pode processá-los de forma diferente, dependendo se eles são arrays ou strings ou não o que, e esta técnica é utilizada em todo PHP fortemente também, então todo mundo vai obtê-lo com bastante facilidade. Então eu acho que é o poder.
Falso, Null, Nada, 0, Undefined , etc., etc.
Cada um deles tem significados específicos que se correlacionam com os conceitos reais. Às vezes, vários significados estão sobrecarregados em uma única palavra-chave ou valor.
NULL, False e 0 estão sobrecarregados com o mesmo valor.
Em C # Eles são 3 conceitos distintos.
null ou NULL geralmente indica uma falta de valor, mas geralmente não especifica o porquê.
0 indica o número zero natural e tem tipo-equivalência a NULL só deve ser tratada um número.
false indica não-verdade. E que seja usado em valores binários . Isso não significa que não definido, nem 0 média. Ele simplesmente indica um dos dois valores binários.
Nada pode indicar que o valor é especificamente definido para ser nada que indica a mesma coisa que nulo, mas com intenção.
Undefined em algumas línguas indica que o valor ainda não foi definido porque nenhum código tenha especificado um valor real.
acabo desperdiçado um dia 1/2 tentando obter tanto um 0, null, false para retornar de strops!
Aqui está tudo o que eu estava tentando fazer, antes que eu encontrei que a lógica não estava fluindo na direção certa, parecendo que havia um buraco negro em php codificação:
Conceito ter um nome de domínio hospedado em um servidor, e certifique-se que não é nível de raiz, OK várias maneiras diferentes de fazer isso, mas eu escolhi diferente devido a outras funções PHP / constrói eu fiz.
De qualquer forma aqui foi a base do Cosing:
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, depois de ler este tópico, Descobri que isso funcionou !!!
{
if ((mydomain.co.uk, mydomain)) !== false )
{
echo "\n5 is True";
} else {
echo "\n5 is False";
}
}
Obrigado por este artigo, agora eu entendo que mesmo que é Natal, pode não ser o Natal como false, como também pode ser um dia NULL!
Depois de desperdiçar um dia de depuração algum código simples, gostaria de ter conhecido isso antes, como eu teria sido capaz de identificar o problema, ao invés de ir por todo o lugar tentando fazê-lo funcionar. Não funcionou, como False, NULL e 0 não são todos o mesmo que True or False or NULL?
A partir da PHP documentação on-line :
Para converter explicitamente um valor para booleano, utilize o (bool) ou moldes (booleano).
No entanto, na maioria dos casos, o elenco é unncecessary, já que um valor será convertido automaticamente se uma estrutura do operador, função ou controle requerer um argumento booleano.
Quando convertendo para booleano, os seguintes valores são considerados FALSE:
- o boolean si
FALSE - o número inteiro `` 0 (zero)
- o
0.0float (zero) - a cadeia vazia, eo
"0"corda - uma matriz com zero elementos
- um objecto sem elementos membros (PHP 4 apenas)
- o tipo
NULLespecial (incluindo variáveis ??não definidas) - SimpleXML objetos criados a partir de tags vazias
Qualquer outro valor é consideradoTRUE(incluindo qualquer recurso).
Assim, na maioria dos casos, é o mesmo.
Por outro lado, o === eo ==are não é a mesma coisa. Regularmente, você só precisa do operador "iguais". Para esclarecer:
$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 obter mais informações, consulte a " Operadores de Comparação "página na documentação on-line do PHP.
Espero que isso ajude.
As diferenças entre esses valores sempre vir para baixo a normas específicas do idioma. O que você aprende para PHP não é necessariamente verdade para Python ou Perl ou C, etc. Embora seja valioso para aprender as regras para a língua (s) que você está trabalhando, confiando neles demasiado está pedindo para ter problemas . O problema surge quando os próximos necessidades programador para manter seu código e você já usou alguma construção que tira proveito de algum pequeno detalhe de Null vs. False (por exemplo). O código deve ser correcta (e, inversamente, o código errado deve olhar errado ).
Null é usado em bancos de dados para representar "nenhum registro" ou "sem informação". Então você pode ter um campo de bits que descreve "faz isso o usuário deseja ser enviado e-mails por nós", onde a verdadeira significa que eles, False significa que eles não querem ser enviados nada, mas Null significa que você don' t sabe. Eles podem vir através de junções externas e afins.
As implicações lógicas de Null são muitas vezes diferentes - em alguns idiomas NULL não é igual a nada, por isso, se (a NULL ==) será sempre false
.Assim, pessoalmente, eu sempre inicialize um booleano para FALSE, e um inicializar para NULL ficaria um pouco icky (mesmo em C onde os dois ficam apenas 0 ... apenas uma coisa estilo).
Eu acho que os desenvolvedores ruins encontrar todos os usos diferentes de nulo / 0 / false lá código.
Por exemplo, um dos mais erros comuns programadores fazer é devolver o código de erro na forma de dados com uma função.
// On error GetChar returns -1
int GetChar()
Este é um exemplo de uma interface de açúcar. Esta é exsplained no livro "debuging o proccess desenvolvimento de software" e também em outro livro "escrever código correto".
O problema com isso, é a implicação ou suposições feitas sobre o tipo char. Em alguns compiladores do tipo char pode ser não-assinado. Assim, mesmo que você retornar uma -1 o compilador pode retornar 1 vez. Este tipo de suposições do compilador em C ++ ou C são difíceis de detectar.
Em vez disso, a melhor maneira é não misturar código de erro com seus dados. Portanto, a seguinte função.
char GetChar()
torna-se agora
// On success return 1
// on failure return 0
bool GetChar(int &char)
Isto significa que não importa quão jovem o desenvolvedor está na sua loja de desenvolvimento, ele ou ela nunca vai conseguir isso errado. Embora este não está falando sobre redudancy ou dependies no código.
Assim, em geral, trocando bool como o primeiro tipo de classe na língua está bem e eu acho que Joel falou sobre isso com sua recente PostCast. Mas tente não usar misturar e combinar bools com seus dados em suas rotinas e você deve estar perfeitamente bem.
Em PHP que depende de se você está validando tipos:
(
( false !== 0 ) && ( false !== -1 ) && ( false == 0 ) && ( false == -1 ) &&
( false !== null ) && ( false == null )
)
Tecnicamente nula é 0x00 mas em PHP ( null == 0x00 ) && ( null !== 0x00 ).
0 é um valor inteiro.
Um fato interessante sobre NULL em PHP: Se você definir uma var igual a NULL, é o mesmo que se você tivesse chamado unset() nele
NULL significa, essencialmente, uma variável não tem valor atribuído a ele; false é um valor booleano válido, 0 é um valor inteiro válido, e PHP tem algumas conversões bastante feias entre 0, "0", "" e false.
Null não é nada, False é um pouco, e 0 é (provavelmente) de 32 bits.
Não é um especialista em PHP, mas em algumas das línguas mais modernas aqueles que não são intercambiáveis. I tipo de perder ter 0 e falso ser intercambiáveis, mas com boolean ser um tipo real você pode ter métodos e objetos associados a ele para que é apenas uma troca. Null é nulo, porém, a ausência de essencialmente nada.
Bem, eu não me lembro o suficiente dos meus tempos de PHP para responder à "===" parte, mas para a maioria das linguagens de estilo C, NULL deve ser utilizada no contexto de valores de ponteiro, falso como um booleano, e zero como um valor numérico, tal como um int. '\ 0' é o valor habitual para um contexto personagem. Normalmente, eu também prefiro usar 0,0 para carros alegóricos e duplos.
Então .. A resposta rápida é:. Contexto
Em praticamente todas as línguas modernas, null logicamente refere-se a ponteiros (ou referências) não ter um valor ou uma variável que não é inicializado. 0 é o valor inteiro do zero, e falso é o valor booleano de, bem, falsa. Para tornar as coisas complicadas, em C, por exemplo, null, 0, e falso são todos representados da mesma maneira. Eu não sei como ele funciona em PHP.
Depois, para as coisas complicar mais, bases de dados têm um conceito de null, o que significa ausentes ou não aplicáveis, ea maioria das línguas não têm uma maneira direta para mapear um DBNull ao seu nulo. Até recentemente, por exemplo, não havia distinção entre um int sendo nula e ser zero, mas isso foi mudado com ints anuláveis.
Desculpe fazer este som complicado. É só que este tem sido um ponto de discórdia harry em línguas durante anos, e até recentemente, não teve qualquer lugar resolução clara. As pessoas costumavam apenas kludge coisas juntos ou fazer em branco ou 0 representam valores nulos no banco de dados, o que nem sempre funciona muito bem.
Falso e 0 são conceitualmente semelhante, ou seja, eles são isomorfos. 0 é o valor inicial para a álgebra dos números naturais, e False é o valor inicial para a álgebra booleana.
Em outras palavras, 0 pode ser definido como o número que, quando adicionado a um número natural, os rendimentos que mesmo número:
x + 0 = x
Da mesma forma, False é um valor tal que uma disjunção dele e qualquer outro valor é esse mesmo valor:
x || False = x
Null é conceitualmente algo totalmente diferente. Dependendo do idioma, existem diferentes semântica para ele, mas nenhum deles descrever um "valor inicial" como falso e 0 são. Não há álgebra para Null. Ele refere-se a variáveis, normalmente para indicar que a variável não tem qualquer valor específico no contexto actual. Na maioria das linguagens, não há operações definidas em Null, e é um erro usar nulo como um operando. Em algumas línguas, existe um valor especial chamado "fundo" em vez de "null", que é um espaço reservado para o valor de um cálculo que não termina.
Eu tenho escrito mais amplamente sobre as implicações de NULL em outro lugar.
Alguém pode me explicar por que 'NULL' não é apenas uma corda em uma instância de comparação?
$x = 0;
var_dump($x == 'NULL'); # TRUE !!!WTF!!!
Os problemas com falsyness vem da história PHP. O problema tem como alvo o tipo escalar não é bem definido.
'*' == true -> true (string match)
'*' === true -> false (numberic match)
(int)'*' == true -> false
(string)'*' == true -> true
PHP7 rigor é um passo em frente, mas talvez não o suficiente. https://web-techno.net/typing -com-php-7-que-você-should-fazer /
