Opérateurs logiques, || ou ou?

StackOverflow https://stackoverflow.com/questions/5998309

Question

Je me souviens avoir lu il y a quelque temps des opérateurs logiques qui, dans le cas de OR, en utilisant || était mieux que or (ou vice versa).

J'ai juste dû l'utiliser dans mon projet quand il m'est revenu mais je ne me souviens pas quel opérateur a été recommandé ni si c'était même vrai.

Quel est le meilleur et pourquoi ?

Était-ce utile?

La solution

Il n'y a pas de "meilleur" mais le plus courant est ||.Ils ont différents priorité et || fonctionnerait comme on pourrait s’y attendre normalement.

Voir également: Opérateurs logiques (l'exemple suivant est tiré 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;

Autres conseils

Ils sont utilisés à des fins différentes et ont en fait des priorités d'opérateur différentes.Le && et || les opérateurs sont destinés aux conditions booléennes, alors que and et or sont destinés au contrôle du flux.

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();

La différence entre respectivement || et ou && et et est priorité des opérateurs :

$bool = FALSE || TRUE;

  • interprété comme ($bool = (FALSE || TRUE))
  • valeur de $bool est TRUE

$bool = FALSE OR TRUE;

  • interprété comme (($bool = FALSE) OR TRUE)
  • valeur de $bool est FALSE

$bool = TRUE && FALSE;

  • interprété comme ($bool = (TRUE && FALSE))
  • valeur de $bool est FALSE

$bool = TRUE AND FALSE;

  • interprété comme (($bool = TRUE) AND FALSE)
  • valeur de $bool est TRUE

Source: http://bit.ly/1hxdmvr

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 pourrait avoir un problème similaire...

Disons que le code ressemble à ceci :

$positions = $this->positions() || [];

Vous vous attendez (comme vous en avez l'habitude par ex.javascript) que lorsque $this->positions() renvoie false ou null, $positions est un tableau vide.Mais ce n'est pas le cas.La valeur est VRAI ou FAUX dépend de ce que $this->positions() renvoie.

Si vous avez besoin d'obtenir la valeur de $this->positions() ou un tableau vide, vous devez utiliser :

$positions = $this->positions() or [];

MODIFIER:

L'exemple ci-dessus ne fonctionne pas comme prévu mais la vérité est que || et or ce n'est pas la même chose...Essaye ça:

<?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 la valeur renvoyée ou un tableau vide.

$positions = $this->positions() ?: [];

Testé avec PHP 7.2.1

Je ne pense pas que l'on est intrinsèquement meilleur qu'un autre, mais je suggérerais de coller avec ||parce que c'est la valeur par défaut dans la plupart des langues.

EDIT: Comme d'autres ont souligné, il y a en effet une différence entre les deux.

Il n'y a rien de mauvais ou de meilleur, cela dépend simplement de la priorité des opérateurs.Depuis || a une priorité plus élevée que or, donc || est surtout utilisé.

Certains langages utilisent soit le court-circuit, soit l'évaluation booléenne complète (si vous le savez, c'est similaire à la directive $B en pascal)

Explications :

function A(){
 ...do somethings..
 return true;
}

function B(){
 ...do somethings..
 return true;
}

if ( A() OR B() ) { .....

Dans cet exemple, la fonction B() ne sera jamais exécuté.Puisque la fonction A() renvoie VRAI, le résultat de l'instruction OR est connu dès la première partie sans qu'il soit nécessaire d'évaluer la deuxième partie de l'expression.

Cependant avec ( A() || B() ), la deuxième partie est toujours évaluée quelle que soit la valeur de la première.

Pour une programmation optimisée, vous devez toujours utiliser OR ce qui est plus rapide (sauf dans le cas où la première partie renvoie false et la deuxième partie doit effectivement être évaluée).

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top