Das Swift Programming Language-Handbuch enthält das folgende Beispiel:

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

class Apartment {
    let number: Int
    init(number: Int) { self.number = number }
    var tenant: Person?
    deinit { println("Apartment #\(number) is being deinitialized") }
}

var john: Person?
var number73: Apartment?

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

//From Apple's “The Swift Programming Language” guide (https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html)

Wenn sie dann die Wohnung der Person zuweisen, verwenden sie ein Ausrufezeichen, um "die Instanz auszupacken":

john!.apartment = number73

Was bedeutet es, "die Instanz auszupacken"? Warum ist es notwendig? Wie unterscheidet es sich von Folgendem:

john.apartment = number73

Ich bin sehr neu in der Swift-Sprache. Ich versuche nur, die Grundlagen zu vermitteln.

UPDATE:
Das große Puzzleteil, das mir fehlte (nicht direkt in den Antworten angegeben - zumindest nicht zum Zeitpunkt des Schreibens), ist das, wenn Sie Folgendes tun:

var john: Person?

das bedeutet NICHT, dass " johnvom Typ ist Personund es Null sein könnte", wie ich ursprünglich dachte. Ich habe das einfach falsch verstanden Personund bin Person?völlig getrennte Typen. Nachdem ich das begriffen hatte , machten all die anderen ?, der !Wahnsinn und die großartigen Antworten unten viel mehr Sinn.

Was bedeutet es, "die Instanz auszupacken"? Warum ist es notwendig?

Soweit ich trainieren kann (das ist auch für mich sehr neu) ...

Der Begriff "verpackt" impliziert, dass wir uns eine optionale Variable als Geschenk vorstellen sollten, eingewickelt in glänzendes Papier, das (leider!) Leer sein könnte .

Beim "Umschließen" ist der Wert einer optionalen Variablen eine Aufzählung mit zwei möglichen Werten (ähnlich einem Booleschen Wert). Diese Aufzählung beschreibt, ob die Variable einen Wert ( Some(T)) enthält oder nicht ( None).

Wenn es einen Wert gibt, kann dies durch "Auspacken" der Variablen (Erhalten des Tvon Some(T)) erhalten werden.

Wie john!.apartment = number73unterscheidet sich von john.apartment = number73? (Umschrieben)

Wenn Sie den Namen einer optionalen Variablen (z. B. Text johnohne !) schreiben , bezieht sich dies auf die "umschlossene" Aufzählung (Some / None) und nicht auf den Wert selbst (T). Ist johnalso keine Instanz von Personund hat kein apartmentMitglied:

john.apartment
// 'Person?' does not have a member named 'apartment'

Der tatsächliche PersonWert kann auf verschiedene Arten ausgepackt werden:

• "Forced Unwrapping": john!(gibt den PersonWert an, falls vorhanden, Laufzeitfehler, wenn er Null ist)
• "optionale Bindung": if let p = john { println(p) }(führt aus, printlnwenn der Wert vorhanden ist)
• "optionale Verkettung": john?.learnAboutSwift()(führt diese erfundene Methode aus, wenn der Wert vorhanden ist)

Ich denke, Sie wählen eine dieser Möglichkeiten zum Auspacken, je nachdem, was im Fall Null passieren soll und wie wahrscheinlich das ist. Dieses Sprachdesign zwingt dazu, den Null-Fall explizit zu behandeln, was meiner Meinung nach die Sicherheit gegenüber Obj-C verbessert (wo man leicht vergisst, den Null-Fall zu behandeln).

Update :

Das Ausrufezeichen wird auch in der Syntax zum Deklarieren von "Implizit entpackten Optionen" verwendet.

In den bisherigen Beispielen wurde die johnVariable als deklariert var john:Person?und ist optional. Wenn Sie den tatsächlichen Wert dieser Variablen möchten, müssen Sie ihn mit einer der drei oben genannten Methoden auspacken.

Wenn es var john:Person!stattdessen als deklariert würde, wäre die Variable eine implizit nicht verpackte Option (siehe den Abschnitt mit dieser Überschrift in Apples Buch). Diese Art von Variable muss beim Zugriff auf den Wert nicht entpackt werden und johnkann ohne zusätzliche Syntax verwendet werden. Aber Apples Buch sagt:

Implizit entpackte Optionen sollten nicht verwendet werden, wenn die Möglichkeit besteht, dass eine Variable zu einem späteren Zeitpunkt Null wird. Verwenden Sie immer einen normalen optionalen Typ, wenn Sie während der Lebensdauer einer Variablen nach einem Nullwert suchen müssen.

Update 2 :

Der Artikel " Interessante schnelle Funktionen " von Mike Ash gibt einige Motivation für optionale Typen. Ich finde es toll, klar zu schreiben.

Update 3 :

Ein weiterer nützlicher Artikel über die implizit ausgepackte optionale Verwendung des Ausrufezeichens: " Swift and the Last Mile " von Chris Adamson. Der Artikel erklärt, dass dies eine pragmatische Maßnahme von Apple ist, mit der die von den Objective-C-Frameworks verwendeten Typen deklariert werden, die möglicherweise Null enthalten. Das Deklarieren eines Typs als optional (Verwenden ?) oder implizit ausgepackt (Verwenden !) ist "ein Kompromiss zwischen Sicherheit und Komfort". In den Beispielen im Artikel hat Apple beschlossen, die Typen als implizit entpackt zu deklarieren, um den aufrufenden Code bequemer, aber weniger sicher zu machen.

Vielleicht könnte Apple in Zukunft ihre Frameworks durchkämmen, um die Unsicherheit implizit entpackter ("wahrscheinlich nie null") Parameter zu beseitigen und sie durch optionale ("könnte sicherlich keine besonderen [hoffentlich dokumentierten!] Umstände sein") oder Standard-Nicht-Umstände zu ersetzen -optionale ("ist niemals null") Deklarationen, basierend auf dem genauen Verhalten ihres Objective-C-Codes.

Folgendes ist meiner Meinung nach der Unterschied:

var john: Person?

Bedeutet, John kann Null sein

john?.apartment = number73

Der Compiler interpretiert diese Zeile wie folgt:

if john != nil {
    john.apartment = number73
}

Während

john!.apartment = number73

Der Compiler interpretiert diese Zeile wie folgt:

john.apartment = number73

Daher mit! wird die if-Anweisung auspacken und schneller ausführen, aber wenn john null ist, tritt ein Laufzeitfehler auf.

Wrap bedeutet hier nicht, dass es sich um Speicher handelt, sondern um Code, in diesem Fall um eine if-Anweisung. Da Apple die Leistung zur Laufzeit genau beachtet, möchten sie Ihnen einen Weg dazu bieten Lassen Sie Ihre App mit der bestmöglichen Leistung laufen.

Aktualisieren:

Zurück zu dieser Antwort nach 4 Jahren, da ich in Stackoverflow den höchsten Ruf davon hatte :) Ich habe die Bedeutung des Auspackens zu dieser Zeit ein wenig falsch verstanden. Jetzt, nach 4 Jahren, glaube ich, dass das Entpacken hier bedeutet, den Code von seiner ursprünglichen kompakten Form zu erweitern. Es bedeutet auch, die Unbestimmtheit um dieses Objekt herum zu entfernen, da wir per Definition nicht sicher sind, ob es null ist oder nicht. Betrachten Sie es genau wie die Antwort von Ashley oben als ein Geschenk, das nichts enthalten könnte. Aber ich denke immer noch, dass das Entpacken Code-Entpacken ist und nicht speicherbasiertes Entpacken wie das Verwenden von Enum.

TL; DR

Was bedeutet ein Ausrufezeichen in der Swift-Sprache?

Das Ausrufezeichen sagt effektiv: „Ich weiß, dass dieses optionale definitiv einen Wert hat; bitte benutze es. " Dies wird als erzwungenes Auspacken des optionalen Werts bezeichnet:

Beispiel

let possibleString: String? = "An optional string."
print(possibleString!) // requires an exclamation mark to access its value
// prints "An optional string."

let assumedString: String! = "An implicitly unwrapped optional string."
print(assumedString)  // no exclamation mark is needed to access its value
// prints "An implicitly unwrapped optional string."

Quelle: https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_399

Wenn John eine optionale Var wäre (so deklariert)

var john: Person?

dann wäre es möglich, dass John keinen Wert hat (im ObjC-Sprachgebrauch kein Wert)

Das Ausrufezeichen sagt dem Compiler im Grunde: "Ich weiß, dass dies einen Wert hat, Sie müssen nicht darauf testen." Wenn Sie es nicht verwenden möchten, können Sie es unter bestimmten Bedingungen testen:

if let otherPerson = john {
    otherPerson.apartment = number73
}

Das Innere davon wird nur ausgewertet, wenn John einen Wert hat.

Einige Gesamtperspektiven, um die anderen nützlichen, aber detaillierteren Antworten zu ergänzen:

In Swift wird das Ausrufezeichen in mehreren Kontexten angezeigt:

• Erzwungenes Auspacken: let name = nameLabel!.text
• Implizit ausgepackte Optionen: var logo: UIImageView!
• Zwangsguss: logo.image = thing as! UIImage
• Unbehandelte Ausnahmen: try! NSJSONSerialization.JSONObjectWithData(data, [])

Jedes von diesen ist ein anderes Sprachkonstrukt mit einer anderen Bedeutung, aber alle haben drei wichtige Dinge gemeinsam:

1. Ausrufezeichen umgehen die Sicherheitsüberprüfungen zur Kompilierungszeit von Swift.

Wenn Sie !in Swift verwenden, sagen Sie im Wesentlichen: "Hey, Compiler, ich weiß, dass Sie denken , dass hier ein Fehler auftreten könnte , aber ich weiß mit absoluter Sicherheit, dass dies niemals der Fall sein wird."

Nicht jeder gültige Code passt in das Feld des Swift-Typsystems zur Kompilierungszeit - oder in die statische Typprüfung einer Sprache. Es gibt Situationen, in denen Sie logisch beweisen können, dass ein Fehler niemals auftreten wird, aber Sie können ihn dem Compiler nicht beweisen . Aus diesem Grund haben die Designer von Swift diese Funktionen in erster Linie hinzugefügt.

Wenn Sie jedoch verwenden !, schließen Sie einen Wiederherstellungspfad für einen Fehler aus, was bedeutet, dass…

2. Ausrufezeichen sind mögliche Abstürze.

Ein Ausrufezeichen lautet außerdem: "Hey Swift, ich bin mir so sicher, dass dieser Fehler niemals auftreten kann, dass es für Sie besser ist, meine gesamte App zum Absturz zu bringen, als für mich, einen Wiederherstellungspfad dafür zu codieren."

Das ist eine gefährliche Behauptung. Es kann das Richtige sein: In geschäftskritischem Code, in dem Sie über die Invarianten Ihres Codes nachgedacht haben, kann es sein, dass eine falsche Ausgabe schlechter ist als ein Absturz.

Wenn ich jedoch !in freier Wildbahn sehe , wird es selten so achtsam verwendet. Stattdessen bedeutet es zu oft: "Dieser Wert war optional und ich habe nicht wirklich darüber nachgedacht, warum es Null sein könnte oder wie ich mit dieser Situation richtig umgehen soll, aber durch Hinzufügen !wurde es kompiliert ... also ist mein Code korrekt, oder?"

Passen Sie auf die Arroganz des Ausrufezeichens auf. Stattdessen…

3. Ausrufezeichen werden am besten sparsam verwendet.

Jedes dieser !Konstrukte hat ein ?Gegenstück, das Sie zwingt, sich mit dem Fehler / Null-Fall zu befassen:

• Bedingtes Auspacken: if let name = nameLabel?.text { ... }
• Optionale Optionen: var logo: UIImageView?
• Bedingte Besetzungen: logo.image = thing as? UIImage
• Null-bei-Fehler-Ausnahmen: try? NSJSONSerialization.JSONObjectWithData(data, [])

Wenn Sie versucht sind, zu verwenden !, ist es immer gut, sorgfältig zu überlegen, warum Sie nicht ?stattdessen verwenden. Ist ein Absturz Ihres Programms wirklich die beste Option, wenn der !Vorgang fehlschlägt? Warum ist dieser Wert optional / fehlgeschlagen?

Gibt es einen vernünftigen Wiederherstellungspfad, den Ihr Code im Fall Null / Fehler einschlagen könnte? Wenn ja, codieren Sie es.

Wenn es unmöglich Null sein kann, wenn der Fehler niemals auftreten kann, gibt es dann eine vernünftige Möglichkeit, Ihre Logik zu überarbeiten, damit der Compiler das weiß? Wenn ja, mach es; Ihr Code ist weniger fehleranfällig.

Es gibt Zeiten, in denen es keinen vernünftigen Weg gibt, einen Fehler zu behandeln, und das einfache Ignorieren des Fehlers - und damit das Vorgehen mit falschen Daten - wäre schlimmer als ein Absturz. Dies sind die Zeiten, in denen Gewalt ausgepackt wird.

Ich durchsuche regelmäßig meine gesamte Codebasis !und überprüfe jede Verwendung davon. Nur sehr wenige Verwendungen halten einer Prüfung stand. (Zum jetzigen Zeitpunkt enthält das gesamte Siesta-Framework genau zwei Instanzen .)

Das heißt nicht, dass Sie Ihren Code niemals verwenden sollten !- nur, dass Sie ihn achtsam verwenden und ihn niemals zur Standardoption machen sollten.

johnist optional var. Kann also einen nilWert enthalten. Um sicherzustellen, dass der Wert nicht gleich Null ist, verwenden Sie a !am Ende des varNamens.

Aus der Dokumentation

„Wenn Sie sicher sind, dass die Option einen Wert enthält, können Sie auf den zugrunde liegenden Wert zugreifen, indem Sie am Ende des Namens der Option ein Ausrufezeichen (!) Einfügen. Das Ausrufezeichen sagt effektiv: „Ich weiß, dass dieses optionale definitiv einen Wert hat; bitte benutze es. "

Eine andere Möglichkeit, den Wert ungleich Null zu überprüfen, ist

    if let j = json {
        // do something with j
    }

Hier sind einige Beispiele:

var name:String = "Hello World"
var word:String?

Wo wordist ein optionaler Wert. bedeutet, dass es einen Wert enthalten kann oder nicht.

word = name 

Hier namehat ein Wert, damit wir ihn zuweisen können

var cow:String = nil
var dog:String!

Wenn doggewaltsam ausgepackt wird, muss es einen Wert enthalten

dog = cow

Die Anwendung stürzt ab, da wir nicht nilausgepackt zugewiesen sind

In diesem Fall...

var John: Person!

es bedeutet, dass John anfangs keinen Wert hat, er wird gesetzt und wenn er einmal gesetzt ist, wird er nie wieder null geführt. Daher kann ich der Einfachheit halber die einfachere Syntax für den Zugriff auf eine optionale Variable verwenden, da dies eine "implizit entpackte Option" ist.

Wenn Sie aus einer Sprache der C-Familie stammen, denken Sie "Zeiger auf ein Objekt vom Typ X, bei dem es sich möglicherweise um die Speicheradresse 0 (NULL) handelt", und wenn Sie aus einer dynamisch typisierten Sprache stammen, werden Sie es sein Denken "Objekt, das wahrscheinlich vom Typ X ist, aber vom Typ undefiniert sein könnte". Keines davon ist tatsächlich richtig, obwohl das erste auf Umwegen nahe ist.

Sie sollten sich das so vorstellen, als wäre es ein Objekt wie:

struct Optional<T> {
   var isNil:Boolean
   var realObject:T
}

Wenn Sie Ihren optionalen Wert foo == nildamit testen, dass er wirklich zurückkehrt foo.isNil, und wenn Sie sagen, foo!dass er foo.realObjectmit der Behauptung zurückkehrt, dass foo.isNil == false. Es ist wichtig, dies zu beachten, denn wenn dies footatsächlich Null foo!ist, ist dies ein Laufzeitfehler. Daher möchten Sie normalerweise stattdessen eine bedingte Erlaubnis verwenden, es sei denn, Sie sind sich sehr sicher, dass der Wert nicht Null ist. Diese Art von Trick bedeutet, dass die Sprache stark typisiert werden kann, ohne dass Sie testen müssen, ob die Werte überall gleich Null sind.

In der Praxis verhält es sich nicht wirklich so, weil die Arbeit vom Compiler erledigt wird. Auf hoher Ebene gibt es einen Typ, Foo?der von getrennt Fooist und Funktionen verhindert, die Typ akzeptierenFoo erhalten. Auf einer niedrigen Ebene ist ein optionaler Wert jedoch kein echtes Objekt, da er keine Eigenschaften oder Methoden hat. Es ist wahrscheinlich, dass es sich tatsächlich um einen Zeiger handelt, der beim Force-Entpacken NULL (0) mit dem entsprechenden Test verwenden kann.

Es gibt eine andere Situation, in der ein Ausrufezeichen auf einem Typ angezeigt wird, wie in:

func foo(bar: String!) {
    print(bar)
}

Dies entspricht in etwa der Annahme einer Option mit erzwungenem Auspacken, dh:

func foo(bar: String?) {
    print(bar!)
}

Sie können dies verwenden, um eine Methode zu haben, die technisch einen optionalen Wert akzeptiert, aber einen Laufzeitfehler aufweist, wenn er Null ist. In der aktuellen Version von Swift wird die is-not-nil-Behauptung anscheinend umgangen, sodass stattdessen ein Fehler auf niedriger Ebene auftritt. Im Allgemeinen keine gute Idee, aber es kann nützlich sein, wenn Code aus einer anderen Sprache konvertiert wird.

Das ! bedeutet, dass Sie das Objekt zwangsweise auspacken! folgt. Weitere Informationen finden Sie in der Apples-Dokumentation, die Sie hier finden: https://developer.apple.com/library/ios/documentation/swift/conceptual/Swift_Programming_Language/TheBasics.html

Wenn Sie mit C # vertraut sind, ähnelt dies nullbaren Typen, die ebenfalls mit einem Fragezeichen deklariert werden:

Person? thisPerson;

Das Ausrufezeichen entspricht in diesem Fall dem Zugriff auf die .Value-Eigenschaft des nullbaren Typs wie folgt:

thisPerson.Value

In Ziel 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 gleich' TRUE ' 'und diejenigen ohne Werte waren gleich' FALSE ').

Swift bietet Typensicherheit durch Bereitstellung eines optionalen Werts. Das heißt, es verhindert, dass Fehler entstehen, die Variablen unterschiedlichen Typs zuweisen.

In Swift können also nur Boolesche Werte für bedingte Anweisungen bereitgestellt werden.

var hw = "Hello World"

Obwohl 'hw' eine Zeichenfolge ist, kann sie hier nicht in einer if-Anweisung wie in Ziel C verwendet werden.

//This is an error

if hw

 {..}

Dafür muss es erstellt werden als,

var nhw : String? = "Hello World"

//This is correct

if nhw

 {..}

Das ! Am Ende eines Objekts steht, dass das Objekt optional ist und ausgepackt werden soll, wenn es sonst eine Null zurückgeben kann. Dies wird häufig verwendet, um Fehler abzufangen, die das Programm sonst zum Absturz bringen würden.

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

let assumedString: String! = "Some message..."
let implicitString: String = assumedString

sonst müssten Sie dies bei jedem nach Übergabe des Wertes tun ...

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // requires an exclamation mark

John ist eine optionale Person, was bedeutet, dass sie einen Wert enthalten oder Null sein kann.

john.apartment = number73

wird verwendet, wenn John nicht optional ist. Da John niemals Null ist, können wir sicher sein, dass die Wohnung nicht mit Null bewertet wird. Während

john!.apartment = number73

verspricht dem Compiler, dass John nicht gleich Null ist, packt dann die Option aus, um Johns Wert zu erhalten, und greift auf Johns Apartment-Eigentum zu. Verwenden Sie dies, wenn Sie wissen, dass John nicht Null ist. Wenn Sie dies mit null optional aufrufen, wird ein Laufzeitfehler angezeigt.

Die Dokumentation enthält ein schönes Beispiel für die Verwendung, wobei convertNumber optional ist.

if convertedNumber {
    println("\(possibleNumber) has an integer value of \(convertedNumber!)")
} else {
    println("\(possibleNumber) could not be converted to an integer")
}

Um es einfach auszudrücken: Ausrufezeichen bedeuten, dass eine Option ausgepackt wird. Eine Option ist eine Variable, die einen Wert haben kann oder nicht. Sie können also mithilfe einer if let-Anweisung wie hier gezeigt überprüfen, ob die Variable leer ist , und dann das Entpacken erzwingen. Wenn Sie das Entpacken einer leeren Option erzwingen, stürzt Ihr Programm ab. Seien Sie also vorsichtig! Optionale Optionen werden deklariert, indem am Ende einer expliziten Zuweisung zu einer Variablen ein Fragezeichen gesetzt wird. Ich könnte beispielsweise Folgendes schreiben:

var optionalExample: String?

Diese Variable hat keinen Wert. Wenn ich es auspacken würde, würde das Programm abstürzen und Xcode würde Ihnen sagen, dass Sie versucht haben, ein optionales mit dem Wert nil auszupacken.

Hoffe das hat geholfen.

IN EINFACHEN WORTEN

USING Das Ausrufezeichen gibt an, dass die Variable aus einem Wert ungleich Null bestehen muss (niemals Null).

Die gesamte Geschichte beginnt mit einer schnellen Funktion, die als optionale Vars bezeichnet wird. Dies sind die Variablen, die einen Wert haben können oder keinen Wert haben können. Im Allgemeinen erlaubt uns swift nicht, eine Variable zu verwenden, die nicht initialisiert ist, da dies zu Abstürzen oder unerwarteten Gründen führen kann und auch einen Platzhalter für Hintertüren dient. Um eine Variable zu deklarieren, deren Wert zunächst nicht bestimmt wurde, verwenden wir ein '?'. Wenn eine solche Variable deklariert wird, um sie als Teil eines Ausdrucks zu verwenden, muss sie vor der Verwendung entpackt werden. Das Entpacken ist eine Operation, durch die der Wert einer Variablen ermittelt wird. Dies gilt für Objekte. Wenn Sie versuchen, sie zu verwenden, wird beim Kompilieren ein Fehler beim Kompilieren angezeigt. Um eine Variable zu entpacken, die eine optionale Variable ist, das Ausrufezeichen "!" wird genutzt.

Es gibt Zeiten, in denen Sie wissen, dass solchen optionalen Variablen beispielsweise vom System oder Ihrem eigenen Programm Werte zugewiesen werden, aber einige Zeit später, z. B. UI-Outlets, in einer solchen Situation, anstatt eine optionale Variable mit einem Fragezeichen "?" Zu deklarieren. wir gebrauchen "!".

Somit weiß das System, dass diese Variable, die mit "!" ist momentan optional und hat keinen Wert, wird aber später in seiner Lebensdauer einen Wert erhalten.

Das Ausrufezeichen enthält also zwei verschiedene Verwendungen: 1. Eine Variable deklarieren, die optional ist und definitiv später einen Wert erhält. 2. Eine optionale Variable auspacken, bevor sie in einem Ausdruck verwendet wird.

Die obigen Beschreibungen vermeiden hoffentlich zu viel technisches Zeug.

Wenn Sie es als optional verwenden, packt es das optionale aus und prüft, ob etwas vorhanden ist. Wenn Sie es in einer if-else-Anweisung verwenden, ist dies Code für NOT. Zum Beispiel,

if (myNumber != 3){
 // if myNumber is NOT 3 do whatever is inside these brackets.
)

Eine optionale Variable kann einen Wert enthalten oder nicht

Fall 1: var myVar:String? = "Something"

Fall 2: var myVar:String? = nil

Wenn Sie jetzt myVar! fragen, weisen Sie den Compiler an, einen Wert zurückzugeben, falls 1 zurückgegeben wird "Something"

in Fall 2 wird es abstürzen.

Bedeutung! mark zwingt den Compiler, einen Wert zurückzugeben, auch wenn dieser nicht vorhanden ist. Deshalb der Name Force Unwrapping .

Simple the Optional variable allows nil to be stored.

var str : String? = nil

str = "Data"

To convert Optional to the Specific DataType, We unwrap the variable using the keyword "!"

func get(message : String){
   return
}

get(message : str!)  // Unwapped to pass as String

FRAG DICH SELBST

• Hat der Typ person?ein apartmentMitglied / eine Eigenschaft? ODER
• Hat der Typ personein apartmentMitglied / eine Eigenschaft?

Wenn Sie diese Frage nicht beantworten können, lesen Sie weiter:

_{Um dies zu verstehen, benötigen Sie möglicherweise ein grundlegendes Verständnis für Generika . Siehe hier . Viele Dinge in Swift werden mit Generics geschrieben. Optionale enthalten}

Der folgende Code wurde in diesem Stanford-Video zur Verfügung gestellt . Sehr zu empfehlen, die ersten 5 Minuten zu sehen

Eine Option ist eine Aufzählung mit nur 2 Fällen

enum Optional<T>{
    case None
    case Some(T)
}

let x: String? = nil //actually means:

let x = Optional<String>.None

let x :String? = "hello" //actually means:

let x = Optional<String>.Some("hello")

var y = x! // actually means:

switch x {
case .Some(let value): y = value
case .None: // Raise an exception
}

Optionale Bindung:

let x:String? = something
if let y = x {
    // do something with y
}
//Actually means:

switch x{
case .Some(let y): print)(y) // or whatever else you like using 
case .None: break
}

wenn du sagst var john: Person?meinst du eigentlich so:

enum Optional<Person>{
case .None
case .Some(Person)
}

Hat die obige Aufzählung eine Eigenschaft namens apartment? Siehst du es irgendwo Es ist überhaupt nicht da! Wenn Sie es jedoch auspacken, dh tun person!, können Sie ... was es unter der Haube tut, ist:Optional<Person>.Some(Person(name: "John Appleseed"))

Hättest du statt definiert var john: Person: var john: Person?dann hättest du das nicht mehr gebraucht !, weil es Personselbst ein Mitglied von hatapartment

Eine zukünftige Diskussion darüber, warum !das Auspacken manchmal nicht empfohlen wird, finden Sie in diesen Fragen und Antworten