Wie viele ternäre Operatoren sind in Java zulässig?

Einführung

Dieser Artikel ist auf Java beschränkt.

Neulich habe ich den folgenden Artikel geschrieben (ich habe den Titel geändert).

• Schreiben Sie keinen Code, wenn (isAdmin == true) in Java-Qiita

In diesem Artikel habe ich den ternären Operator als gutes Beispiel angegeben:

String userType = isAdmin ? "Administrator" : "Allgemeines";

Es gab jedoch einige Reaktionen, die der ternäre Operator schwer zu lesen war. Ich wollte es als einfaches Beispiel geben, aber ich habe es nicht genug erklärt, deshalb werde ich einen separaten Artikel schreiben.

Mein Fazit ist, dass ** ternäre Operatoren nur für einfache Dinge verwendet werden können **.

Was ist ein ternärer Operator?

Der ternäre Operator hat die folgende Form:

<Bedingter Ausdruck> ? <Wert wenn wahr> : <Wert wenn falsch>

Bevor ich darüber spreche, wie ich schreiben soll, schreibe ich ein Beispiel dafür, wie sehr ich mich "wie viel" fühle.

/*
 *Weiß(Fast kein Problem)
 */
String userType = isAdmin ? "Administrator" : "Allgemeines";

String userType = user.isAdmin() ? "Administrator" : "Allgemeines";

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

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

/*
 *Grau fast weiß
 */
return user.getType() == UserType.GUEST ? "Gastbenutzer" : user.getName();

/*
 *Grau fast schwarz
 */
String userName = user.getType() == UserType.GUEST ? "Gastbenutzer" : user.getName();

/*
 *schwarz(aus)
 */
String userName = user.getType() == UserType.GUEST ? "Die Gäste" : user.getType() == UserType.ADMIN ? "Administrator" : user.getName() + "Herr.";

Was ist der Standard?

Kehren Sie zur Definition des ternären Operators zurück.

<Bedingter Ausdruck> ? <Wert wenn wahr> : <Wert wenn falsch>

Im vorherigen Beispiel kann wie folgt klassifiziert werden, welche Art von Muster gut oder schlecht ist.

• Weiß (fast kein Problem)
• Bedingter Ausdruck
• Boolesche Variable
• Methode, die einen Booleschen Wert zurückgibt
• Wert wenn wahr / falsch
• Konstante * enum
• Einfacher Anruf wie Getter
• Grau
• Der bedingte Ausdruck enthält einen Vergleich mit == oder ! =
• Schwarz (aus)
• Verschachtelt
• Der Wert bei true / false ist kein einfacher Aufruf

Der Grund, warum ternäre Operatoren häufig nicht gemocht werden, besteht darin, dass die Kosten für die lexikalische Analyse und die grammatikalische Analyse hoch sind, z. B. wie viel ein bedingter Ausdruck ist und wie viel der Wert ist, wenn er wahr ist. Der Grund, warum Vergleiche mit "==" und "! =" Nicht gut sind, ist, dass sie mit der Substitution "=" verwechselt werden und für einen Moment verwirrt sind.

Deshalb versuche ich, alles andere als einfaches Schreiben zu vermeiden.

Wie schreibt man

Sie könnten so etwas schreiben, aber ich mag es nicht, weil es eine negative Lösung ist.

String userName; //Die Initialisierung hier ist nutzlos, also nicht

if (user.getType() == UserType.GUEST) {
    userName = "Die Gäste";
} else if (user.userType() == UserType.ADMIN) {
    userName = "Administrator";
} else {
    userName = user.getName() + "Herr.";
}

Wenn Sie selbst sind, erstellen Sie eine Methode wie folgt. In diesem Fall kann es als Methode der User-Klasse implementiert werden.

Dieses Mal habe ich eine if-Anweisung erstellt, die mit dem ursprünglichen bedingten Ausdruck übereinstimmt, aber im Fall von enum verwende ich häufig eine switch-Anweisung.

private String getName(User user) {
    if (user.getType() = UserType.GUEST) {
        return "Die Gäste";
    } else if (user.getType() == UserType.ADMIN) {
        return "Administrator";
    } else {
        return user.getName() + "Herr.";
    }
}

//Anrufer
String userName = getName(user);

abschließend

Es gab mehr Muster, die schwerer zu lesen waren als ich erwartet hatte. Ich denke, es ist übertrieben, ternäre Operatoren zu verbieten, aber ich denke, es ist in Ordnung, nur einfache zu verwenden.