Ricordo di aver letto qualche tempo fa riguardo agli operatori logici che, nel caso di OR, usare ||era meglio di or(o viceversa).
Dovevo solo usarlo nel mio progetto quando mi è tornato in mente, ma non ricordo quale operatore fosse consigliato o se fosse anche vero.
Quale è meglio e perché?
Risposte:
Non esiste un "migliore" ma il più comune lo è ||. Hanno una precedenza diversa e ||funzionerebbero come ci si aspetterebbe normalmente.
Vedi anche: Operatori logici ( il seguente esempio è preso da lì ):
// The result of the expression (false || true) is assigned to $e
// Acts like: ($e = (false || true))
$e = false || true;
// The constant false is assigned to $f and then true is ignored
// Acts like: (($f = false) or true)
$f = false or true;27 or 0ritorna 27per me.
orrestituisce anche booleano. Solo la sua precedenza è così bassa che a volte sembra che faccia qualcos'altro. :) print 27 or 0verrebbe stampato 27perché oraccade dopo print 27 . BTW, echonon si lascia ingannare - echo 27 or 0sarebbe uscita 1.
Sono utilizzati per scopi diversi e infatti hanno precedenza di operatori diversi. Gli operatori &&e ||sono destinati alle condizioni booleane, mentre ande orsono destinati al flusso di controllo.
Ad esempio, la seguente è una condizione booleana:
if ($foo == $bar && $baz != $quxx) {Questo differisce dal flusso di controllo:
doSomething() or die();die()verrà chiamata la funzione se doSomething()tornerà falseo null? E se doSomething()ritorni trueo niente?
doSomething()viene valutato come booleano. Se restituisce un valore che PHP considera veritiero ( true, una stringa non vuota, ecc.), Non chiamerà die().
La differenza tra rispettivamente || e OR e && e AND è la precedenza dell'operatore :
$bool = FALSE || TRUE;($bool = (FALSE || TRUE))$boolèTRUE$bool = FALSE OR TRUE;(($bool = FALSE) OR TRUE)$boolèFALSE$bool = TRUE && FALSE;($bool = (TRUE && FALSE))$boolèFALSE$bool = TRUE AND FALSE;(($bool = TRUE) AND FALSE)$boolèTRUEFonte: http://wallstreetdeveloper.com/php-logical-operators/
Ecco un esempio di codice per lavorare con gli operatori logici:
<html>
<head>
<title>Logical</title>
</head>
<body>
<?php
$a = 10;
$b = 20;
if ($a>$b)
{
echo " A is Greater";
}
elseif ($a<$b)
{
echo " A is lesser";
}
else
{
echo "A and B are equal";
}
?>
<?php
$c = 30;
$d = 40;
//if (($a<$c) AND ($b<$d))
if (($a<$c) && ($b<$d))
{
echo "A and B are larger";
}
if (isset($d))
$d = 100;
echo $d;
unset($d);
?>
<?php
$var1 = 2;
switch($var1)
{
case 1: echo "var1 is 1";
break;
case 2: echo "var1 is 2";
break;
case 3: echo "var1 is 3";
break;
default: echo "var1 is unknown";
}
?>
</body>
</html>So che è un vecchio argomento ma ancora. Ho appena incontrato il problema nel codice che sto eseguendo il debug al lavoro e forse qualcuno potrebbe avere un problema simile ...
Diciamo che il codice ha questo aspetto:
$positions = $this->positions() || [];Ti aspetteresti (come sei abituato ad esempio da javascript) che quando $ this-> position () restituisce false o null, $ position è un array vuoto. Ma non lo è. Il valore è TRUE o FALSE dipende da cosa restituisce $ this-> position ().
Se hai bisogno di ottenere il valore di $ this-> position () o un array vuoto, devi usare:
$positions = $this->positions() or [];MODIFICARE:
L'esempio sopra non funziona come previsto, ma la verità è che ||e ornon è la stessa ... Prova questo:
<?php
function returnEmpty()
{
//return "string";
//return [1];
return null;
}
$first = returnEmpty() || [];
$second = returnEmpty() or [];
$third = returnEmpty() ?: [];
var_dump($first);
var_dump($second);
var_dump($third);
echo "\n";Questo è il risultato:
bool(false)
NULL
array(0) {
}Quindi, in realtà la terza opzione ?:è la soluzione corretta quando si desidera impostare il valore restituito o un array vuoto.
$positions = $this->positions() ?: [];Testato con PHP 7.2.1
$positions = $this->positions() ?? [];è probabilmente quello che vuoi.
Non c'è niente di male o meglio, dipende solo dalla precedenza degli operatori. Poiché ||ha una precedenza maggiore di or, quindi ||viene utilizzato principalmente.
Alcuni linguaggi usano il cortocircuito e altri usano la valutazione booleana completa (se lo sai, questo è simile alla direttiva $Bin Pascal).
spiegazioni:
function A(){
...Do something..
return true;
}
function B(){
...Do something..
return true;
}
if ( A() OR B() ) { .....In questo esempio la funzione B()non verrà mai eseguita. Poiché la funzione A()restituisce TRUE, il risultato dell'istruzione OR è noto dalla prima parte senza che sia necessario valutare la seconda parte dell'espressione.
Tuttavia con ( A() || B() ), la seconda parte viene sempre valutata indipendentemente dal valore della prima.
Per una programmazione ottimizzata, dovresti sempre usare ORquale è più veloce (tranne il caso in cui la prima parte ritorna falsee la seconda parte deve essere effettivamente valutata).
||, Bnon verrà chiamato. Entrambi gli operatori fanno esattamente lo stesso, tranne per il fatto che la precedenza è diversa.
$e = true || $x = 'foo'non definirà a$xcausa del cortocircuito, non a causa di una precedenza più elevata.