Opérateurs logiques: AND est-il meilleur que OR?

https://stackoverflow.com/questions/457317

19-08-2019
|

Question

Désolé s'il s'agit d'une question comp-sci 101. Je ne suis pas sûr d'avoir oublié quelque chose d'évident.

Supposons donc que certaines entrées utilisateur génèrent une erreur et que je veuille la détecter et renvoyer des commentaires. L'erreur sera un nombre, compris entre 0 et 8. 0 signifie "Aucune erreur". Je veux donner à l'utilisateur des commentaires très spécifiques si l'erreur est 3 (pas de chiffres autorisés, par exemple). Pour les 7 autres possibilités, je veux juste terminer le script et répéter l’erreur.

Je travaillais sur ceci et a décidé d'aller avec ceci:

$no_errors ( Désolé s'il s'agit d'une question comp-sci 101. Je ne suis pas sûr d'avoir oublié quelque chose d'évident. 

 Supposons donc que certaines entrées utilisateur génèrent une erreur et que je veuille la détecter et renvoyer des commentaires. L'erreur sera un nombre, compris entre 0 et 8. 0 signifie "Aucune erreur". Je veux donner à l'utilisateur des commentaires très spécifiques si l'erreur est 3 (pas de chiffres autorisés, par exemple). Pour les 7 autres possibilités, je veux juste terminer le script et répéter l’erreur. 

 Je travaillais sur ceci et a décidé d'aller avec ceci: 

<*>

 Quoi qu'il en soit, je remarquais alors l'opérateur OR en première ligne et pensais qu'il serait peut-être préférable / plus sûr pour un utilisateur AND. Mais plus je contemple, moins je vois de différence. 

 La vraie question est donc: si vous voulez éliminer deux possibilités d’une variable spécifique, les opérateurs AND et OR sont-ils identiques, ou est-ce que l’une est logiquement / fonctionnellement plus optimale? 
error != 0 ||  Désolé s'il s'agit d'une question comp-sci 101. Je ne suis pas sûr d'avoir oublié quelque chose d'évident. 

 Supposons donc que certaines entrées utilisateur génèrent une erreur et que je veuille la détecter et renvoyer des commentaires. L'erreur sera un nombre, compris entre 0 et 8. 0 signifie "Aucune erreur". Je veux donner à l'utilisateur des commentaires très spécifiques si l'erreur est 3 (pas de chiffres autorisés, par exemple). Pour les 7 autres possibilités, je veux juste terminer le script et répéter l’erreur. 

 Je travaillais sur ceci et a décidé d'aller avec ceci: 

<*>

 Quoi qu'il en soit, je remarquais alors l'opérateur OR en première ligne et pensais qu'il serait peut-être préférable / plus sûr pour un utilisateur AND. Mais plus je contemple, moins je vois de différence. 

 La vraie question est donc: si vous voulez éliminer deux possibilités d’une variable spécifique, les opérateurs AND et OR sont-ils identiques, ou est-ce que l’une est logiquement / fonctionnellement plus optimale? error != 3) ? FALSE : TRUE;
if (!$no_errors)
echo $error_msg[' Désolé s'il s'agit d'une question comp-sci 101. Je ne suis pas sûr d'avoir oublié quelque chose d'évident. 

 Supposons donc que certaines entrées utilisateur génèrent une erreur et que je veuille la détecter et renvoyer des commentaires. L'erreur sera un nombre, compris entre 0 et 8. 0 signifie "Aucune erreur". Je veux donner à l'utilisateur des commentaires très spécifiques si l'erreur est 3 (pas de chiffres autorisés, par exemple). Pour les 7 autres possibilités, je veux juste terminer le script et répéter l’erreur. 

 Je travaillais sur ceci et a décidé d'aller avec ceci: 

<*>

 Quoi qu'il en soit, je remarquais alors l'opérateur OR en première ligne et pensais qu'il serait peut-être préférable / plus sûr pour un utilisateur AND. Mais plus je contemple, moins je vois de différence. 

 La vraie question est donc: si vous voulez éliminer deux possibilités d’une variable spécifique, les opérateurs AND et OR sont-ils identiques, ou est-ce que l’une est logiquement / fonctionnellement plus optimale? error'];
$error_3 ($no_errors &&  Désolé s'il s'agit d'une question comp-sci 101. Je ne suis pas sûr d'avoir oublié quelque chose d'évident. 

 Supposons donc que certaines entrées utilisateur génèrent une erreur et que je veuille la détecter et renvoyer des commentaires. L'erreur sera un nombre, compris entre 0 et 8. 0 signifie "Aucune erreur". Je veux donner à l'utilisateur des commentaires très spécifiques si l'erreur est 3 (pas de chiffres autorisés, par exemple). Pour les 7 autres possibilités, je veux juste terminer le script et répéter l’erreur. 

 Je travaillais sur ceci et a décidé d'aller avec ceci: 

<*>

 Quoi qu'il en soit, je remarquais alors l'opérateur OR en première ligne et pensais qu'il serait peut-être préférable / plus sûr pour un utilisateur AND. Mais plus je contemple, moins je vois de différence. 

 La vraie question est donc: si vous voulez éliminer deux possibilités d’une variable spécifique, les opérateurs AND et OR sont-ils identiques, ou est-ce que l’une est logiquement / fonctionnellement plus optimale? error == 3) ? TRUE : FALSE;
if ($error_3)
   bunch of stuff happens;
else
   bunch of other stuff;

Quoi qu'il en soit, je remarquais alors l'opérateur OR en première ligne et pensais qu'il serait peut-être préférable / plus sûr pour un utilisateur AND. Mais plus je contemple, moins je vois de différence.

La vraie question est donc: si vous voulez éliminer deux possibilités d’une variable spécifique, les opérateurs AND et OR sont-ils identiques, ou est-ce que l’une est logiquement / fonctionnellement plus optimale?

La solution

logiquement les suivants sont identiques (excusez mon pseudo-code)

(! expression_one || ! expression_two) /** this is the same as the one below **/
! (expression_one && expression_two)

Sur le plan fonctionnel, lequel est le plus optimal? Ils sont tous deux aussi optimaux l'un que l'autre. Les deux manières (& amp; et ||) permettent les courts-circuits si la première expression est vraie (dans le cas du ||) ou fausse (dans le cas de & amp; & amp;)

Autres conseils

Il sera beaucoup plus lisible si vous utilisez une instruction switch:

switch ( Il sera beaucoup plus lisible si vous utilisez une instruction switch: 

<*>error) {
    case 0;
        nothing happens;
        break;
    case 3:
        bunch of stuff happens;
        break;
    default:
        bunch of other stuff;
        break;
}

Tout d'abord, je pense que je recommanderais d'utiliser un autre moyen d'identifier les erreurs que d'utiliser "des nombres magiques". Ils sont difficiles à maintenir car vous oubliez facilement ce que vous utilisez "3". signifiait. Il semble que votre langage soit PHP, qui prend en charge les exceptions. Je vous recommande de les utiliser à la place, vous pouvez en savoir plus à ce sujet ici: http://dk.php.net/ exceptions

En ce qui concerne les opérateurs logiques, aucun d’entre eux n'est considéré comme une "bonne pratique". Utilisez ce que vous voulez. Si vous ne parvenez pas à savoir quand votre expression est vraie ou fausse, essayez de créer une table de vérité: http: // en.wikipedia.org/wiki/Truth_table

En ce qui concerne les performances, gardez à l’esprit que l’évaluation sera paresseuse dans la plupart des langues. Si vous utilisez OU, si la première condition est vraie, elle retournera la valeur true sans évaluer la deuxième condition. Pour AND, il retournera false si la première condition est fausse, sans évaluer la seconde.

Sinon, les performances des opérateurs eux-mêmes ne sont pas vraiment différentes. Utilisez ce qui vous est le plus lisible.

Le meilleur est celui qui vous aide à lire le code plus rapidement. C’est la seule véritable optimisation que vous puissiez faire ici, et éventuellement dans des millions d’autres endroits.

Cela semblerait plus simple à lire:

  if( Cela semblerait plus simple à lire: 

<*>

 Personne ne remarque les microsecondes que vous pourriez gagner. error==3)
      do stuff;
    else if( Cela semblerait plus simple à lire: 

<*>

 Personne ne remarque les microsecondes que vous pourriez gagner. error>0)
      do some other stuff
    else
      do normal stuff

Personne ne remarque les microsecondes que vous pourriez gagner.

Personnellement, je supprimerais l'utilisation de ces nombres et utiliserais des constantes à la place. En plus d'être plus faciles à gérer, ils facilitent beaucoup le codage et vous permettent de mettre à jour les valeurs demain, par exemple. si certaines circonstances vous obligent à modifier le nombre à partir de 3, vous devez parcourir presque tout votre code
Comme suggéré par gkrogers, un commutateur en accomplissant la même chose est beaucoup plus facile à lire et à maintenir

En ce qui concerne les performances, je pense qu’elles sont très similaires (voir article de wvanbergen), mais il existe des différences évidentes de comportement. Je pense que votre annonce actuelle ne fait peut-être pas ce que vous espérez. Dans la première ligne si vous $ _error = 3 alors vous aurez $ no_errors = false. Lorsque vous vérifiez deux conditions, elles doivent toutes deux être satisfaites et seraient plus appropriées.

Parfois, le moyen le plus simple de vérifier ma logique est de dire ce que je veux à haute voix. Par exemple, "Nous n'avons pas d'erreur si le code d'erreur est pas 0 et pas 3"

Je trouve généralement que dans une situation comme celle-ci avec seulement quelques variables, la façon dont j'écrirais la phrase en anglais me fournit la méthode la plus intuitive (et la plus précise) pour déterminer les opérateurs logiques.

Si vous constatez que le code semble compliqué après ce processus, vous pouvez alors trouver this lien utile sur les lois de De Morgan

(A || B) =! (A & B & B). Donc, cela ne fait vraiment pas une différence

EDIT: (A || B) =! (A & B & B) est incorrect. Tks pour le commentaire. La forme correcte est (! A ||! B) =! (A & B & B).

Mes excuses

Si vous utilisez:

$no_errors ( Si vous utilisez: 

<*>

 Cela signifie que si $ error! = 0 AND $ error! = 3, ce qui est une logique invalide car $ error ne peut pas être == à 3 et 0 il peut être 3 OU 0 mais pas les deux. 

Dans l'exemple ci-dessus, si $ error = 0, sa valeur est FALSE car il ne s'agit pas de 3 & amp; & amp; 0 vous cherchez qu'il soit 3 || 0. 
error != 0 &&  Si vous utilisez: 

<*>

 Cela signifie que si $ error! = 0 AND $ error! = 3, ce qui est une logique invalide car $ error ne peut pas être == à 3 et 0 il peut être 3 OU 0 mais pas les deux. 

Dans l'exemple ci-dessus, si $ error = 0, sa valeur est FALSE car il ne s'agit pas de 3 & amp; & amp; 0 vous cherchez qu'il soit 3 || 0. error != 3) ? FALSE : TRUE;

Cela signifie que si $ error! = 0 AND $ error! = 3, ce qui est une logique invalide car $ error ne peut pas être == à 3 et 0 il peut être 3 OU 0 mais pas les deux.
Dans l'exemple ci-dessus, si $ error = 0, sa valeur est FALSE car il ne s'agit pas de 3 & amp; & amp; 0 vous cherchez qu'il soit 3 || 0.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow