Comment raccourcir mes instructions conditionnelles

J'ai une très longue instruction conditionnelle comme suit:

if(test.type == 'itema' || test.type == 'itemb' || test.type == 'itemc' || test.type == 'itemd'){
    //do something.
}

Je me demandais si je pouvais refactoriser cette expression/déclaration dans une forme plus concise.

Aucune idée sur comment faire?

Vous pouvez les mettre dans un tableau et utiliser in?
snook.ca/archives/javascript/testing_for_a_v
maintenant, seulement si quelqu'un pouvait vérifier lequel est le plus rapide
cela peut être un choc pour tout le monde mais ce que l'OP a est un gagnant clair dans la vitesse!!!!!!! Peut-être à cause du navigateur optimiser pour cela beaucoup.. Résultats: (1) si avec ||. (2) switch consolidés. (3) regex. (4) ~. jsperf.com/if-statements-test-techsin
Vous pouvez également être en approchant de cette façon le mal. Dans ce cas, ces 4 types ont quelque chose en commun. Quel est-il? Si nous prenons cela pour un cas plus extrême, que si nous devions ajouter 10 autres types de correspondre à cette condition. Ou 100? S'il n'y avait plus, vous n'auriez probablement pas envisager de recourir à cette solution, ou de toute autres propositions. Vous êtes témoins d'un grand si l'instruction de ce genre, et de penser que c'est une odeur de code, ce qui est un bon signe. Votre meilleur moyen de le rendre plus concis serait si vous pouviez écrire if (test.your_common_condition). C'est plus facile à comprendre dans ce contexte, et plus extensible.
Lire: Optimiser OU SI
En python ce serais simplement if test.type in ('itema', 'itemb', ...):
Ces résultats sont très bizarre lorsque l'on compare les résultats entre Firefox & Chrome, que la différence est ÉNORME.
ff a battu chrome en js vitesse récemment, donc oui.
Cette question est actuellement un double de double de double de double de double. (this -> Javascript formatage si la condition -> Javascript: Comparaison de la Valeur UNIQUE à l'Encontre de PLUSIEURS Valeurs avec OU Opérandes -> Javascript si l'instruction avec plusieurs admissibilité-conditions ->Javascript Si l'instruction utilisée pour vérifier les extensions de fichier ne fonctionne pas)

InformationsquelleAutor FlyingCat | 2013-08-21

if-statement javascript

240

Mettre vos valeurs dans un tableau, et de vérifier si votre article est dans le tableau:
```
if ([1, 2, 3, 4].includes(test.type)) {
    //Do something
}
```
Si le navigateur vous le soutien n'a pas le Array#includes méthode, vous pouvez utiliser cette polyfill.

Courte explication de la ~ tilde raccourci:

Mise à jour: Puisque nous avons maintenant la includes méthode, il n'y a pas de point à l'aide de la ~ hack plus. En gardant juste ce ici pour les gens qui sont intéressés à savoir comment il fonctionne et/ou qu'ils ont rencontré dans d'autres code.

Au lieu de vérifier si le résultat de indexOf est >= 0, il est un agréable petit raccourci:
```
if ( ~[1, 2, 3, 4].indexOf(test.type) ) {
    //Do something
}
```
Ici est le violon: http://jsfiddle.net/HYJvK/

Comment cela fonctionne? Si un élément est trouvé dans le tableau, indexOf retourne son index. Si l'élément n'a pas été trouvé, il va revenir -1. Sans entrer dans trop de détails, le ~ est un not au niveau du bit opérateur, qui sera de retour 0 seulement pour -1.

J'ai comme l'utilisation de la ~ raccourci, car il est plus concis que de faire une comparaison de la valeur de retour. Je souhaite JavaScript serait un in_array fonction qui retourne un Booléen directement (similaire à PHP), mais c'est juste un vœu pieux (mise à Jour: c'est maintenant. Il est appelé includes. Voir ci-dessus). Notez que jQuery inArray, tandis que le partage de PHP à la signature de la méthode, imite en fait le natif indexOf fonctionnalité (ce qui est utile dans différents cas, si l'index est ce que vous êtes vraiment après).

Remarque importante: à l'Aide de la tilde raccourci semble être plongé dans la controverse, comme certains avec véhémence crois que le code n'est pas suffisamment claire et doit être évité à tous les frais (voir les commentaires sur cette réponse). Si vous partagez leur sentiment, vous devez vous en tenir à la .indexOf(...) >= 0 solution.

Un peu plus d'explication:

Entiers en JavaScript sont signés, ce qui signifie que la partie gauche du bit est réservé que le bit de signe; un drapeau pour indiquer si le nombre est positif ou négatif, avec un 1 être négatif.

Voici quelques exemples de nombres positifs en binaire de 32 bits format:
```
1 :    00000000000000000000000000000001
2 :    00000000000000000000000000000010
3 :    00000000000000000000000000000011
15:    00000000000000000000000000001111
```
Voici maintenant de ces mêmes nombres, mais négatif:
```
-1 :   11111111111111111111111111111111
-2 :   11111111111111111111111111111110
-3 :   11111111111111111111111111111101
-15:   11111111111111111111111111110001
```
Pourquoi ces étranges combinaisons pour les nombres négatifs? Simple. Un nombre négatif est tout simplement l'inverse du nombre positif + 1; ajouter le numéro du négatif au positif numéro doit toujours céder 0.

Pour comprendre cela, nous allons faire quelques simple arithmétique binaire.

Voici comment nous pourrions ajouter -1 à +1:
```
   00000000000000000000000000000001      +1
+  11111111111111111111111111111111      -1
-------------------------------------------
=  00000000000000000000000000000000       0
```
Et voici comment nous pourrions ajouter -15 à +15:
```
   00000000000000000000000000001111      +15
+  11111111111111111111111111110001      -15
--------------------------------------------
=  00000000000000000000000000000000        0
```
Comment pouvons-nous obtenir ces résultats? Par la pratique régulière de plus, la manière dont il nous a été enseigné à l'école: vous commencez à la colonne la plus à droite, et vous additionnez toutes les lignes. Si la somme est plus grande que le plus grand nombre (qui en décimal est 9, mais en binaire est 1) nous portons le reste à la colonne suivante.

Maintenant, comme vous le verrez, lors de l'ajout d'un nombre négatif à son nombre positif, la colonne la plus à droite ce n'est pas tout 0s auront toujours deux 1s, qui, lorsqu'on les additionne entraînera 2. La représentation binaire de deux 10, nous portons la 1 à la colonne suivante, et de mettre un 0 le résultat dans la première colonne. Toutes les autres colonnes de gauche ont qu'une seule ligne avec un 1, de sorte que le 1 reportée de l'exercice précédent de la colonne sera de nouveau ajouter jusqu'à 2, qui va alors effectuer plus de... Ce processus se répète jusqu'à ce que nous obtenons à la colonne la plus à gauche, où l' 1 être reporté a nulle part où aller, donc il déborde et se perd, et nous nous retrouvons avec 0s partout.

Ce système est appelé Complément de 2. Vous pouvez en lire plus à ce sujet ici:

Complément de 2 Représentation des Entiers Signés.

Maintenant que le cours intensif de 2 effectif de plus, vous remarquerez que -1 est le seul nombre dont la représentation binaire est 1's partout.

À l'aide de la ~ not au niveau du bit opérateur, tous les bits d'un nombre donné sont inversées. La seule façon d'obtenir 0 de retour à partir de l'inversion de tous les bits est si nous avons commencé avec 1's partout.

Donc, tout cela est un travail de longue haleine manière de dire que ~n ne retour 0 si n est -1.
- ce n'est pas faire la même chose tho
- Soins à élaborer?
- Vous pouvez élaborer sur le tilde raccourci.
- que faire si vous avez d'avoir des valeurs nommé comme "itemb' pas 2...donc, dans ce cas, vous devez remplacer tous les nombres avec des cordes, et ça va devenir long comme ça. Mais il est toujours une bonne façon de prendre un peu de logique.
- n'est-ce pas un raccourci. C'est de la bit-à-bit PAS opérateur
- Je ne reçois pas votre point de vue. Les articles doivent être énumérés indépendamment de ce qu'ils sont. Les stockant dans un tableau est le chemin le plus court pour les énumérer.
- Lors de l'utilisation d'opérateurs au niveau du bit est sûr, c'est sexy, est-il vraiment mieux que !== -1 de toutes les façons imaginables? N'est pas explicite la logique booléenne plus approprié que de façon implicite à l'aide de la falsey-ness de zéro?
- Alors que je considère l'opérateur au niveau du bit genre de hack, c'est assez bien connue, de sorte qu'il n'est pas comme si le code est illisible. J'aime vraiment la concision du tilde, mais si vous ne l'aimez pas, ne l'utilisez pas. J'ai ajouté le -1 vérifier ma réponse.
- Je préfère vérifier avec >=0 qui a la plus détendue état (lorsque la documentation ne dit que la valeur renvoyée est négative (ce qui peut être !==-1)
- Bien techy, mais je ne l'aime pas. Il n'est pas évident au premier coup d'œil ce que fait le code, ce qui le rend difficile à maintenir. Je préfère de beaucoup "Yuriy Galanter"'s réponse.
- C'est très intéressant info, qui connaissait une telle belle réponse après une question superficielle.
- Est la représentation binaire des nombres entiers de 32 bits garantie en JavaScript? Autant que je sache, spécification ECMAScript n'est pas le décrire. J'ai peur que le fait de compter sur ~-1 == false n'est pas portable.
- Si vous devez expliquer votre code pour la grande majorité des gens qui le regardent, alors vous voudrez probablement quelque chose d'un peu plus facile à comprendre.
- oui et non. Le ~foo.indexOf(bar) raccourci est un très commune chemin pour écrire foo.contains(bar), de la même manière que foo || bar est une commune de la forme abrégée de foo ? foo : bar
- Histoire: une fois, j'ai demandé à mon ancien manager pourquoi il a été l'utilisation de bit-wise logique plutôt de type boolean. Il n'avait aucune idée de ce dont je parlais - je n'ai même pas savoir qu'il y avait une autre façon de faire.
- c'est ce que la révision du code sont pour. De nombreux programmeurs ne savent pas les expressions régulières, mais cela ne signifie pas que je devrais arrêter de les utiliser là où elles rendent le code plus simple. J'essaie de code d'une manière qui permet aux futurs-moi à comprendre ce que j'ai écrit. Pour quiconque de maintenir le code, j'ai à assumer un niveau de base de compétence dans la langue en cours d'utilisation. Si la personne gérant le code n'a pas que du niveau de compétence, c'est leur travail pour apprendre, pas mon métier stupide des choses vers le bas. je suis pas en essayant de dire que c'est une bonne idée d'écrire trop intelligent code.
- l'habitude de l'ajout de 00000000000000000000000000000001 + 11111111111111111111111111111111 = 100000000000000000000000000000000 and not 000000000000000000000000000000000 notice the first digit
- Nope. Il n'y a que 32 bits alloués pour un nombre donné, que le dernier bit de débordement et d'être perdus à jamais, résultant en une somme de 0. Lire mon post à nouveau.
- -1 les nouveaux programmeurs de voir les réponses comme ça, pense que c'est cool et acceptable de codage, puis dans 5 ans, j'ai pour maintenir leur code et de m'arracher les cheveux
- La façon dont je le vois, ces hacks sont acceptables si elles sont couramment utilisés chez les programmateurs compétents (comme l'utilisation de a || b en place de a ? a : b). Depuis cette tilde hack est assez bien connu et utilisé, je ne pense pas que vous aurez à "s'arracher les cheveux" sur elle. Je comprends que c'est une question d'opinion, donc si vous n'aimez pas, ne l'utilisez pas; c'est pourquoi j'ai inclus l'autre méthode dans ma réponse.
- Cet idiome est certainement pas commun dans des langages tels que C#, Java ou Python, qui sont mes domaines d'expertise. Et je viens de demander à quelques-uns des locaux Javascript experts ici, et aucun d'eux n'a jamais vu faire auparavant; donc ce n'est clairement pas aussi commun que vous le prétendez. Il doit toujours être évitées au profit de la commune et plus claire != -1.
- Vous avez sacrifié une tonne de lisibilité pour des raisons de concision. J'espère que personne n'a jamais regarde ce code, sauf vous, sinon votre version d'origine est de loin supérieure.
- Je suis d'accord, je ne pense pas vraiment que c'est commun en Javascript, soit, que j'ai utilisé tous les jours pendant des années. Les opérations sur les bits sont trop bas niveau de facilement venir à l'esprit.
- et tous - Cette technique est assez bien connue (voir ici & ici). Même une simple Recherche serait l'expliquer. Sa préférence est une question d'opinion. Cela dit, puisque de nombreux pense que c'est une mauvaise idée, j'ai revenue la première solution pour utiliser >=0, et ajouté un gros note à côté de la tilde solution. C'est la dernière que j'ai à dire à ce sujet.
- les gars viens de l'utiliser si vous le souhaitez et si vous ne le faites pas. Et le respect des autres choix lors de la lecture de leur code. Pas tout le monde peut penser de la même façon. Somethings regarder de plus organisé et facile à certaines personnes et à certains juste le contraire. Pour ne pas mentionner de préférence également changer d'effectuer des heures supplémentaires.
- -1 en raison inutile bitfiddling dans une langue qui n'est pas vraiment préciser beaucoup de choses sur les représentations en bits en premier lieu. De Plus, la majeure partie de cette réponse est d'expliquer les bitfiddling. Si vous avez à écrire 20 paragraphes pour expliquer le hack, est-il VRAIMENT sauver tout le temps?
- -1 JavaScript n'a qu'une notion de nombre, pas un entier. Voir cette réponse
- Lors de l'utilisation d'opérateurs au niveau du bit, les chiffres sont les convertis pour signé nombres entiers de 32 bits. Voir ce post sur MDN: Les opérandes de tous les opérateurs sur les bits sont convertis signé de 32 bits entiers dans des big-endian l'ordre et en complément à deux format..
- -1, indexOf n'est pas pris en charge dans tous les navigateurs. L'introduction de l'incompatibilité du navigateur juste pour un raccourci n'est pas une bonne pratique.
- Astuce: si le JavaScript les experts ne savent pas) que indexOf retourne -1 pour le manque de présence et b) que la ~ opérateur, et/ou ne peuvent pas comprendre ce ~[...].indexOf(...) n' lors de la première lecture, puis sur ils ne sont pas JavaScript experts.
- tilde tourne -1 (pas dans le tableau) en 0 (false). ce n'est absolument pas intuitif, il n'a pas d'inverser la logique. MÉFIEZ-vous!
- J'ai toujours lu les ~ "non", ce qui provoque ce raccourci pour être totalement confus pour moi
- Cela fonctionne, mais n'est pas encore une amélioration du code. Voir, que la lecture de code est terrible. Les grandes structures conditionnelles, indiquent les niveaux de complexité en dessous de ce code, il est où est le problème. Manque OO ici.
- J'ai une question, N'js ont ou= opérateur. Si je pouvais écrire le code comme ceci if ( x == 'a' ||= 'b' ||= 'c') . ce serait tellement logique. Et, de même, d'avoir et de = l'habitude de mal non plus comme &&=.
- -1 je suis un nodeJS/JS programmeur et je déteste les opérateurs au niveau du bit. Si je voulais m'en servir, j'avais le code en C ou en assembleur. JS a une meilleure syntaxe pour ce genre de choses, comme la plus explicite, lisible !== -1. J'espère ne jamais avoir à voir votre code n'importe où.
- +-0: -1 pour ~, pour ajouter de la complexité. +1 pour >= 0, il est trivial et tout le monde comprendra.
- Le seul navigateurs qui ne supportent pas indexOfsont IE<9 et les premières versions de Firefox. À mon humble avis, vous devriez avoir un polyfill pour cela de toute façon.
InformationsquelleAutor Joseph Silber
242

Vous pouvez utiliser l'instruction switch avec l'automne thru:
```
switch (test.type) {

  case "itema":
  case "itemb":
  case "itemc":
  case "itemd":
    //do something
}
```
- c'est en fait le même que le si, l'indice de la matrice de la méthode est loin beaucoup mieux
- le problème avec l'instruction switch est que vous avez besoin de mettre explicite saut pour éviter de tomber à travers
- la chute est un peu un point ici 🙂
- son malheureusement, la bonne réponse est celle-ci, mais il est impossible d'obtenir de l'attention à cela au lieu de le génial bitwhise-tableau de truc.
- Je savais que cette réponse devait être ici, mais j'ai dû faire défiler chemin vers le bas pour le trouver. C'est exactement ce que l'instruction switch a été conçu et transporte plus de nombreuses autres langues. J'ai trouvé beaucoup de gens ne savent pas à propos de la chute par le biais de la méthode dans une instruction switch.
- Cette solution est la plus rapide sur Firefox et Safari et la seconde, plus rapide (d'après l'original ||) sur Chrome. Voir jsperf.com/if-statements-test-techsin
- Cela fonctionne, mais n'est pas encore une amélioration du code. Voir, que la lecture de code est terrible. Les grandes structures conditionnelles, indiquent les niveaux de complexité en dessous de ce code, il est où est le problème. Manque OO ici.
- Je pense que ce serait terrible d'écrire dans une méthode si vous avez eu beaucoup de conditions... si fine pour quelques conditions, mais pour plus de 10 j'irais pour le tableau de garder un code propre.
- Quelle étrange chose... Pour la même réponse à la même question une demi-année, j'ai reçu un downvote 🙂
- Je ne peux pas imaginer une situation dans laquelle un long tableau est plus propre que d'une longue instruction switch.
- le cas où vous avez pour tester cette condition à plusieurs reprises les ressorts à l'esprit. Pourrait juste être une question de goût bien que. Je préfère mettre en place une liste ou un tableau dans le constructeur. Et une liste a l'avantage supplémentaire que vous pouvez facilement ajouter ou supprimer des conditions si nécessaire.
- Je suis d'accord que lorsque vous avez besoin de ré-utilisation de ces valeurs dans un autre endroit, il est plus intelligent de les avoir stockées quelque part plutôt que de les dupliquer. Mais si il y a un seul point d'utilisation, le tableau utilise plus de mémoire, sans aucun avantage pour la mise en forme. De toute façon, tous les cas besoin d'être énumérées, et de nouveaux cas peuvent être ajoutés facilement.
InformationsquelleAutor Yuriy Galanter
63

L'utilisation de la Science: vous devez faire ce que idfah dit et ce pour le plus rapide tandis que la vitesse de garder le code court:

C'EST plus RAPIDE QUE ~ Méthode
```
var x = test.type;
if (x == 'itema' ||
    x == 'itemb' ||
    x == 'itemc' ||
    x == 'itemd') {
    //do something
}
```
http://jsperf.com/if-statements-test-techsin

(En haut à définir: Chrome, bas: Firefox)

Conclusion :

Si possibilités sont quelques et vous savez que certains d'entre eux sont plus susceptibles de se produire que vous obtenir le maximum de performance et de if || ,switch fall through , et if(obj[keyval]).

Si possibilités sont de nombreux, et quiconque d'entre eux pourrait être la plupart survenant, en d'autres termes, vous ne pouvez pas le savoir lequel est le plus susceptible de se produire que vous obtenez la plupart de la performance de l'objet de recherche if(obj[keyval]) et regex si cela correspond.

http://jsperf.com/if-statements-test-techsin/12

je vais mettre à jour si quelque chose de nouveau arrive.
- +1 pour un poste vraiment bon! Si je comprends bien, la switch case est la méthode la plus rapide?
- dans firefox, oui, en chrome de ses if ( ...||...||...)...
- j'irais avec un ' ||' parce que si quelqu'un est sur chrome, la plupart le sont, ils vont obtenir une plus grande vitesse et si ils sont sur ff ils ne seront toujours obtenir beaucoup de fois plus.
- C'est plus rapide si vous avez vraiment beaucoup de boucles au-dessus de cette entrée, mais c'est bien de plus si vous avez une boucle avec un très grand n (nombre de "itemX" chaînes de caractères). J'ai piraté ce générateur de code que vous pouvez utiliser pour vérifier (ou réfuter). obj["itemX"] est extrêmement rapide si n est grand. Fondamentalement, ce qui est rapide dépend du contexte. Avoir du plaisir.
- peut-être vous êtes juste un peu...jetez un oeil à cette mise à jour du code/test...switch et si encore gagner, mais de l'objet de recherche rattrape... La chose que j'ai remarqué avec l'objet est l'objet était de se recréé à nouveau et de nouveau. Quand à la situation réelle d'un objet contenant les valeurs par défaut sera créé une fois. De toute façon commutateur est mieux.
- C'est donc la méthode la plus rapide, mais est-il question?
- um yeaaa parfois la vitesse importe beaucoup, comme dans le mobile.
- commentaire hors sujet... des captures d'écran devrait presque toujours être pris comme une image PNG... ick que l'image est floue! 😉
- ce n'est pas que je pense que j'ai enregistré avec de très faible qualité. Mais depuis, il n'a pas d'importance, je n'ai pas réessayer
- Astuce: si vous mettez le plus probablement le choix le plus rapide de votre code. Parce que switch or if n'avez pas à continuer.
- Ne sacrifie pas l'élégance de code juste pour la vitesse. C'est ce que beaucoup beaucoup de gens vont vous dire. En fin de compte, il suffit d'utiliser le sens commun.
InformationsquelleAutor Muhammad Umer
32

Si vous comparez à cordes et il y a un patron, pensez à utiliser des expressions régulières.

Sinon, je le soupçonne d'essayer de raccourcir ce sera juste dissimuler votre code. Envisager de simplement envelopper les lignes pour faire joli.
```
if (test.type == 'itema' ||
    test.type == 'itemb' ||
    test.type == 'itemc' ||
    test.type == 'itemd') {
    do something.
}
```
- cette réponse est le gagnant en termes de vitesse jsperf.com/if-statements-test-techsin
- C'est aussi le plus facile à développer que lorsque le projet passe en mode de maintenance (avec des règles telles que, (test.type == 'itemf' && foo.mode == 'detailed'))
InformationsquelleAutor idfah
16
```
var possibilities = {
  "itema": 1,
  "itemb": 1,
  "itemc": 1,
…};
if (test.type in possibilities) { … }
```
À l'aide d'un objet comme un tableau associatif est une chose assez commune, mais depuis que JavaScript n'est pas un natif, vous pouvez utiliser des objets comme pas cher sets.
- Comment est-ce plus courts que la normale si l'instruction que FlyingCat est d'essayer de raccourcir?
- OP if instruction conditionnelle prend 78 caractères si vous supprimez tous les espaces. La Mine dure 54 si vous l'écrire comme ceci: test.type in {"itema":1,"itemb":1,"itemc":1,"itemd":1}. Fondamentalement, son utilise quatre caractères pour tous les deux de la mine utiliser pour chaque touche supplémentaire.
- mais vous pouvez faire: si(possibilités[de test.type]) et d'enregistrer un ensemble de 2 caractères! 🙂
- Vrai, mais je ne veux pas de cela pour obtenir trop de code-golfy.
InformationsquelleAutor kojiro
15
```
if( /^item[a-d]$/.test(test.type) ) { /* do something */ }
```
ou si les articles ne sont pas uniformes, puis:
```
if( /^(itema|itemb|itemc|itemd)$/.test(test.type) ) { /* do something */ }
```
- "Certaines personnes, lorsqu'ils sont confrontés à un problème, on pense à" je sais, je vais utiliser des expressions régulières.' Maintenant, ils ont deux problèmes." - Jamie Zawinski, 1997
- Même si je peux comprendre les gens aiment échanger à propos de cette citation et les personnes et certainement d'utiliser des expressions régulières pour totalement inadaptés choses, mais ce n'est pas l'un d'eux. Dans le cas prévu par l'OP, ce n'est pas seulement correspond aux critères, il le fait très bien. Les expressions régulières ne sont pas mauvais en soi, et la correspondance des chaînes de caractères avec des paramètres bien définis est ce que c'est fait pour.
- Habituellement, je suppose que l'interlocuteur n'est pas en fait en essayant de faire correspondre contre ces un exemple artificiel comme le premier cas, et que le monde réel, les matchs ne sont pas si simples, dans ce cas, je ne pense pas qu'une RegEx va être la bonne façon de le faire. Pour le dire d'une autre façon, si votre RegEx est juste un tuyau de caractère liste d'options séparées, c'est pas plus lisible que les autres suggestions, et d'être beaucoup moins efficace.
InformationsquelleAutor Matt
10

D'excellentes réponses, mais vous pourriez faire le code beaucoup plus lisible en l'enveloppant d'un d'entre eux en fonction.

C'est complexe dans le cas de la déclaration, lorsque vous (ou quelqu'un d'autre) lire le code dans un ans de temps, vous serez la numérisation à travers pour trouver la section de comprendre ce qui se passe. Une déclaration avec ce niveau de la logique d'entreprise vous fera trébucher quelques secondes pendant que vous travaillez que vous souhaitez tester. Où que ce code, vous permettra de poursuivre la numérisation.
```
if(CheckIfBusinessRuleIsTrue())
{
    //Do Something
}

function CheckIfBusinessRuleIsTrue() 
{
    return (the best solution from previous posts here);
}
```
Nom de votre fonction explicite immédiatement évident que vous de tester et de votre code sera plus facile à analyser et à comprendre.
- Meilleure réponse que j'ai vu ici. Vraiment, je vois que les gens ne se soucient pas des principes de bonne conception. Veux juste corriger quelque chose rapidement et oublier pour améliorer le code de sorte que le système devrait être maintenable à l'avenir!
- Que diriez-vous simplement de commenter comme // CheckIfBusinessRuleIsTrue?
InformationsquelleAutor Fran Hoey
4

Vous pouvez mettre toutes les réponses dans un Javascript Pour Définir et puis il suffit d'appeler .contains() sur l'ensemble.

Vous avez encore de déclarer tous les le contenu, mais la ligne téléphonique sera plus courte.

Quelque chose comme:
```
var itemSet = new Set(["itema","itemb","itemc","itemd"]);
if( itemSet.contains( test.type ){}
```
- Ça me paraît incroyable gaspillage d'accomplir ce que l'OP est en train de faire. Ainsi, alors que vous pourrait inclure un supplément de la 3e partie de la bibliothèque, instancier un objet, et l'appel d'une méthode sur elle, vous ne devriez probablement pas.
- Froid: Bien que l'OP a demandé de concision pas de mémoire. Peut-être que le jeu pourrait être réutilisé pour d'autres opérations?
- Bien sûr, mais tout de même: souhaitez-vous en toute honnêteté jamais le faire vous-même? Si je n'ai jamais vu cela dans la nature, je le considère comme l'un des principaux WTF.
- Ouais vous avez raison (je vous ai donné le +1s), mais il suppose que cette vérification est fait nulle part ailleurs. Si elle se fait dans plusieurs autres lieux et/ou les changements de test, l'utilisation de la série pourrait faire sens. Je laisse à l'OP pour choisir la meilleure solution. Tout ce que dit si c'était un solitaire d'utilisation, je suis d'accord que l'utilisation de l'Ensemble mériterait le Clown chapeau de la honte.
- En fait je pense que la réponse choisie est absolument horrible et le pire, puis en utilisant le Jeu comme il est absolument illisible.
InformationsquelleAutor Guido Anselmi
2

Un de mes façons préférées de l'accomplissement, c'est avec une bibliothèque comme underscore.js...
```
var isItem = _.some(['itema','itemb','itemc','itemd'], function(item) {
    return test.type === item;
});

if(isItem) {
    //One of them was true
}
```
http://underscorejs.org/#some
- contains est sans doute une meilleure solution que some
- Pas besoin d'utiliser une bibliothèque pour cela: some est une fonction sur le Tableau prototype dans EC5.
- Vrai, mais pas tout le monde a EC5 de soutien disponibles. De Plus, j'aime juste le trait de soulignement. 🙂
- Si vous êtes déjà à l'aide d'une bibliothèque comme le soulignent, c'est probablement le moyen le plus facile. Sinon, il fait peu de sens pour charger une bibliothèque entière uniquement pour une seule fonction.
InformationsquelleAutor jcreamer898
2

une autre façon ou d'une autre manière impressionnante que j'ai trouvé est ce...
```
if ('a' in oc(['a','b','c'])) { //dosomething }

function oc(a)
{
  var o = {};
  for(var i=0;i<a.length;i++)  o[a[i]]='';
  return o;
}
```
bien sûr, comme vous pouvez le voir, prend les choses une étape plus loin et de les rendre facile de suivre la logique.

http://snook.ca/archives/javascript/testing_for_a_v

utilisant des opérateurs tels que ~ && || ((),()) ~~ est bien uniquement si votre code pauses plus tard. Vous ne savez pas par où commencer. Si la lisibilité est GRAND.

si vous devez vous pourriez faire plus court.
```
('a' in oc(['a','b','c'])) && statement;
('a' in oc(['a','b','c'])) && (statements,statements);
('a' in oc(['a','b','c']))?statement:elseStatement;
('a' in oc(['a','b','c']))?(statements,statements):(elseStatements,elseStatements);
```
et si vous voulez faire l'inverse l'
```
('a' in oc(['a','b','c'])) || statement;
```
InformationsquelleAutor Muhammad Umer

Il suffit d'utiliser un switch déclaration au lieu de if déclaration:

switch (test.type) {

  case "itema":case "itemb":case "itemc":case "itemd":
    //do your process
  case "other cases":...:
    //do other processes
  default:
    //do processes when test.type does not meet your predictions.
}

Switch travaille également plus rapide que la comparaison de beaucoup de conditions à l'intérieur d'un if

InformationsquelleAutor unmultimedio

2

Pour de très longues listes de chaînes de caractères, cette idée permettrait d'économiser quelques caractères (ne pas le dire je le recommande dans la vraie vie, mais il devrait fonctionner).

Choisir un personnage que vous connaissez ne pas se produire dans votre test.type, de l'utiliser comme délimiteur, collez-les ensemble dans une longue chaîne et de la recherche:
```
if ("/itema/itemb/itemc/itemd/".indexOf("/"+test.type+"/")>=0) {
  //doSomething
}
```
Si vos cordes arrive d'être limité davantage, vous pouvez omettre les délimiteurs...
```
if ("itemaitembitemcitemd".indexOf(test.type)>=0) {
  //doSomething
}
```
...mais vous devez être prudent de faux positifs dans ce cas (par exemple, "embite" pourrait correspondre dans cette version)

InformationsquelleAutor CupawnTae

Pour des raisons de lisibilité de créer une fonction pour le test (oui, une seule ligne):

function isTypeDefined(test) {
    return test.type == 'itema' ||
           test.type == 'itemb' ||
           test.type == 'itemc' ||
           test.type == 'itemd';
}

ensuite l'appeler:

…
    if (isTypeDefined(test)) {
…
}
...

InformationsquelleAutor zaph

1

Je pense qu'il y a 2 objectifs lors de l'écriture de ce genre de condition if.
1. brièveté
2. lisibilité
En tant que tel, parfois, #1 pourrait être le plus rapide, mais je vais prendre le #2 pour un entretien facile plus tard. Selon le scénario, je vais souvent opter pour une variation de Walter réponse.

Pour commencer je avoir un ensemble de fonction disponible dans le cadre de ma bibliothèque existante.
```
function isDefined(obj){
  return (typeof(obj) != 'undefined');
}
```
et puis quand je veux exécuter une condition si semblables à la vôtre, je voudrais créer un objet avec une liste de valeurs valides:
```
var validOptions = {
  "itema":1,
  "itemb":1,
  "itemc":1,
  "itemd":1
};
if(isDefined(validOptions[test.type])){
  //do something...
}
```
Il n'est pas aussi rapide qu'un commutateur/instruction de cas, et un peu plus détaillée que celle de certains autres exemples, mais je reçois souvent des ré-utilisation de l'objet ailleurs dans le code, qui peut être assez pratique.

Se greffer sur l'un des jsperf d'échantillons ci-dessus, j'ai ajouté ce test, et une variation de comparer les vitesses. http://jsperf.com/if-statements-test-techsin/6 La chose la plus intéressante je l'ai noté, c'est que certains test de combos dans Firefox sont beaucoup plus rapide que Chrome.

InformationsquelleAutor scunliffe
1

Cela peut être résolu avec une simple boucle for:
```
test = {};
test.type = 'itema';

for(var i=['itema','itemb','itemc']; i[0]==test.type && [
    (function() {
        //do something
        console.log('matched!');
    })()
]; i.shift());
```
Nous utilisons la première section de la boucle for pour initialiser les arguments que vous voulez, en fonction, la deuxième section pour arrêter la boucle en cours d'exécution, et la troisième partie à cause de la boucle pour finalement quitter.

InformationsquelleAutor

Vous devez vous connecter pour publier un commentaire.

Courte explication de la ~ tilde raccourci:

Un peu plus d'explication:

Courte explication de la `~` tilde raccourci: