Opérateurs ternaires en JavaScript sans «autre»

J'ai toujours dû mettre nulldans les autres conditions qui n'ont rien. Y a-t-il quelque chose autour? Par exemple

condition ? x = true : null;

en gros, y a-t-il un moyen de faire:

condition ? x = true;

Maintenant, il apparaît comme une erreur de syntaxe

Pour info, voici un vrai exemple de code:

!defaults.slideshowWidth ? defaults.slideshowWidth = obj.find('img').width()+'px' : null;

Tout d'abord, une expression ternaire ne remplace pas une construction if / else - c'est un équivalent à une construction if / else qui renvoie une valeur. Autrement dit, une clause if / else est du code, une expression ternaire est une expression , ce qui signifie qu'elle renvoie une valeur.

Cela signifie plusieurs choses:

• utilisez des expressions ternaires uniquement lorsque vous avez une variable sur le côté gauche de la =valeur de retour
• utiliser uniquement des expressions ternaires lorsque la valeur renvoyée doit être l'une des deux valeurs (ou utiliser des expressions imbriquées si cela convient)
• chaque partie de l'expression (après? et après:) doit renvoyer une valeur sans effets secondaires (l'expression x = truerenvoie true car toutes les expressions renvoient la dernière valeur, mais change également x sans que x n'ait d'effet sur la valeur renvoyée)

En bref - l'utilisation `` correcte '' d'une expression ternaire est

var resultofexpression = conditionasboolean ? truepart: falsepart;

Au lieu de votre exemple condition ? x=true : null ;, où vous utilisez une expression ternaire pour définir la valeur de x, vous pouvez utiliser ceci:

 condition && (x = true);

Ceci est toujours une expression et peut donc ne pas passer la validation, donc une approche encore meilleure serait

 void(condition && x = true);

Le dernier passera la validation.

Mais là encore, si la valeur attendue est un booléen, utilisez simplement le résultat de l'expression de condition elle-même

var x = (condition); // var x = (foo == "bar");

MISE À JOUR En ce qui concerne votre échantillon, c'est probablement plus approprié:

defaults.slideshowWidth = defaults.slideshowWidth || obj.find('img').width()+'px';

Non, il faut trois opérandes. C'est pourquoi on les appelle ternaires opérateurs .

Cependant, pour ce que vous avez comme exemple, vous pouvez faire ceci:

if(condition) x = true;

Bien qu'il soit plus sûr d'avoir des accolades si vous devez ajouter plus d'une instruction à l'avenir:

if(condition) { x = true; }

Edit: Maintenant que vous mentionnez le code réel dans lequel votre question s'applique à:

if(!defaults.slideshowWidth)
    { defaults.slideshowWidth = obj.find('img').width()+'px'; }

Le plus souvent, les gens utilisent des opérateurs logiques pour raccourcir la syntaxe de l'instruction:

!defaults.slideshowWidth &&
  (defaults.slideshowWidth = obj.find('img').width()+'px');

Mais dans votre cas particulier, la syntaxe peut être encore plus simple

defaults.slideshowWidth = defaults.slideshowWidth || obj.find('img').width()+'px';

Ce code renverra la defaults.slideshowWidthvaleur si le defaults.slideshowWidthest évalué à vrai et la obj.find('img').width()+'px'valeur dans le cas contraire.

Voir l' évaluation de court-circuit des opérateurs logiques pour plus de détails.

var x = condition || null;

Tu pourrais écrire

x = condition ? true : x;

Ainsi, x n'est pas modifié lorsque la condition est fausse.

Ceci est alors équivalent à

if (condition) x = true

ÉDITER:

!defaults.slideshowWidth 
      ? defaults.slideshowWidth = obj.find('img').width()+'px' 
      : null 

Il existe quelques alternatives - je ne dis pas que ce sont meilleures / pires - simplement des alternatives

La transmission de null comme troisième paramètre fonctionne car la valeur existante est nulle. Si vous refactorisez et modifiez la condition, il y a un risque que ce ne soit plus vrai. Passer la valeur existante comme 2ème choix dans les gardes ternaires contre ceci:

!defaults.slideshowWidth = 
      ? defaults.slideshowWidth = obj.find('img').width()+'px' 
      : defaults.slideshowwidth 

Plus sûr, mais peut-être pas aussi agréable à regarder, et plus de frappe. En pratique, j'écrirais probablement

defaults.slideshowWidth = defaults.slideshowWidth 
               || obj.find('img').width()+'px'

Dans votre cas, je vois l'opérateur ternaire comme redondant. Vous pouvez affecter la variable directement à l'expression, en utilisant les opérateurs ||, &&.

!defaults.slideshowWidth ? defaults.slideshowWidth = obj.find('img').width()+'px' : null ;

va devenir :

defaults.slideshowWidth = defaults.slideshowWidth || obj.find('img').width()+'px';

C'est plus clair, c'est plus du style "javascript".

Qu'en est-il simplement

    if (condition) { code if condition = true };

Pour utiliser un opérateur ternaire sans autre à l'intérieur d'un tableau ou d'une déclaration d'objet, vous pouvez utiliser l'opérateur de propagation ES6 ...()

const cond = false;
const arr = [
  ...(cond ? ['a'] : []),
  'b',
];
    // ['b']

Et pour les objets:

const cond = false;
const obj = {
  ...(cond ? {a: 1} : {}),
  b: 2,
};
    // {b: 2}

source primaire