Null vs. False vs. 0 in PHP
https://stackoverflow.com/questions/137487
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Mi è stato detto che i buoni sviluppatori possono individuare / utilizzare la differenza tra Null e False e 0 e tutti gli altri buoni " niente " ; entità.
Qual è qual è la differenza, in particolare in PHP? Ha qualcosa a che fare con === ?
Soluzione
È specifico della lingua, ma in PHP:
Null significa " niente " ;. Il var non è stato inizializzato.
False significa " non vero in un contesto booleano " ;. Utilizzato per mostrare esplicitamente che hai a che fare con problemi logici.
0 è un int . Niente a che fare con il resto sopra, usato per la matematica.
Ora, ciò che è difficile, è che in linguaggi dinamici come PHP, tutti hanno un valore in un contesto booleano , che (in PHP) è False .
Se lo provi con == , sta testando il valore booleano, quindi otterrai l'uguaglianza. Se lo provi con === , testerà il tipo e otterrai disuguaglianza.
Quindi perché sono utili?
Bene, guarda la funzione strrpos () . Restituisce False se non ha trovato nulla, ma 0 se ha trovato qualcosa all'inizio della stringa!
<?php
// pitfall :
if (strrpos("Hello World", "Hello")) {
// never exectuted
}
// smart move :
if (strrpos("Hello World", "Hello") !== False) {
// that works !
}
?>
E ovviamente, se hai a che fare con gli stati:
Volete fare la differenza tra DebugMode = False (impostato su off), DebugMode = True (impostato su on) e DebugMode = Null (non impostato affatto, porterà a un intenso debug ;-)).
Altri suggerimenti
null è null . false è false . Triste ma vero.
non c'è molta coerenza in PHP. gli sviluppatori PROVA per rendere nulli mezzi "sconosciuti" o "inesistente". ma spesso False fungerà da "inesistente" (ad es. strrpos ("fail", "search") restituirà false e non null)
vedrai spesso null essere usato quando stanno già usando false per qualcosa. per esempio. filter_input (). Restituiscono false se la variabile non riesce al filtro. e null se la variabile non esiste (non esiste significa che ha anche fallito il filtro? quindi perché anche restituire null?!?)
php ha la comodità di restituire i dati nelle funzioni. e spesso gli sviluppatori stipano tutti i tipi di stato di errore anziché i dati.
E non c'è modo ragionevole in PHP di rilevare dati (int, str, ecc.) da errori (false, null)
praticamente devi sempre testare === null o === false, a seconda della funzione. o per entrambi, in casi come filter_input () / filter_var ()
ed ecco un po 'di divertimento con il tipo giocoleria. nemmeno includendo matrici e oggetti.
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)
Di seguito è riportato un esempio:
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
Si prega di consultare questo per ulteriori riferimenti di confronti di tipi in PHP. Dovrebbe darti una chiara comprensione.
In PHP puoi usare gli operatori === e! == per verificare non solo se i valori sono uguali ma anche se i loro tipi corrispondono. Ad esempio, 0 == false è true , ma 0 === false è false . Lo stesso vale per ! = contro ! == . Inoltre, nel caso in cui si confronti null con gli altri due utilizzando gli operatori citati, si aspettano risultati simili.
Ora in PHP questa qualità di valori viene solitamente utilizzata quando si restituisce un valore che a volte può essere 0 (zero), ma a volte potrebbe non funzionare la funzione. In tali casi in PHP restituisci false e devi verificare questi casi utilizzando l'operatore di identità === . Ad esempio, se stai cercando una posizione di una stringa all'interno dell'altra e stai usando strpos () , questa funzione restituirà la posizione numerica che può essere 0 se la stringa viene trovata proprio all'inizio, ma se la stringa non viene trovata affatto, strpos () restituirà false e devi tenerne conto quando ti occupi del risultato.
Se utilizzerai la stessa tecnica nelle tue funzioni, chiunque abbia familiarità con la libreria PHP standard capirà cosa sta succedendo e come verificare se il valore restituito è ciò che si desidera o si è verificato un errore durante l'elaborazione. Lo stesso vale per i parametri di funzione, puoi elaborarli in modo diverso a seconda che siano array o stringhe o cosa no, e questa tecnica viene utilizzata anche in tutto il PHP pesantemente, quindi tutti lo capiranno abbastanza facilmente. Quindi immagino sia questo il potere.
False, Null, Nothing, 0, Undefined , ecc. ecc.
Ognuno di questi ha significati specifici correlati con concetti reali. A volte più significati sono sovraccaricati in una singola parola chiave o valore.
In C e C ++ , NULL , False e 0 sono sovraccarichi allo stesso valore.
In C # sono 3 concetti distinti.
null o NULL di solito indica una mancanza di valore, ma di solito non specifica il perché.
0 indica il numero naturale zero e ha equivalenza di tipo a 1, 2, 3, ecc. e in lingue che supportano concetti separati di NULL dovrebbe essere trattato solo un numero.
Falso indica non verità. E utilizzato in valori binari . Non significa disinserito, né 0 . Indica semplicemente uno dei due valori binari.
Nulla può indicare che il valore è specificamente impostato per essere nulla che indica la stessa cosa di null, ma con intento.
Non definito in alcune lingue indica che il valore deve ancora essere impostato perché nessun codice ha specificato un valore effettivo.
Ho appena sprecato 1/2 al giorno cercando di ottenere 0 , null , false per tornare da ritagli
Ecco tutto quello che stavo cercando di fare, prima di scoprire che la logica non scorreva nella giusta direzione, sembrando che ci fosse un buco nero nella codifica php:
Concetto prendere un nome di dominio ospitato su un server e assicurarsi che non sia a livello di root, OK diversi modi per farlo, ma ho scelto diversi a causa di altre funzioni / costrutti php che ho fatto.
Comunque qui è stata la base della cosing:
if (strpos( Ho appena sprecato 1/2 al giorno cercando di ottenere 0 , null , false per tornare da ritagli
Ecco tutto quello che stavo cercando di fare, prima di scoprire che la logica non scorreva nella giusta direzione, sembrando che ci fosse un buco nero nella codifica php:
Concetto
prendere un nome di dominio ospitato su un server e assicurarsi che non sia a livello di root, OK diversi modi per farlo, ma ho scelto diversi a causa di altre funzioni / costrutti php che ho fatto.
Comunque qui è stata la base della cosing:
{
if ((mydomain.co.uk, mydomain)) !== false )
{
echo "\n5 is True";
} else {
echo "\n5 is False";
}
}
FINALMENTE dopo aver letto questo argomento,
Ho scoperto che ha funzionato !!!
<*>
Grazie per questo articolo, ora capisco che anche se è Natale, potrebbe non essere Natale come false , poiché può anche essere un giorno NULL !
Dopo aver perso una giornata di debug di alcuni semplici codici, avrei voluto saperlo prima, dato che avrei potuto identificare il problema, piuttosto che andare ovunque cercando di farlo funzionare. Non ha funzionato, poiché False , NULL e 0 non sono tutti uguali a True o False o NULL ?
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 dopo aver letto questo argomento, Ho scoperto che ha funzionato !!!
<*> Grazie per questo articolo, ora capisco che anche se è Natale, potrebbe non essere Natale come false , poiché può anche essere un giorno NULL !
Dopo aver perso una giornata di debug di alcuni semplici codici, avrei voluto saperlo prima, dato che avrei potuto identificare il problema, piuttosto che andare ovunque cercando di farlo funzionare. Non ha funzionato, poiché False , NULL e 0 non sono tutti uguali a True o False o NULL ?
Dalla Documentazione online PHP :
Per convertire esplicitamente un valore in booleano, usa i cast (boolean) o (boolean).
Tuttavia, nella maggior parte dei casi il cast non è necessario, poiché un valore verrà automaticamente convertito se un operatore, una funzione o una struttura di controllo richiedono un argomento booleano.
Quando si converte in booleano, i seguenti valori sono considerati FALSE:
- il
FALSObooleano stesso - l'intero `` 0 (zero)
- il float
0.0(zero) - la stringa vuota e la stringa
" 0 " - un array con zero elementi
- un oggetto con zero variabili membro (solo PHP 4)
- il tipo speciale
NULL(comprese le variabili non impostate) - Oggetti SimpleXML creati da tag vuoti
Ogni altro valore è consideratoTRUE(inclusa qualsiasi risorsa).
Quindi, nella maggior parte dei casi, è lo stesso.
D'altra parte, === e == non sono la stessa cosa. Regolarmente, hai solo bisogno di " uguale a " operatore. Per chiarire:
$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.
Per ulteriori informazioni, controlla " Operatori di confronto " pagina nei documenti online di PHP.
Spero che questo aiuti.
Le differenze tra questi valori dipendono sempre da regole dettagliate specifiche della lingua. Ciò che impari per PHP non è necessariamente vero per Python, o Perl, o C, ecc. Mentre è utile imparare le regole per la lingua o le lingue con cui stai lavorando, fare troppo affidamento su di esse è chiedere problemi . Il problema sorge quando il prossimo programmatore deve mantenere il tuo codice e hai usato un costrutto che sfrutta alcuni piccoli dettagli di Null vs. False (ad esempio). Il codice dovrebbe apparire corretto (e viceversa, il codice errato dovrebbe apparire errato ).
Null viene utilizzato nei database per rappresentare " nessun record " o "nessuna informazione". Quindi potresti avere un piccolo campo che descrive " questo utente desidera che vengano inviate e-mail da noi " ;, dove True significa che lo fanno, False significa che non vogliono essere inviato nulla, ma Null significherebbe che tu non lo so. Possono verificarsi attraverso join esterni e simili.
Le implicazioni logiche di Null sono spesso diverse - in alcune lingue NULL non è uguale a nulla, quindi se (a == NULL) sarà sempre falso.
Quindi personalmente inizializzerei sempre un booleano su FALSE, e inizializzarne uno su NULL sembrerebbe un po 'icky (anche in C dove i due sono entrambi solo 0 ... solo una cosa di stile).
Penso che i cattivi sviluppatori trovino tutti i diversi usi di null / 0 / false nel codice lì.
Ad esempio, uno degli errori più comuni che gli sviluppatori commettono è quello di restituire il codice di errore sotto forma di dati con una funzione.
// On error GetChar returns -1
int GetChar()
Questo è un esempio di un'interfaccia Sugar. Questo è spiegato nel libro "Debug del processo di sviluppo software" e anche in un altro libro "scrivendo il codice corretto".
Il problema con questo, è l'implicazione o le ipotesi fatte sul tipo di carattere. Su alcuni compilatori il tipo di carattere può essere non firmato. Quindi anche se si restituisce un -1, il compilatore può invece restituire 1. Questo tipo di ipotesi del compilatore in C ++ o C sono difficili da individuare.
Invece, il modo migliore è non mescolare il codice di errore con i tuoi dati. Quindi la seguente funzione.
char GetChar()
ora diventa
// On success return 1
// on failure return 0
bool GetChar(int &char)
Ciò significa che non importa quanto sia giovane lo sviluppatore nel tuo negozio di sviluppo, non sbaglierà mai. Anche se non si tratta di ridondanza o dipendenze nel codice.
Quindi, in generale, scambiare bool come il primo tipo di classe nella lingua va bene e penso che Joel ne abbia parlato con il suo recente postcast. Ma cerca di non usare i bool mix and match con i tuoi dati nelle tue routine e dovresti stare perfettamente.
In PHP dipende se stai convalidando i tipi:
(
( false !== 0 ) && ( false !== -1 ) && ( false == 0 ) && ( false == -1 ) &&
( false !== null ) && ( false == null )
)
Tecnicamente null è 0x00 ma in PHP (null == 0x00) & amp; & amp; (null! == 0x00) .
0 è un valore intero.
Un fatto interessante su NULL in PHP: se hai impostato una var uguale a NULL , è lo stesso che se avessi chiamato unset () su di esso.
NULL essenzialmente significa che una variabile non ha alcun valore assegnato ad essa; false è un valore booleano valido, 0 è un valore intero valido e PHP ha conversioni abbastanza brutte tra 0 , " 0 " , " " e false .
Null è nulla, False è un po 'e 0 è (probabilmente) 32 bit.
Non un esperto di PHP, ma in alcune delle lingue più moderne non sono intercambiabili. Mi manca un po 'avere 0 e false essere intercambiabili, ma con il booleano un tipo reale puoi avere metodi e oggetti associati ad esso, quindi questo è solo un compromesso. Null è nulla, l'assenza di qualcosa essenzialmente.
Beh, non ricordo abbastanza dei miei giorni in PHP per rispondere a " === " parte, ma per la maggior parte dei linguaggi in stile C, NULL deve essere utilizzato nel contesto dei valori del puntatore, false come valore booleano e zero come valore numerico come int. '\ 0' è il valore abituale per un contesto di carattere. Di solito preferisco anche usare 0.0 per float e double.
Quindi ... la risposta rapida è: contesto.
In quasi tutte le lingue moderne, null logicamente si riferisce a puntatori (o riferimenti) che non hanno un valore o a una variabile che non è inizializzata. 0 è il valore intero di zero e false è il valore booleano di, beh, falso. Per complicare le cose, in C, ad esempio, null, 0 e false sono tutti rappresentati esattamente allo stesso modo. Non so come funzioni in PHP.
Quindi, per complicare ulteriormente le cose, i database hanno un concetto di null, il che significa che manca o non è applicabile, e la maggior parte delle lingue non ha un modo diretto per mappare un DBNull al loro null. Fino a poco tempo fa, ad esempio, non c'era distinzione tra un int che era nullo e uno zero, ma ciò è stato modificato con ints nullable.
Mi dispiace rendere complicato questo suono. È solo che questo è stato un punto critico nelle lingue per anni e fino a poco tempo fa non ha avuto una chiara risoluzione da nessuna parte. Le persone solevano semplicemente raggruppare le cose insieme o rendere vuoti o 0 rappresentare null nel database, che non sempre funziona troppo bene.
False e 0 sono concettualmente simili, ovvero sono isomorfi. 0 è il valore iniziale per l'algebra dei numeri naturali e False è il valore iniziale per l'algebra booleana.
In altre parole, 0 può essere definito come il numero che, se aggiunto a un numero naturale, produce lo stesso numero:
x + 0 = x
Allo stesso modo, False è un valore tale che una sua disgiunzione e qualsiasi altro valore ha lo stesso valore:
x || False = x
Null è concettualmente qualcosa di completamente diverso. A seconda della lingua, esistono diverse semantiche, ma nessuna di esse descrive un "valore iniziale". come False e 0 sono. Non esiste algebra per Null. Riguarda le variabili, di solito per indicare che la variabile non ha alcun valore specifico nel contesto corrente. Nella maggior parte delle lingue, non ci sono operazioni definite su Null ed è un errore utilizzare Null come operando. In alcune lingue, esiste un valore speciale chiamato " bottom " piuttosto che "null", che è un segnaposto per il valore di un calcolo che non termina.
Ho scritto più ampiamente sulle implicazioni di NULL altrove.
Qualcuno può spiegarmi perché 'NULL' non è solo una stringa in un'istanza di confronto?
$x = 0;
var_dump($x == 'NULL'); # TRUE !!!WTF!!!
I problemi con la falsità provengono dalla storia di PHP. Il problema riguarda il tipo scalare non ben definito.
'*' == true -> true (string match)
'*' === true -> false (numberic match)
(int)'*' == true -> false
(string)'*' == true -> true
La severità di PHP7 è un passo avanti, ma forse non abbastanza. https://web-techno.net/typing -con-php-7-what-you-shouldnt-do /
