Prüfen Sie, ob das optionale Array leer ist

Erweiterungseigenschaft im Protokoll Collection

* In Swift 3 geschrieben

extension Optional where Wrapped: Collection {
    var isNilOrEmpty: Bool {
        switch self {
            case .some(let collection):
                return collection.isEmpty
            case .none:
                return true
        }
    }
}

Beispielgebrauch:

if array.isNilOrEmpty {
    print("The array is nil or empty")
}

Andere Optionen

Abgesehen von der obigen Erweiterung finde ich die folgende Option am deutlichsten, ohne das Erzwingen von Optionals zu erzwingen. Ich las dies als das Auspacken des optionalen Arrays und, wenn nicht vorhanden, ein leeres Array desselben Typs. Nehmen Sie dann das (nicht optionale) Ergebnis davon und führen Sie, falls es isEmpty ist, den Bedingungscode aus.

Empfohlen

if (array ?? []).isEmpty {
    print("The array is nil or empty")
}

Obwohl das Folgende klar lesbar ist, schlage ich die Gewohnheit vor, das Auspacken von Optionals nach Möglichkeit zu vermeiden. Obwohl Sie garantiert sind, dass array niemals nil sein wird, wenn array!.isEmpty in diesem speziellen Fall ausgeführt wird, ist es einfach, sie später zu bearbeiten und versehentlich einen Absturz einzuführen. Wenn Sie die Option zum Auspacken von Optionen nutzen möchten, erhöhen Sie die Wahrscheinlichkeit, dass jemand in der Zukunft eine Änderung vornimmt, die kompiliert wird, jedoch zur Laufzeit abstürzt.

Nicht empfohlen!

if array == nil || array!.isEmpty {
    print("The array is nil or empty")
}

Ich finde Optionen, die array? (optionale Verkettung) beinhalten, wie zum Beispiel:

Verwirrend?

if !(array?.isEmpty == false) {
    print("The array is nil or empty")
}

if array?.isEmpty ?? true {
    print("There are no objects")
}

Option D: Wenn das Array nicht optional sein muss, weil es Ihnen wirklich wichtig ist, ob es leer ist oder nicht, dann initialisieren Sie es als leeres Array anstelle eines optionalen:

var array = [Int]()

Jetzt wird es immer existieren und Sie können einfach nach isEmpty suchen. 

Swift 3-4 kompatibel:

extension Optional where Wrapped: Collection {
        var nilIfEmpty: Optional {
            switch self {
            case .some(let collection):
                return collection.isEmpty ? nil : collection
            default:
                return nil
            }
        }

        var isNilOrEmpty: Bool {
            switch self {
            case .some(let collection):
                return collection.isEmpty
            case .none:
                return true
        }
}

Verwendungszweck:

guard let array = myObject?.array.nilIfEmpty else { return }

Oder

if myObject.array.isNilOrEmpty {
    // Do stuff here
}

Bedingtes Auspacken:

if let anArray = array {
    if !anArray.isEmpty {
        //do something
    }
}

EDIT: Möglich seit Swift 1.2:

if let myArray = array where !myArray.isEmpty {
    // do something with non empty 'myArray'
}

EDIT: Möglich seit Swift 2.0:

guard let myArray = array where !myArray.isEmpty else {
    return
}
// do something with non empty 'myArray'

Anstelle von if und else ist es besser, guard zu verwenden, um nach leeren Arrays zu suchen, ohne neue Variablen für dasselbe Array zu erstellen.

guard !array.isEmpty else {
    return
}
// do something with non empty ‘array’

Die elegante integrierte Lösung ist die map-Methode von Optional. Diese Methode wird oft vergessen, macht aber genau das, was Sie hier brauchen. Damit können Sie eine Nachricht sicher an das in einem optionalen Gerät verpackte Objekt senden. Wir erhalten in diesem Fall eine Art Dreifach-Switch: Wir können isEmpty zum optionalen Array sagen und erhalten true, false oder nil (falls das Array selbst gleich null ist).

var array : [Int]?
array.map {$0.isEmpty} // nil (because `array` is nil)
array = []
array.map {$0.isEmpty} // true (wrapped in an Optional)
array?.append(1)
array.map {$0.isEmpty} // false (wrapped in an Optional)