Alternatives imbriquées opérateur ternaire en JS

Personnellement, j'aime ternaire opérateurs, et à mon humble avis, ils font des expressions complexes très facile à digérer. Prenez celui-ci:

  word = (res.distance === 0) ? 'a'
    : (res.distance === 1 && res.difference > 3) ? 'b'
    : (res.distance === 2 && res.difference > 5 && String(res.key).length > 5) ? 'c'
    : 'd';

Toutefois, dans notre projet de ESLINT règles imbriquées ternaire opérateurs sont interdits, donc je dois me débarrasser de ce qui précède.

J'essaie de trouver des alternatives à cette approche. Je n'ai vraiment pas envie de le transformer en un énorme if /else, mais ne sais pas si il y a d'autres options.

Peut-être un switch déclaration qu'il regarde comme il y a quelques scénarios que vous souhaitez évaluer: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
Si vous pensez qu'ils font expressions complexes faciles à digérer, il suffit de désactiver cette stupide eslint règle.
Je suis en train de faire sur la base d'un eslint jeu de règles qui n'est pas à moi de décider.
Peut-être consulter les cette approche si vous voulez éviter de if/else et aussi comme des expressions
Il pourrait être ['a', res.difference > 3 && 'b', res.difference > 5 && String(res.key).length > 5 && 'c'][res.distance] || 'd', mais si nous avions appeler "raisonnables" est discutable 🙂

OriginalL'auteur dthree | 2015-08-29

15

Vos solutions de rechange ici sont essentiellement:
1. Que if/else vous ne voulez pas faire
2. Un switch combiné avec if/else
J'ai essayé de trouver avec une recherche de l'option de carte, mais il est devenu déraisonnable assez rapidement.

J'irais pour le #1, il n'est pas aussi grand:
```
if (res.distance == 0) {
    word = 'a';
} else if (res.distance == 1 && res.difference > 3) {
    word = 'b';
} else if (res.distance == 2 && res.difference > 5 && String(res.key).length > 5) {
    word = 'c';
} else {
    word = 'd';
}
```
Si toutes les accolades et la taille verticale de vous déranger, sans eux, c'est presque aussi concis que l'opérateur conditionnel version:
```
if (res.distance == 0) word = 'a';
else if (res.distance == 1 && res.difference > 3) word = 'b';
else if (res.distance == 2 && res.difference > 5 && String(res.key).length > 5) word = 'c';
else word = 'd';
```
(Je ne dis pas que je n'ai jamais préconisent de laisser hors tension de l'appareil ou de mettre l'instruction à la suite d'une if sur la même ligne, mais d'autres ont des styles différents points de vue.)

#2 est, à mon avis, le plus maladroit, mais c'est probablement plus un style de commentaires que d'autre chose:
```
word = 'd';
switch (res.distance) {
    case 0:
        word = 'a';
        break;
    case 1:
        if (res.difference > 3) {
            word = 'b';
        }
        break;
    case 2:
        if (res.difference > 5 && String(res.key).length > 5) {
            word = 'c';
        }
        break;
}
```
Et enfin, et je suis pas la promotion de ce, vous pouvez profiter du fait que JavaScript est switch est inhabituel dans le B-syntaxe de la langue de la famille: Le case déclarations peuvent être expressions, et sont comparées à la valeur du paramètre dans le code source de commande:
```
switch (true) {
    case res.distance == 0:
        word = 'a';
        break;
    case res.distance == 1 && res.difference > 3:
        word = 'b';
        break;
    case res.distance == 2 && res.difference > 5 && String(res.key).length > 5:
        word = 'c';
        break;
    default:
        word = 'd';
        break;
}
```
Comment moches, c'est qui? 🙂

Incroyable! Comment sur l'utilisation de par défaut de cas ?
Il y a plusieurs façons différentes, nous arrivons à 'd', ce qui rend la tâche la plus simple. Sinon, nous avons un conditionnel dans les deux 1 et 2 cas et répétez 'd' trois fois; la première ne me dérange pas tant que ça, mais ce dernier est un problème de maintenance en attente de se produire.
Parfait ! je suppose que c'est la différence entre les approches de développeur moyen et T. J. Crowder !
LOL
Je pense qu'il voulait vraiment dire B.

OriginalL'auteur T.J. Crowder

À mon goût, soigneusement structurées imbriquée ternaire bat tous ceux désordre fi et commutateurs:

const isFoo = res.distance === 0;
const isBar = res.distance === 1 && res.difference > 3;
const isBaz = res.distance === 2 && res.difference > 5 && String(res.key).length > 5;

const word =
  isFoo ? 'a' :
  isBar ? 'b' :
  isBaz ? 'c' :
          'd' ;

OriginalL'auteur Andrey Mikhaylov - lolmaus

word = (res.distance === 0) ? 'a'
: (res.distance === 1 && res.difference > 3) ? 'b'
: (res.distance === 2 && res.difference > 5 && String(res.key).length > 5) ? 'c'
: 'd';

C'est une vieille question, mais c'est la façon dont je le ferais... je voudrais commencer par le cas par défaut, puis modifiez la variable ou passer inchangée, comme souhaité.

var word = 'd';
word = (res.distance === 0) ? 'a' : word;
word = (res.distance === 1 && res.difference > 3) ? 'b' : word
word = (res.distance === 2 && res.difference > 5 && String(res.key).length > 5) ? 'c' : word;

OriginalL'auteur K McCabe

Vous pourriez écrire une immédiatement appelé la fonction d'expression pour le rendre un peu plus lisible:

const word = (() =>  {
  if (res.distance === 0) return 'a';
  if (res.distance === 1 && res.difference > 3) return 'b';
  if (res.distance === 2 && res.difference > 5 && String(res.key).length > 5) return 'c';
  return 'd';
})();

Lien vers repl

OriginalL'auteur Yo Wakita

0

J'ai fait face à ce trop récemment et une recherche sur google m'a conduit ici, et je veux partager quelque chose que j'ai découvert récemment:

a && b || c

est presque la même chose que

a ? b : c

tant que b est truthy. Si b n'est pas truthy, vous pouvez contourner le problème en utilisant

!a && c || b

si c est truthy.

La première expression est évaluée comme (a && b) || c comme && a plus de priorité que ||.

Si a est truthy puis a && b permettrait d'évaluer à b si b est truthy, donc l'expression devient b || c qui évalue à b si c'est truthy, tout comme a ? b : c serait si a est truthy, et si a n'est pas truthy alors l'expression d'évaluer à c que nécessaire.

Alternance entre les && et || truc et ? et || dans les couches de la déclaration des astuces la non-imbriquées-ternaire eslint la règle, ce qui est assez soigné (bien que je ne recommande pas de le faire à moins qu'il n'y a pas d'autre moyen de sortir).

Une démonstration rapide:
```
true ? false ? true : true ? false : true ? true ? true : false : true : true
//which is interpreted as
true ? (false ? true : (true ? false : (true ? (true ? true : false) : true))) : true
//now with the trick in alternate levels
true ? (false && true || (true ? false : (true && (true ? true : false) || true))) : true
//all of these evaluate to false btw
```
J'ai effectivement triché un peu en choisissant un exemple où b est toujours truthy, mais si vous êtes juste de réglage des chaînes ensuite, cela devrait bien fonctionner en tant que même '0' est ironiquement truthy.

pouvez vous s'il vous plaît prendre un coup d'oeil à stackoverflow.com/questions/45508733/... j'essaie de trouver un moyen d'éviter la imbriquée opérateur ternaire et je pense que vos conseils pourraient travailler, mais vous ne savez pas exactement où l' || doit être utilisé.

OriginalL'auteur Ambyjkl
0

J'ai été en utilisant un commutateur(vrai) déclaration de ces cas. À mon avis, cette syntaxe se sent un peu plus élégante que imbriquée si/d'autre opérateurs
```
switch (true) {
  case condition === true :
    //do it
    break;
  case otherCondition === true && soOn < 100 :
    //do that
    break;
}
```
OriginalL'auteur ap-o

Vous devez vous connecter pour publier un commentaire.