Je me souviens avoir lu il y a quelque temps sur les opérateurs logiques qui, dans le cas de OR, utiliser ||était mieux que or(ou vice versa).
Je devais juste l'utiliser dans mon projet quand il m'est revenu, mais je ne me souviens plus quel opérateur était recommandé ou si c'était même vrai.
Quel est le meilleur et pourquoi?
Réponses:
Il n'y a pas de «meilleur» mais le plus courant l'est ||. Ils ont une priorité différente et ||fonctionneraient comme on s'y attendrait normalement.
Voir aussi: Opérateurs logiques ( l'exemple suivant est pris à partir de 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 0revient 27pour moi.
orrenvoie également un booléen. Juste sa priorité est si faible qu'il semble parfois qu'il fasse autre chose. :) print 27 or 0imprimerait 27parce orqu'il arrive après print 27 . BTW, echon'est pas dupe - echo 27 or 0produirait 1.
Ils sont utilisés à des fins différentes et ont en fait des priorités d'opérateurs différentes. Les opérateurs &&et ||sont destinés aux conditions booléennes, tandis que andet orsont destinés au flux de contrôle.
Par exemple, ce qui suit est une condition booléenne:
if ($foo == $bar && $baz != $quxx) {Cela diffère du flux de contrôle:
doSomething() or die();die()La fonction sera appelée si doSomething()retournera falseou null? Et si doSomething()revient trueou rien?
doSomething()est évalué comme un booléen. S'il renvoie une valeur que PHP considère comme véridique ( true, une chaîne non vide, etc.), il n'appellera pas die().
La différence entre respectivement || et OR et && et AND est la priorité de l'opérateur :
$bool = FALSE || TRUE;($bool = (FALSE || TRUE))$boolestTRUE$bool = FALSE OR TRUE;(($bool = FALSE) OR TRUE)$boolestFALSE$bool = TRUE && FALSE;($bool = (TRUE && FALSE))$boolestFALSE$bool = TRUE AND FALSE;(($bool = TRUE) AND FALSE)$boolestTRUESource: http://wallstreetdeveloper.com/php-logical-operators/
Voici un exemple de code pour travailler avec des opérateurs logiques:
<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>
Je sais que c'est un vieux sujet mais quand même. Je viens de rencontrer le problème dans le code que je débogue au travail et peut-être que quelqu'un peut avoir un problème similaire ...
Disons que le code ressemble à ceci:
$positions = $this->positions() || [];Vous vous attendez (comme vous en avez l'habitude par exemple avec javascript) que lorsque $ this-> positions () retourne false ou null, $ positions est un tableau vide. Mais ce n'est pas le cas. La valeur est TRUE ou FALSE dépend de ce que renvoie $ this-> positions ().
Si vous avez besoin d'obtenir la valeur de $ this-> positions () ou un tableau vide, vous devez utiliser:
$positions = $this->positions() or [];ÉDITER:
L'exemple ci - dessus ne fonctionne pas comme prévu , mais la vérité est que , ||et orn'est pas la même chose ... Essayez ceci:
<?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";
Voici le résultat:
bool(false)
NULL
array(0) {
}
Donc, en fait, la troisième option ?:est la bonne solution lorsque vous souhaitez définir une valeur renvoyée ou un tableau vide.
$positions = $this->positions() ?: [];Testé avec PHP 7.2.1
$positions = $this->positions() ?? [];est probablement ce que vous voulez.
Il n'y a rien de mal ou de mieux, cela dépend juste de la priorité des opérateurs. Puisque ||a une priorité plus élevée que or, ||est donc principalement utilisé.
Certains langages utilisent le court-circuit, et d'autres utilisent une évaluation booléenne complète (si vous le savez, c'est similaire à la directive $Ben Pascal).
Explications:
function A(){
...Do something..
return true;
}
function B(){
...Do something..
return true;
}
if ( A() OR B() ) { .....Dans cet exemple, la fonction B()ne sera jamais exécutée. Puisque la fonction A()retourne TRUE, le résultat de l'instruction OR est connu de la première partie sans qu'il soit nécessaire d'évaluer la deuxième partie de l'expression.
Cependant avec ( A() || B() ), la seconde partie est toujours évaluée quelle que soit la valeur de la première.
Pour une programmation optimisée, vous devez toujours utiliser ORce qui est le plus rapide (sauf dans le cas où la première partie revient falseet la seconde partie doit en fait être évaluée).
||, Bne sera pas appelé. Les deux opérateurs font exactement la même chose, sauf que la priorité est différente.
$e = true || $x = 'foo'ne définira pas en$xraison d'un court-circuit, pas en raison d'une priorité plus élevée.