Combien d'opérateurs ternaires sont autorisés en Java

introduction

Cet article est limité à Java.

L'autre jour, j'ai écrit l'article suivant (j'ai changé le titre).

• N'écrivez pas de code si (isAdmin == true) dans Java-Qiita

Dans cet article, j'ai donné l'opérateur ternaire comme un bon exemple:

String userType = isAdmin ? "Administrateur" : "Général";

Cependant, il y a eu pas mal de réactions que l'opérateur ternaire était difficile à lire. J'avais l'intention de le donner à titre d'exemple simple, mais je ne l'ai pas suffisamment expliqué, alors j'écrirai un article séparé.

Ma conclusion est que ** les opérateurs ternaires ne peuvent être utilisés que pour des choses simples **.

Qu'est-ce qu'un opérateur ternaire?

L'opérateur ternaire a la forme suivante:

<Expression conditionnelle> ? <Valeur lorsqu'elle est vraie> : <Valeur lorsque faux>

Avant de parler de la manière d'écrire, j'écrirai un exemple de ce que je ressens "combien".

/*
 *blanc(Presque pas de problème)
 */
String userType = isAdmin ? "Administrateur" : "Général";

String userType = user.isAdmin() ? "Administrateur" : "Général";

UserType userType = user.isAdmin() ? UserType.ADMIN : UserType.NORMAL;

String userName = user.isAdmin() ? "Administrateur" : user.getName();

/*
 *Gris proche du blanc
 */
return user.getType() == UserType.GUEST ? "Utilisateur invité" : user.getName();

/*
 *Gris proche du noir
 */
String userName = user.getType() == UserType.GUEST ? "Utilisateur invité" : user.getName();

/*
 *noir(en dehors)
 */
String userName = user.getType() == UserType.GUEST ? "Les invités" : user.getType() == UserType.ADMIN ? "Administrateur" : user.getName() + "M.";

Quelle est la norme

Revenez à la définition de l'opérateur ternaire.

<Expression conditionnelle> ? <Valeur lorsqu'elle est vraie> : <Valeur lorsque faux>

Dans l'exemple précédent, le type de motif qui est bon ou mauvais peut être classé comme suit.

• Blanc (presque pas de problème)
• Expression conditionnelle
• variable booléenne
• Méthode qui retourne booléen
• Valeur quand true / false
• Constant * enum
• Appel simple tel que getter
• Gris
• L'expression conditionnelle contient une comparaison avec == ou ! =
• Coupure électrique)
• Imbriqué
• La valeur quand true / false est autre qu'un simple appel

La raison pour laquelle les opérateurs ternaires ne sont souvent pas appréciés est que le coût de l'analyse lexicale et de l'analyse grammaticale à l'esprit est élevé, comme la valeur d'une expression conditionnelle et la valeur lorsqu'elle est vraie. De plus, la raison pour laquelle les comparaisons avec == et ! = Ne sont pas bonnes est qu'elles sont confondues avec la substitution = et sont confuses pendant un moment.

Par conséquent, j'essaie d'éviter autre chose que la simple écriture.

Comment écrire

Vous pourriez écrire quelque chose comme ça, mais je n'aime pas ça parce que c'est une solution négative.

String userName; //L'initialisation ici est inutile, alors ne le faites pas

if (user.getType() == UserType.GUEST) {
    userName = "Les invités";
} else if (user.userType() == UserType.ADMIN) {
    userName = "Administrateur";
} else {
    userName = user.getName() + "M.";
}

Si vous êtes vous-même, créez une méthode comme suit. Dans ce cas, il peut être implémenté en tant que méthode de la classe User.

Cette fois, j'ai fait une instruction if pour correspondre à l'expression conditionnelle d'origine, mais dans le cas de enum, j'utilise souvent une instruction switch.

private String getName(User user) {
    if (user.getType() = UserType.GUEST) {
        return "Les invités";
    } else if (user.getType() == UserType.ADMIN) {
        return "Administrateur";
    } else {
        return user.getName() + "M.";
    }
}

//Votre interlocuteur
String userName = getName(user);

en conclusion

Il y avait plus de modèles plus difficiles à lire que ce à quoi je m'attendais. Je pense qu'il est exagéré d'interdire les opérateurs ternaires, mais je pense qu'il est normal de n'utiliser que des opérateurs simples.