Wie vermeidet man das Auspacken einer Variablen?

Question

Wie vermeide ich die Verwendung der! Eine Operation, die eine Kraftentpackung ausführt, ist normalerweise eine schlechte Option.

Was ist die bessere Option mit Code wie der folgenden, wo die Verwendung macht es den Code einfacher aussehen und wegen der Überprüfung der Variablen! Angerufen wird nie Null und so kann nicht abstürzen.

Mein Kursleiter stellte uns dem (!) Operator vor und forderte uns auf, ihn nie wieder zu benutzen. Uns sagen, warum natürlich, dass es unsere App zum Absturz bringen wird, wenn das optionale NULL ist.

Allerdings finde ich mich in Situationen wie diesen, in denen der Knall-Operator die prägnanteste und sicherste Option zu sein scheint.

func fullName() -> String { 
    if middleName == nil { 
     return "\(firstName) \(lastName)" 
    }else{ 
     return "\(firstName) \(middleName!) \(lastName)" 
    } 
} 

Gibt es eine bessere Möglichkeit, so etwas zu tun?

Auch hier ist die ganze Klasse, wenn sich jemand fragt.

class CPerson{ 
    var firstName: String 
    var middleName: String? 
    var lastName: String 

    init(firstName: String, middleName: String?, lastName: String) { 
     self.firstName = firstName 
     self.middleName = middleName 
     self.lastName = lastName 
    } 
    convenience init(firstName: String, lastName: String) { 
     self.init(firstName: firstName, middleName: nil, lastName: lastName) 
    } 
    func fullName() -> String { 
     if middleName == nil { 
      return "\(firstName) \(lastName)" 
     }else{ 
      return "\(firstName) \(middleName!) \(lastName)" 
     } 
    } 
} 

Mein Lehrer sagte O_O

Answer 1

die if let oder guard Konstrukte verwenden:

func fullName() -> String { 
    if let middleName = middleName { 
     return "\(firstName) \(middleName) \(lastName)" 

    } else { 
     return "\(firstName) \(lastName)" 
    } 
} 

func fullName() -> String { 
    guard let middleName = middleName else { 
     return "\(firstName) \(lastName)" 
    } 
    return "\(firstName) \(middleName) \(lastName)" 
} 

ich die guard Aussage in der Vollständigkeit halber gesetzt haben, aber wie andere bemerkt haben, dies wird häufig auch in einem Fehler verwendet/Fehlerfall.

Ich würde auch davon abraten, String-Interpolation für Strings zu verwenden. Sie sind bereits Zeichenfolgen, es ist nicht erforderlich, die description jedes Namens in einer neuen Zeichenfolge zu verwenden.

Betrachten return firstName + " " + lastName. Siehe Difference between String interpolation and String initializer in Swift für Fälle, in denen die String-Interpolation zu einem unerwarteten Ergebnis führen kann.

Answer 2

Was hast du arbeiten und in der Tat: „Wenn ich Sie sehe den Knall-Operator, wir kämpfen werden“, wenn Sie sich nicht null wissen, mit! ist ein korrekter Weg, um es auszupacken.

Swift verfügt jedoch über eine Funktion namens optionale Bindung (https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html).

In Ihrem Fall würde es so sein:

func fullName() -> String { 
     if let middle = middleName { 
      return "\(firstName) \(middleName) \(lastName)" 
     } else { 
      return "\(firstName) \(lastName)" 
     } 
    } 

Was die optionale Bindung tut, ist, wie Apple in den obigen Link sagt: „Sie verwenden optionale Bindung, um herauszufinden, ob ein optionaler Wert enthält, und wenn ja, diesen Wert als temporäre Konstante oder Variable verfügbar zu machen. " Innerhalb Ihrer Klammern haben Sie Zugriff auf middle und können es als bekanntes Nicht-Nil verwenden.

Sie können diese auch verketten, sodass Sie Zugriff auf mehrere temporäre Konstanten haben und if-Anweisungen nicht verketten müssen. Und Sie können sogar eine where Klausel verwenden, um eine optionale Bedingung auszuwerten. Wieder von der Apple-docs oben:

if let firstNumber = Int("4"), secondNumber = Int("42") where firstNumber < secondNumber { 
    print("\(firstNumber) < \(secondNumber)") 
} 

Answer 3

Ihr Lehrer ist im Großen und Ganzen richtig. Definitiv in diesem Fall. Es gibt keinen Grund, diesen speziellen Fall zu machen und doppelten Code zu erzwingen.

Dies verbindet nur alle Nicht-Nil-Teile des Namens mit Leerzeichen. Die anderen Antworten hier sind auch in Ordnung, aber sie skalieren nicht so gut, um weitere optionale Teile hinzuzufügen (wie ein "Mr." -Titel oder "Jr." -Suffix).

(Dies ist in swift3 Syntax. Swift 2 sehr ähnlich ist, ist es joinWithSeparator(_:) statt.)

Answer 4

Bevor eine optionale Variable Abwickeln sollten Sie müssen für nil überprüfen sonst Ihre Anwendung abstürzt, wenn die Variable nil enthalten.

1. if let
2. guard
3. if-else
4. mit ternären Operator
5. Nil koaleszierende Betreiber

Und die man verwenden vollständig: und Schecks können auf verschiedene Weise, wie durchgeführt werden hängt von der Anforderung ab.

Sie können nur diesen Code ersetzen

if middleName == nil { 
    return "\(firstName) \(lastName)" 
}else{ 
    return "\(firstName) \(middleName!) \(lastName)" 
} 

von

return "\(firstName)\(middleName != nil ? " \(middleName!) " : " ")\(lastName)" 

ODER

Sie auch Nil coalescing operator (a ?? b) auspackt optional ein verwenden können, wenn es enthält ein Wert oder gibt einen Standardwert b zurück, wenn a null ist.

Answer 5

In diesem Fall liegt Ihr Lehrer falsch. Deine Funktion ist absolut sicher. middleName ändert sich nicht von nil zu nil hinter deinem Rücken. Ihre Funktion kann abstürzen, wenn Sie einen Tippfehler machen, und den Namen einer anderen Variablen anstelle von middleName eingeben, aber das wäre sowieso ein Fehler und der Absturz würde Sie zum Bug führen.

Aber normalerweise "wenn lassen ..." ist der bessere Weg, damit umzugehen, weil es den Test und das Auspacken kombiniert.

Es gibt auch Situationen, in denen Sie nicht sagen "wenn es Null ist, wird es abstürzen, das ist schlecht", aber "wenn es Null ist, dann will ich es abstürzen" (normalerweise weil Sie wissen, dass es nur Null sein kann, wenn es da ist ist ein Fehler irgendwo in Ihrem Code). In diesem Fall ! macht genau das, was du willst.