Was bedeutet ein Ausrufezeichen in der Swift-Sprache?

Question

Der Leitfaden zur Swift-Programmiersprache hat das folgende Beispiel:

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { println("\(name) wird deinitialisiert") }
}

class Apartment {
    let number: Int
    init(number: Int) { self.number = number }
    var tenant: Person?
    deinit { println("Apartment Nr. \(number) wird deinitialisiert") }
}

var john: Person?
var number73: Apartment?

john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)

// Aus dem Leitfaden "The Swift Programming Language" von Apple (https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html)

Dann, wenn das Apartment der Person zugewiesen wird, benutzen sie ein Ausrufezeichen, um die Instanz "auszupacken":

john!.apartment = number73

Was bedeutet es, eine Instanz "auszupacken"? Warum ist es notwendig? Wie unterscheidet es sich davon, einfach folgendes zu tun:

john.apartment = number73

Ich bin ganz neu in der Swift-Sprache. Versuche nur, die Grundlagen zu verstehen.

UPDATE:
Das große Puzzlestück, das mir fehlte (nicht direkt in den Antworten angegeben - zumindest nicht zum Zeitpunkt des Verfassens dieses Beitrags), ist, dass wenn man Folgendes tut:

var john: Person?

das NICHT bedeutet, dass "john vom Typ Person ist und vielleicht nil sein könnte", wie ich ursprünglich dachte. Ich habe einfach missverstanden, dass Person und Person? vollständig separate Typen sind. Sobald ich das verstanden hatte, ergaben alle anderen ?, ! Verwirrungen und die großartigen Antworten unten viel mehr Sinn.

Answer 1

Wenn Sie mit C# vertraut sind, ist dies ähnlich wie Nullable-Typen, die auch mit einem Fragezeichen deklariert werden:

Person? thisPerson;

Und das Ausrufezeichen in diesem Fall entspricht dem Zugriff auf die .Value-Eigenschaft des nullable Typs wie folgt:

thisPerson.Value

Answer 2

Für Googlers:

john!.department

...sagt dem Compiler:

• Ich weiß, dass john optional ist
• Benutze es, als ob es einen Wert hätte
• Crashe einfach, wenn es keinen Wert hat

In der Produktion verwenden Sie guard let oder if let, um mit der Situation ohne Wert und harten Abstürzen umzugehen.

Answer 3

Kurz gesagt: Nachdem Sie eine Variable deklariert haben und sicher sind, dass die Variable einen Wert enthält.

let assumedString: String! = "Eine Nachricht..."
let implicitString: String = assumedString

Sonst müssten Sie dies jedes Mal machen, nachdem Sie den Wert übergeben haben...

let possibleString: String? = "Ein optionaler String."
let forcedString: String = possibleString! // erfordert ein Ausrufezeichen

Answer 4

Das ! am Ende eines Objekts besagt, dass das Objekt optional ist und entpackt werden soll, wenn möglich, ansonsten wird nil zurückgegeben. Dies wird oft verwendet, um Fehler abzufangen, die das Programm ansonsten zum Absturz bringen würden.

Answer 5

In Objective-C waren Variablen ohne Wert gleich 'nil' (es war auch möglich, 'nil'-Werte wie 0 und false zu verwenden), daher war es möglich, Variablen in bedingten Anweisungen zu verwenden (Variablen mit Werten sind wie 'TRUE' und diejenigen ohne Werte waren gleich 'FALSE').

Swift bietet Typsicherheit, indem es 'optionale Werte' bereitstellt. d.h. Es verhindert Fehler, die durch das Zuweisen von Variablen verschiedener Typen entstehen.

Also in Swift können nur Booleans in bedingten Anweisungen bereitgestellt werden.

var hw = "Hallo Welt"

Hier, obwohl 'hw' eine Zeichenkette ist, kann sie nicht wie in Objective-C in einer If-Anweisung verwendet werden.

//Das ist ein Fehler

if hw

 {..}

Dazu muss es erstellt werden als,

var nhw : String? = "Hallo Welt"

//Dies ist korrekt

if nhw

 {..}