Avantages de l'utilisation de l'opérateur conditionnel?: (Ternaire)

Quels sont les avantages et les inconvénients de l'opérateur?: Par rapport à l'instruction if-else standard. Les plus évidents étant:

Conditionnel?: Opérateur

• Plus court et plus concis lorsqu'il s'agit de comparaisons et d'affectations directes de valeurs
• Ne semble pas aussi flexible que la construction if / else

Standard If / Else

• Peut être appliqué à plus de situations (comme les appels de fonction)
• Souvent inutilement longs

La lisibilité semble varier pour chacun en fonction de l'énoncé. Pendant un petit moment après avoir été exposé à l'opérateur?:, Il m'a fallu un certain temps pour comprendre exactement comment cela fonctionnait. Recommanderiez-vous de l'utiliser dans la mesure du possible, ou de m'en tenir à si / sinon étant donné que je travaille avec de nombreux non-programmeurs?

Je recommanderais essentiellement de ne l'utiliser que lorsque l'instruction résultante est extrêmement courte et représente une augmentation significative de la concision par rapport à l'équivalent if / else sans sacrifier la lisibilité.

Bon exemple:

int result = Check() ? 1 : 0;

Mauvais exemple:

int result = FirstCheck() ? 1 : SecondCheck() ? 1 : ThirdCheck() ? 1 : 0;

Ceci est à peu près couvert par les autres réponses, mais "c'est une expression" n'explique pas vraiment pourquoi c'est si utile ...

Dans des langages comme C ++ et C #, vous pouvez définir des champs en lecture seule locaux (dans un corps de méthode) en les utilisant. Cela n'est pas possible avec une instruction if / then conventionnelle car la valeur d'un champ en lecture seule doit être affectée dans cette instruction unique:

readonly int speed = (shiftKeyDown) ? 10 : 1;

n'est pas la même chose que:

readonly int speed;  
if (shifKeyDown)  
    speed = 10;    // error - can't assign to a readonly
else  
    speed = 1;     // error  

De la même manière, vous pouvez incorporer une expression tertiaire dans un autre code. En plus de rendre le code source plus compact (et dans certains cas plus lisible en conséquence), il peut également rendre le code machine généré plus compact et efficace:

MoveCar((shiftKeyDown) ? 10 : 1);

... peut générer moins de code que d'avoir à appeler la même méthode deux fois:

if (shiftKeyDown)
    MoveCar(10);
else
    MoveCar(1);

Bien sûr, c'est aussi une forme plus pratique et concise (moins de frappe, moins de répétition et peut réduire le risque d'erreurs si vous devez dupliquer des morceaux de code dans un if / else). Dans des cas de "modèle commun" propres comme celui-ci:

object thing = (reference == null) ? null : reference.Thing;

... il est tout simplement plus rapide à lire / analyser / comprendre (une fois que vous y êtes habitué) que l'équivalent si / else long et long, donc il peut vous aider à «grok» le code plus rapidement.

Bien sûr, ce n'est pas parce que c'est utile que c'est la meilleure chose à utiliser dans tous les cas. Je conseillerais de ne l'utiliser que pour de courts morceaux de code où la signification est claire (ou rendue plus claire) en utilisant ?:- si vous l'utilisez dans un code plus complexe, ou si vous imbriquez des opérateurs ternaires les uns dans les autres, cela peut rendre le code horriblement difficile à lire .

Je choisis généralement un opérateur ternaire quand j'aurais beaucoup de code en double autrement.

if (a > 0)
    answer = compute(a, b, c, d, e);
else
    answer = compute(-a, b, c, d, e);

Avec un opérateur ternaire, ceci pourrait être accompli avec ce qui suit.

answer = compute(a > 0 ? a : -a, b, c, d, e); 

Je trouve cela particulièrement utile lors du développement Web si je souhaite définir une variable sur une valeur envoyée dans la demande si elle est définie ou sur une valeur par défaut si ce n'est pas le cas.

Une utilisation vraiment cool est:

x = foo ? 1 :
    bar ? 2 :
    baz ? 3 :
          4;

L'opérateur conditionnel est idéal pour les conditions courtes, comme ceci:

varA = boolB ? valC : valD;

Je l'utilise occasionnellement car cela prend moins de temps pour écrire quelque chose de cette façon ... malheureusement, ce branchement peut parfois être manqué par un autre développeur parcourant votre code. De plus, le code n'est généralement pas aussi court, donc j'aide généralement la lisibilité en mettant le? et: sur des lignes séparées, comme ceci:

doSomeStuffToSomething(shouldSomethingBeDone()
    ? getTheThingThatNeedsStuffDone()
    : getTheOtherThingThatNeedsStuffDone());

Cependant, le gros avantage de l'utilisation des blocs if / else (et pourquoi je les préfère) est qu'il est plus facile d'entrer plus tard et d'ajouter une logique supplémentaire à la branche,

if (shouldSomethingBeDone()) {
    doSomeStuffToSomething(getTheThingThatNeedsStuffDone());
    doSomeAdditionalStuff();
} else {
doSomeStuffToSomething(getTheOtherThingThatNeedsStuffDone());
}

ou ajoutez une autre condition:

if (shouldSomethingBeDone()) {
    doSomeStuffToSomething(getTheThingThatNeedsStuffDone());
    doSomeAdditionalStuff();
} else if (shouldThisOtherThingBeDone()){
    doSomeStuffToSomething(getTheOtherThingThatNeedsStuffDone());
}

Donc, en fin de compte, c'est une question de commodité pour vous maintenant (plus courte à utiliser:?) Vs de commodité pour vous (et les autres) plus tard. C'est un appel au jugement ... mais comme tous les autres problèmes de formatage de code, la seule vraie règle est d'être cohérent et d'être visuellement courtois avec ceux qui doivent maintenir (ou noter!) Votre code.

(tout le code est compilé à l'œil)

Une chose à reconnaître lors de l'utilisation de l'opérateur ternaire qu'il s'agit d'une expression et non d'une instruction.

Dans les langages fonctionnels comme le schéma, la distinction n'existe pas:

(si (> ab) ab)

Conditionnel?: Opérateur "Ne semble pas aussi flexible que la construction if / else"

Dans les langages fonctionnels, c'est.

Lors de la programmation dans des langages impératifs, j'applique l'opérateur ternaire dans des situations où j'utiliserais généralement des expressions (affectation, instructions conditionnelles, etc.).

Bien que les réponses ci-dessus soient valides et que je conviens que la lisibilité soit importante, il y a 2 autres points à considérer:

1. En C # 6, vous pouvez avoir des méthodes avec corps d'expression.

Cela rend particulièrement concis l'utilisation du ternaire:

string GetDrink(DayOfWeek day) 
   => day == DayOfWeek.Friday
      ? "Beer" : "Tea";

2. Le comportement diffère en ce qui concerne la conversion de type implicite.

Si vous avez des types T1et T2que les deux peuvent être implicitement convertis en T, alors ce qui suit ne fonctionne pas :

T GetT() => true ? new T1() : new T2();

(car le compilateur essaie de déterminer le type de l'expression ternaire et il n'y a pas de conversion entre T1et T2.)

En revanche, la if/elseversion ci-dessous fonctionne:

T GetT()
{
   if (true) return new T1();
   return new T2();
}

car T1est converti en Tet est doncT2

Parfois, cela peut rendre l'attribution d'une valeur booléenne plus facile à lire au premier coup d'œil:

// With
button.IsEnabled = someControl.HasError ? false : true;

// Without
button.IsEnabled = !someControl.HasError;

Si je mets une valeur et que je sais que ce sera toujours une ligne de code pour le faire, j'utilise généralement l'opérateur ternaire (conditionnel). S'il y a une chance que mon code et ma logique changent à l'avenir, j'utilise un if / else car c'est plus clair pour les autres programmeurs.

Un autre intérêt pour vous peut être le ?? opérateur .

L'avantage de l'opérateur conditionnel est qu'il s'agit d'un opérateur. En d'autres termes, il renvoie une valeur. Puisqu'il ifs'agit d'une instruction, elle ne peut pas renvoyer de valeur.

Je recommanderais de limiter l'utilisation de l'opérateur ternaire (? :) à une simple attribution d'une seule ligne logique if / else. Quelque chose ressemblant à ce modèle:

if(<boolCondition>) {
    <variable> = <value>;
}
else {
    <variable> = <anotherValue>;
}

Peut être facilement converti en:

<variable> = <boolCondition> ? <value> : <anotherValue>;

J'éviterais d'utiliser l'opérateur ternaire dans des situations qui nécessitent if / else if / else, imbriqué if / else, ou if / else une logique de branche qui aboutit à l'évaluation de plusieurs lignes. L'application de l'opérateur ternaire dans ces situations entraînerait probablement un code illisible, déroutant et ingérable. J'espère que cela t'aides.

L'utilisation de l '? opérateur dans par exemple. MS Visual C ++, mais c'est vraiment une chose spécifique au compilateur. Le compilateur peut en fait optimiser la branche conditionnelle dans certains cas.

Le scénario que je me retrouve le plus à utiliser est celui des valeurs par défaut et en particulier des retours

return someIndex < maxIndex ? someIndex : maxIndex;

Ce sont vraiment les seuls endroits où je trouve ça sympa, mais pour eux je le fais.

Cependant, si vous recherchez un booléen, cela peut parfois sembler une chose appropriée à faire:

bool hey = whatever < whatever_else ? true : false;

Parce que c'est si facile à lire et à comprendre, mais cette idée doit toujours être rejetée pour le plus évident:

bool hey = (whatever < whatever_else);

Si vous avez besoin de plusieurs succursales dans la même condition, utilisez un if:

if (A == 6)
  f(1, 2, 3);
else
  f(4, 5, 6);

Si vous avez besoin de plusieurs branches avec des conditions différentes, alors si le nombre d'instructions fait boule de neige, vous voudrez utiliser le ternaire:

f( (A == 6)? 1: 4, (B == 6)? 2: 5, (C == 6)? 3: 6 );

Vous pouvez également utiliser l'opérateur ternaire lors de l'initialisation.

const int i = (A == 6)? 1 : 4;

Faire cela avec if est très compliqué:

int i_temp;
if (A == 6)
   i_temp = 1;
else
   i_temp = 4;
const int i = i_temp;

Vous ne pouvez pas placer l'initialisation dans if / else, car cela change la portée. Mais les références et les variables const ne peuvent être liées qu'à l'initialisation.

L'opérateur ternaire peut être inclus dans une rvalue, alors qu'un if-then-else ne le peut pas; d'autre part, un if-then-else peut exécuter des boucles et d'autres instructions, tandis que l'opérateur ternaire ne peut exécuter que des rvalues ​​(éventuellement vides).

Dans le même ordre d'idées, les && et || Les opérateurs autorisent certains modèles d'exécution qui sont plus difficiles à implémenter avec if-then-else. Par exemple, si l'on a plusieurs fonctions à appeler et que l'on souhaite exécuter un morceau de code si l'une d'entre elles échoue, cela peut être fait très bien en utilisant l'opérateur &&. Le faire sans cet opérateur nécessitera un code redondant, un goto ou une variable d'indicateur supplémentaire.

Avec C # 7 , vous pouvez utiliser la nouvelle fonctionnalité de locals de référence pour simplifier l'affectation conditionnelle de variables compatibles ref. Alors maintenant, non seulement vous pouvez faire:

int i = 0;

T b = default(T), c = default(T);

// initialization of C#7 'ref-local' variable using a conditional r-value⁽¹⁾

ref T a = ref (i == 0 ? ref b : ref c);

... mais aussi le plus merveilleux:

// assignment of l-value⁽²⁾ conditioned by C#7 'ref-locals'

(i == 0 ? ref b : ref c) = a;

Cette ligne de code attribue la valeur de aà soit bou c, en fonction de la valeur de i.