À la défense de l’opérateur ternaire | de Kas van ‘t Veer | décembre 2022

Adoptez un style de codage immuable et fonctionnel

Les ternaires ont parfois mauvaise réputation. Ils sont souvent décrits comme difficiles à lire, généralement en raison de leur syntaxe plus abstraite que le if-else en prose. Cependant, ils présentent des avantages uniques par rapport à leurs alternatives une fois que vous vous êtes familiarisé avec eux.

Si vous n’êtes pas encore sûr à 100% du fonctionnement d’un opérateur ternaire, consultez mon article Opérateurs ternaires pour débutants. Dans cet article, nous avons examiné l’exemple JavaScript suivant d’une instruction ternaire :

Et un code équivalent utilisant if-else :

Nous allons maintenant approfondir les raisons pour lesquelles l’opérateur ternaire peut être une option supérieure et dans quels cas il doit ou ne doit pas être utilisé.

Brièveté

Tout d’abord, l’exemple ternaire est une seule ligne, où l’équivalent if-else est de six lignes, bien que cela puisse varier en fonction de votre style de codage préféré.

La syntaxe est objectivement plus concise de multiples façons. Tout d’abord, la version if-else a l’identifiant name répété trois fois, alors que la version ternaire ne l’a qu’une seule fois. Nous pouvons également voir deux missions se dérouler au lieu d’une. Enfin, la version ternaire n’oblige pas le lecteur à examiner la portée et l’indentation, contrairement à la version if-else.

Immutabilité

Un autre grand avantage de l’opérateur ternaire est la possibilité d’écrire du code plus immuable. On voit que la variable est définie et immédiatement affectée dans la version ternaire du code. Il n’est plus modifié. En revanche, avec la version if-else, la variable est d’abord déclarée sur une ligne, et ce n’est que plus tard, sur une autre ligne, qu’elle est modifiée pour que la valeur correcte lui soit affectée.

Étant donné que la variable est immédiatement affectée à la valeur correcte, nous pouvons utiliser constalors que dans le if-else nous sommes obligés d’utiliser let. La const mot-clé en JavaScript nous empêche de réaffecter la variable plus jamais. De nombreuses autres langues ont des mots-clés similaires qui font une chose similaire.

Alors, qu’y a-t-il de si génial à utiliser const Au lieu? Cela permet au lecteur de supposer en toute sécurité que la variable ne sera jamais réaffectée ailleurs dans le code. Cela réduit la gamme de choses qui peuvent se produire dans les lignes de code ci-dessous. Ceci, à son tour, rend le code plus prévisible et, par conséquent, plus facile à lire et à réfléchir.

Expressions

Les deuxième et troisième opérandes de l’opérateur ternaire (resultIfTrue et resultIfFalse dans l’exemple ci-dessus) ne peuvent être que des expressions. Cela contraste avec la version if-else illustrée ci-dessus, dans laquelle le bloc de code peut contenir n’importe quel code après l’instruction if ou else. Cela rend l’opérateur ternaire plus prévisible que if-else. Le lecteur peut être assuré que soit resultIfTrue ou resultIfFalse serait le résultat, et n’a donc pas à chercher dans d’autres parties du code.

Cela facilite l’analyse mentale du code en une fraction de seconde. Cela garantit également que la définition de la variable et que son affectation ne « s’écartera » pas accidentellement lorsque davantage de code sera ajouté ultérieurement.

Étant donné que l’opérateur ternaire est également une expression, il peut être utilisé de manière pratique dans le cadre de définitions plus larges, une valeur dans un littéral d’objet, un paramètre de fonction, un élément dans un littéral de tableau, ou vous pouvez obtenir le scénario suivant :

const response = {
body: data,
status: error ? error.status : 200
}

Cela peut rendre les définitions d’objets plus grandes beaucoup plus faciles à lire puisque le lecteur peut voir la valeur d’une clé directement à l’intérieur de la définition d’objet au lieu d’être déclarée ailleurs dans une variable.

Plus abstrait

Bien sûr, l’opérateur ternaire est plus abstrait et se lit moins comme un vrai langage. C’est un inconvénient pour ceux qui ne le connaissent pas. Un débutant total peut être capable de déchiffrer la simple affectation if-else simplement par intuition, mais il est très peu probable qu’il puisse comprendre l’opérateur ternaire sans documentation ni tutoriels.

Cependant, cela ne devrait avoir d’importance que lorsque vous écrivez du code à des fins éducatives destiné aux débutants. Pour tout code écrit pour les amateurs ou les professionnels, ce n’est pas un problème.

Petit espace

Un inconvénient peut-être plus pertinent est que l’opérateur ternaire ne laisse pas beaucoup d’espace pour les expressions. Dans la section suivante, nous examinerons un style qui vous permet d’avoir une ligne distincte pour chaque opérande. Cependant, si vous ne pouvez pas facilement écrire chaque opérande en une seule expression, l’opérateur ternaire n’est généralement pas le bon choix.

Moins souple

Tout comme l’opérateur ternaire n’acceptant que des expressions peut être un avantage, cela rend l’opérateur ternaire moins flexible. Pour une logique conditionnelle très complexe, if-else est généralement préféré.

Parce que l’opérateur ternaire semble si abstrait, le style est important. La façon dont vous les répartissez sur plusieurs lignes et la façon dont elles sont indentées peuvent faire la différence entre un code clair et succinct et un puzzle trop compliqué.

Chaque opérande sur une seule ligne

Si vous souhaitez utiliser un opérateur ternaire, mais que l’intégralité de l’expression ternaire ne tient pas sur une seule ligne, voici le style le plus courant à utiliser :

const result = someBooleanFunction(arg1, arg2, arg3)
? aPrettyLongResultFunction(arg4, arg5, arg6)
: anEvenLongerResultFunction(arg7, arg8, arg9)

Il est facile de s’habituer à la lecture car chaque opérande est sur une seule ligne, ce qui rend immédiatement évident qui est qui.

Opérandes multilignes

Peut-être qu’une seule ligne n’est pas suffisante pour certains ou tous les opérandes. Dans ce cas, vous pouvez placer les opérandes sur plusieurs lignes. Mais dans ce cas, vous voudrez préciser où chaque opérande commence et se termine en vous assurant que chacun est entouré de parenthèses ou d’accolades, même si ce n’est techniquement pas nécessaire pour que le code se compile. Cela permet au lecteur de reconnaître immédiatement les opérandes sans ambiguïté. Par exemple:

const result = someCondition
? (
// multiline expression here
)
: (
// another multiline expression here
)

En JavaScript, ce style pourrait vous permettre d’ajouter des objets existants tout en étant entièrement immuable conditionnellement :

const result = someCondition
? {
...baseObject,
extraProperty1: 'a',
extraProperty2: 'b',
}
: {
...baseObject,
extraProperty3: 'c',
extraProperty4: 'd',
}

Notez qu’ici les expressions ne sont pas enveloppées dans () puisqu’ils sont déjà enveloppés {}indiquant clairement au lecteur où chaque opérande commence et se termine.

Nidification des ternaires

L’imbrication d’expressions ternaires est assez controversée parmi les développeurs. En effet, de nombreux exemples existent dans la nature d’expressions ternaires imbriquées extrêmement difficiles à lire, mais il n’est pas nécessaire qu’il en soit ainsi.

Il existe une astuce pour imbriquer très efficacement et clairement les expressions ternaires ! Vous ne voudrez mettre qu’une expression ternaire comme dernier opérande de l’expression ternaire globale. Plus simplement, vous voulez que ?le sable :s de toujours alterner, de sorte que vous n’ayez jamais deux ?s sans : entre. Indentez ensuite pour obtenir le format suivant :

const result =
question1 ?
answer1
: question2 ?
answer2
: question3 ?
answer3
:
defaultAnswer;

L’astuce clé pour comprendre ce style ternaire imbriqué est de considérer chaque condition comme une question (elle se termine même par un point d’interrogation !). Ensuite, sur la ligne ci-dessous, la « réponse » à la question est en retrait. Cela peut se lire très naturellement car, dans le monde non codant, ce format indenté est également utilisé.

Imaginez un exemple réel où nous souhaitons définir une ligne d’adresse spécifique à un pays, et cela ressemble à ceci :

Très succinct et totalement immuable ! Si vous le souhaitez, vous pouvez mettre une nouvelle ligne avant chaque : clarté supplémentaire.

Bien que les expressions ternaires semblent un peu menaçantes pour un œil non averti, il est facile de s’y habituer et de commencer à en récolter les bénéfices. Une fois que vous vous êtes familiarisé avec le fonctionnement des expressions ternaires et que vous avez essayé de trouver le meilleur style, elles vous permettent d’écrire du code élégant.

Cela vous aide également à adopter un style de codage plus immuable, et donc fonctionnel. Avec moins de mutabilité et plus constness, il y a moins de place pour la confusion et les bugs.

En Python, les opérateurs ternaires sont un peu différents. Voici un exemple :

name = expressionIfTrue if condition else expressionIfFalse

Il fonctionne essentiellement de la même manière que le ?: style, bien qu’il soit important de réaliser que l’ordre des paramètres est différent. La condition est au milieu plutôt qu’au début.

Cela a l’avantage de se lire davantage comme une phrase anglaise et donc d’être plus facile à comprendre simplement par intuition. L’inconvénient est que les deux expressions ne sont plus adjacentes mais séparées par la condition. Cette syntaxe ne permet pas de les imbriquer aussi bien que le ?:.

Par conséquent, je recommanderais plus de prudence lors de l’imbrication d’opérateurs ternaires en Python. Au lieu de cela, vous pouvez utiliser le match case syntaxe. Il est certainement plus verbeux mais sera beaucoup plus lisible, et ce compromis en vaut peut-être la peine. Une autre option serait d’extraire toute la logique dans une fonction distincte et d’utiliser if elif else déclarations qui sont chacune immédiatement suivies d’un return.

Si vous connaissez un style qui rend les ternaires imbriqués lisibles en Python, faites-le nous savoir dans les commentaires !