Wie überprüfen Sie Objekt ist Null oder nicht in Swift?

Question

Angenommen, ich habe String wie:

var abc : NSString = "ABC" 

und ich möchte überprüfen, ob es gleich Null ist oder nicht, und dafür möchte ich versuchen:

if abc == nil{ 

     //TODO: 

    } 

Aber das funktioniert nicht und mir ein Fehler geben. Fehler sagt:

Can not invoke '=='with an argument list of type '(@|value NSString , NilLiteralConvertible)' 

Jede Lösung für diese?

Answer 1

Wenn abc ist ein optionaler, dann der üblicher Weg, dies zu tun wäre es in einer if-Anweisung, um zu versuchen zu sein auszupacken:

if let variableName = abc { // If casting, use, eg, if let var = abc as? NSString 
    // variableName will be abc, unwrapped 
} else { 
    // abc is nil 
} 

---

Um jedoch Ihre tatsächliche Frage zu beantworten, ist Ihr Problem, dass Sie die Variable eingeben, so dass es nie optional sein kann.

Denken Sie daran, dass in Swift nil ein Wert ist, der nur für Optionals gelten kann.

Da Sie Ihre Variable deklariert haben, wie:

var abc: NSString ... 

es nicht optional ist und nicht nil sein kann.

Versuchen Sie es als erklärt:

var abc: NSString? ... 

oder alternativ lassen der Compiler den Typ schließen.

Answer 2

Apple empfiehlt außerdem, dass Sie dies verwenden, um nach veralteten und entfernten Klassen aus früheren Frameworks zu suchen.

Hier ist ein wörtliches Zitat aus einem Entwickler bei Apple:

Ja. Wenn das derzeit laufende Betriebssystem die Klasse nicht implementiert, gibt die Klassenmethode nil zurück.

this helps :)

Answer 3

Der Fall von if abc == nil wird verwendet, wenn Sie eine Var deklarieren und erzwingen wollen, auszupacken und dann auf Null überprüfen. Hier können Sie wissen, dass dies nil sein kann und Sie können if != nil verwenden Sie die NSString Funktionen von der Stiftung.

Im Fall von String? ist Ihnen nicht bekannt, was zur Laufzeit umgebrochen wird und Sie müssen daher if-let verwenden und die Überprüfung durchführen.

Sie taten folgendes, aber ohne "!". Hoffe das klärt es.

Von Apfel docs sieh dir das an:

let assumedString: String! = "An implicitly unwrapped optional string." 

Sie können immer noch eine implizit ungeöffneten optional wie ein normaler optional behandeln, zu überprüfen, ob es einen Wert enthält:

if assumedString != nil { 
    println(assumedString) 
} 
// prints "An implicitly unwrapped optional string." 

Answer 4

Die Nullprüfung ist wirklich gut gemacht mit Guard Keyword in Swift. Es verbessert die Lesbarkeit des Codes und der Gültigkeitsbereich der Variablen ist nach dem Nullstellen immer noch verfügbar, um zu überprüfen, ob Sie sie verwenden möchten.

func setXYX -> Void{ 

    guard a != nil else { 
     return; 
    } 

    guard b != nil else { 
     return; 
    } 

    print (" a and b is not null"); 
} 

Answer 5

Ich landete Nutzenfunktion Schreiben für null zu überprüfen Hat

func isObjectNotNil(object:AnyObject!) -> Bool 
{ 
    if let _:AnyObject = object 
    { 
     return true 
    } 

    return false 
} 

die gleiche Arbeit & Code sieht sauber!

Usage

var someVar:NSNumber? 

if isObjectNotNil(someVar) 
{ 
    print("Object is NOT nil") 
} 
else 
{ 
    print("Object is nil") 
} 

Answer 6

Swift kurze expression:

var abc = "string" 
abc != nil ? doWork(abc) :() 

oder:

abc == nil ?() : abc = "string" 

oder beides:

abc != nil ? doWork(abc) : abc = "string" 

Answer 7

func isObjectValid(someObject: Any?) -> Any? { 
    if someObject is String { 
     if let someObject = someObject as? String { 
      return someObject 
     }else { 
      return "" 
     } 
    }else if someObject is Array<Any> { 
     if let someObject = someObject as? Array<Any> { 
      return someObject 
     }else { 
      return [] 
     } 
    }else if someObject is Dictionary<AnyHashable, Any> { 
     if let someObject = someObject as? Dictionary<String, Any> { 
      return someObject 
     }else { 
      return [:] 
     } 
    }else if someObject is Data { 
     if let someObject = someObject as? Data { 
      return someObject 
     }else { 
      return Data() 
     } 
    }else if someObject is NSNumber { 
     if let someObject = someObject as? NSNumber{ 
      return someObject 
     }else { 
      return NSNumber.init(booleanLiteral: false) 
     } 
    }else if someObject is UIImage { 
     if let someObject = someObject as? UIImage { 
      return someObject 
     }else { 
      return UIImage() 
     } 
    } 
    else { 
     return "InValid Object" 
    } 
} 

Diese Funktion überprüft jede Art von Objekt und Standardwert der Rückkehr von der Art des Objekts, wenn das Objekt ungültig ist.

Answer 8

Normalerweise möchte ich nur wissen, ob das Objekt Null ist oder nicht.

Also ich benutze diese Funktion, die nur true zurückgibt, wenn das eingegebene Objekt gültig ist und false wenn es nicht ist.

func isNotNil(someObject: Any?) -> Bool { 
     if someObject is String { 
      if (someObject as? String) != nil { 
       return true 
      }else { 
       return false 
      } 
     }else if someObject is Array<Any> { 
      if (someObject as? Array<Any>) != nil { 
       return true 
      }else { 
       return false 
      } 
     }else if someObject is Dictionary<AnyHashable, Any> { 
      if (someObject as? Dictionary<String, Any>) != nil { 
       return true 
      }else { 
       return false 
      } 
     }else if someObject is Data { 
      if (someObject as? Data) != nil { 
       return true 
      }else { 
       return false 
      } 
     }else if someObject is NSNumber { 
      if (someObject as? NSNumber) != nil{ 
       return true 
      }else { 
       return false 
      } 
     }else if someObject is UIImage { 
      if (someObject as? UIImage) != nil { 
       return true 
      }else { 
       return false 
      } 
     } 
     return false 
}