wake-up-neo.net

Was ist ein optionaler Wert in Swift?

Aus Apples Dokumentation :

Sie können if und let zusammen verwenden, um mit möglicherweise fehlenden Werten zu arbeiten. Diese Werte werden als Option dargestellt. Ein optionaler Wert enthält entweder einen Wert oder nil, um anzuzeigen, dass der Wert fehlt. Schreiben Sie ein Fragezeichen (?) nach dem Wertetyp, um den Wert als optional zu markieren.

Warum möchten Sie einen optionalen Wert verwenden?

237
Tim Vermeulen

Nehmen wir das Beispiel einer NSError. Wenn kein Fehler zurückgegeben wird, möchten Sie es optional machen, um Null zurückzugeben. Es hat keinen Sinn, ihm einen Wert zuzuweisen, wenn kein Fehler vorliegt.

var error: NSError? = nil

Dadurch können Sie auch einen Standardwert festlegen. Sie können also eine Methode als Standardwert festlegen, wenn der Funktion nichts übergeben wird

func doesntEnterNumber(x: Int? = 5) -> Bool {
    if (x == 5){
        return true
    } else {
        return false
    }
}
14
John Riselvato

Sie können keine Variable haben, die in Swift auf nil verweist. Es gibt keine Zeiger und keine Nullzeiger. In einer API möchten Sie jedoch häufig entweder einen bestimmten Wert oder einen Mangel an Wert angeben, z. Hat mein Fenster einen Delegierten und wenn ja, wer ist es? Optionals sind die typensichere, speichersichere Möglichkeit von Swift, dies zu tun.

12
rickster

Ich habe eine kurze Antwort gegeben, die die meisten der oben genannten Aussagen zusammenfasst, um die Unsicherheit zu beseitigen, die ich als Anfänger in meinem Kopf hatte:

Im Gegensatz zu Objective-C darf keine Variable nil in Swift enthalten, daher wurde der Variablentyp Optionale hinzugefügt (Variablen mit dem Suffix "?"):

    var aString = nil //error

Der große Unterschied ist, dass die optionalen Variablen keine Werte direkt speichern (wie normale Obj-C-Variablen). Sie enthalten zwei Zustände: "hat einen Wert" oder "hat keine ":

    var aString: String? = "Hello, World!"
    aString = nil //correct, now it contains the state "has nil"

Sie können diese Variablen also in verschiedenen Situationen prüfen:

if let myString = aString? {
     println(myString)
}
else { 
     println("It's nil") // this will print in our case
}

Mit dem "!" Suffix können Sie auch auf die darin eingeschlossenen Werte zugreifen, nur wenn diese vorhanden sind. (d. h. es ist nicht null):

let aString: String? = "Hello, World!"
// var anotherString: String = aString //error
var anotherString: String = aString!

println(anotherString) //it will print "Hello, World!"

Deshalb müssen Sie "?" und "!" und nicht alle standardmäßig verwenden. (das war meine größte Verwirrung)

Ich stimme auch der obigen Antwort zu: Der optionale Typ kann nicht als boolesches verwendet werden.

11
Teodor Ciuraru

In Objective C waren Variablen ohne Wert gleich 'nil' (es war auch möglich, 'nil'-Werte wie 0 und falsch zu verwenden), daher konnten Variablen in Bedingungsanweisungen verwendet werden (Variablen mit Werten sind mit' TRUE 'identisch 'und diejenigen ohne Werte waren gleich' FALSE ').

Swift bietet Typsicherheit, indem es einen optionalen Wert bietet. Das heißt, es verhindert Fehler, die beim Zuweisen von Variablen verschiedener Typen entstehen.

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

var hw = "Hello World"

Auch wenn 'hw' eine Zeichenfolge ist, kann sie nicht in einer if-Anweisung wie in Objective 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

 {..}
7
Gokul

Mit dem optionalen Wert können Sie das Fehlen eines Werts anzeigen. Ein bisschen wie NULL in SQL oder NSNull in Objective-C. Ich denke, das wird eine Verbesserung sein, da Sie dies auch für "primitive" Typen verwenden können.

// Reimplement the Swift standard library's optional type
enum OptionalValue<T> {
    case None
    case Some(T)
}
var possibleInteger: OptionalValue<Int> = .None
possibleInteger = .Some(100)”

Auszug aus: Apple Inc. „Die schnelle Programmiersprache“. IBooks. https://itun.es/gb/jEUH0.l

5
Maria Zverina

Eine optionale Option bedeutet, dass Swift nicht ganz sicher ist, ob der Wert dem Typ entspricht: beispielsweise Int? bedeutet, dass Swift nicht ganz sicher ist, ob die Nummer eine Int ist.

Um es zu entfernen, gibt es drei Methoden, die Sie verwenden können.

1) Wenn Sie sich des Typs absolut sicher sind, können Sie das Auspacken mit einem Ausrufezeichen wie folgt erzwingen:

// Here is an optional variable:

var age: Int?

// Here is how you would force unwrap it:

var unwrappedAge = age!

Wenn Sie das Auspacken eines optionalen Elements erzwingen, das gleich Null ist, kann dieser Absturzfehler auftreten:

 enter image description here

Dies ist nicht unbedingt sicher, daher folgt hier eine Methode, die einen Absturz verhindern kann, falls Sie sich hinsichtlich Typ und Wert nicht sicher sind:

Die Methoden 2 und 3 schützen vor diesem Problem.

2) Die implizit nicht verpackte Option

 if let unwrappedAge = age {

 // continue in here

 }

Beachten Sie, dass der unverpackte Typ jetzt Int ist, anstatt Int?.

3) Die Wachaussage

 guard let unwrappedAge = age else { 
   // continue in here
 }

Von hier aus können Sie die unverpackte Variable verwenden. Stellen Sie sicher, dass Sie das Entpacken (mit einem!) Nur erzwingen, wenn Sie sich des Typs der Variablen sicher sind.

Viel Glück mit deinem Projekt!

3
GJZ

Als ich anfing, Swift zu lernen, war es sehr schwierig zu erkennen, warum optional .

Lasst uns auf diese Weise denken .. Lassen Sie uns eine Klasse Person betrachten, die zwei Eigenschaften name und company hat.

class Person: NSObject {

    var name : String //Person must have a value so its no marked as optional
    var companyName : String? ///Company is optional as a person can be unemployed that is nil value is possible

    init(name:String,company:String?) {

        self.name = name
        self.companyName = company

    }
}

Jetzt können wir einige Objekte von Person erstellen.

var tom:Person = Person.init(name: "Tom", company: "Apple")//posible
var bob:Person = Person.init(name: "Bob", company:nil) // also Possible because company is marked as optional so we can give Nil

Wir können jedoch Nil nicht an name übergeben.

var personWithNoName:Person = Person.init(name: nil, company: nil)

Lassen Sie uns darüber sprechen, warum wir optional?..__ verwenden. Wir betrachten eine Situation, in der wir Inc nach dem Firmennamen wie Apple hinzufügen möchten, Apple Inc. Wir müssen Inc nach dem Firmennamen anhängen und drucken.

print(tom.companyName+" Inc") ///Error saying optional is not unwrapped.
print(tom.companyName!+" Inc") ///Error Gone..we have forcefully unwrap it which is wrong approach..Will look in Next line
print(bob.companyName!+" Inc") ///Crash!!!because bob has no company and nil can be unwrapped.

Lassen Sie uns nun untersuchen, warum optional optional eingesetzt wird.

if let companyString:String = bob.companyName{///Compiler safely unwrap company if not nil.If nil,no unwrap.

    print(companyString+" Inc") //Will never executed and no crash!!!
}

Ersetzen Sie bob durch tom

if let companyString:String = tom.companyName{///Compiler safely unwrap company if not nil.If nil,no unwrap.

    print(companyString+" Inc") //Will never executed and no crash!!!
}

Und Gratulation! Wir haben mit optional? richtig umgegangen

Die Erkenntnispunkte sind also

  1. Eine Variable wird als optional markiert, wenn es möglich ist, nil zu sein.
  2. Wenn wir diese Variable irgendwo im Code verwenden wollen, erinnert der Compiler Daran, dass wir prüfen müssen, ob wir die Variable Richtig behandeln, wenn sie nil enthält.

Vielen Dank ... Happy Coding

Lassen Sie uns mit dem folgenden Code Playground experimentieren.

var sampleString: String? ///Optional, Possible to be nil

sampleString = nil ////perfactly valid as its optional

sampleString = "some value"  //Will hold the value

if let value = sampleString{ /// the sampleString is placed into value with auto force upwraped.

    print(value+value)  ////Sample String merged into Two
}

sampleString = nil // value is nil and the

if let value = sampleString{

    print(value + value)  ///Will Not execute and safe for nil checking
}

//   print(sampleString! + sampleString!)  //this line Will crash as + operator can not add nil

Von https://developer.Apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/OptionalChaining.html :

Optionale Verkettung ist ein Prozess zum Abfragen und Aufrufen von Eigenschaften, Methoden und Subskripten für eine optionale Option, die derzeit null ist. Wenn das optionale Element einen Wert enthält, ist der Aufruf von property, method oder subscript erfolgreich. Wenn die Option null ist, gibt der Aufruf von property, method oder subscript nil zurück. Mehrere Abfragen können miteinander verkettet werden und die gesamte Kette fällt ordnungsgemäß aus, wenn ein Link in der Kette gleich Null ist.

Um tiefer zu verstehen, lesen Sie den Link oben.

0
nizama bunti

Gut...

? (Optional) zeigt an, dass Ihre Variable einen Nullwert enthalten kann, während ! (unwrapper) gibt an, dass Ihre Variable über einen Speicher (oder einen Wert) verfügen muss, wenn sie zur Laufzeit verwendet wird (versucht wurde, einen Wert davon zu erhalten).

Der Hauptunterschied besteht darin, dass die optionale Verkettung ordnungsgemäß fehlschlägt, wenn die Option null ist, während das erzwungene Auspacken einen Laufzeitfehler auslöst, wenn die Option null ist.

Um der Tatsache Rechnung zu tragen, dass die optionale Verkettung für einen Nullwert aufgerufen werden kann, ist das Ergebnis eines optionalen Verkettungsaufrufs immer ein optionaler Wert, auch wenn die abgefragte Eigenschaft, Methode oder der Index einen nicht optionalen Wert zurückgibt. Sie können diesen optionalen Rückgabewert verwenden, um zu prüfen, ob der optionale Verkettungsaufruf erfolgreich war (das zurückgegebene optionale Element enthält einen Wert) oder aufgrund eines Nullwerts in der Kette nicht erfolgreich war (der zurückgegebene optionale Wert ist null).

Insbesondere ist das Ergebnis eines optionalen Verkettungsaufrufs vom selben Typ wie der erwartete Rückgabewert, jedoch in einem optionalen Aufruf. Eine Eigenschaft, die normalerweise ein Int zurückgibt, gibt ein Int? Zurück, wenn über optionale Verkettung zugegriffen wird.

var defaultNil : Int?  // declared variable with default nil value
println(defaultNil) >> nil  

var canBeNil : Int? = 4
println(canBeNil) >> optional(4)

canBeNil = nil
println(canBeNil) >> nil

println(canBeNil!) >> // Here nil optional variable is being unwrapped using ! mark (symbol), that will show runtime error. Because a nil optional is being tried to get value using unwrapper

var canNotBeNil : Int! = 4
print(canNotBeNil) >> 4

var cantBeNil : Int = 4
cantBeNil = nil // can't do this as it's not optional and show a compile time error

Hier ist ein grundlegendes Tutorial im Detail von Apple Developer Committee: Optionale Verkettung

0
Krunal

Ein optionales Element in Swift ist ein Typ, der entweder einen Wert oder keinen Wert enthalten kann. Optionals werden durch Anhängen eines? zu irgendeinem Typ:

var name: String?

Sie können auf diesen Link verweisen, um detaillierte Informationen zu erhalten: https://medium.com/@agoiabeladeyemi/optionals-in-Swift-2b141f12f870

0
Vicky Prajapati