So überprüfen Sie, ob sich ein Element in einem Array befindet

Wie kann ich in Swift überprüfen, ob ein Element in einem Array vorhanden ist? Xcode hat keine Vorschläge für contain, includeoderhas , und eine schnelle Suche im Buch ergab nichts. Irgendeine Idee, wie man das überprüft? Ich weiß, dass es eine Methode findgibt, die die Indexnummer zurückgibt, aber gibt es eine Methode, die einen Booleschen Wert wie den von Ruby zurückgibt #include??

Beispiel für das, was ich brauche:

var elements = [1,2,3,4,5]
if elements.contains(5) {
  //do something
}

Swift 2, 3, 4, 5:

let elements = [1, 2, 3, 4, 5]
if elements.contains(5) {
    print("yes")
}

contains()ist eine Protokollerweiterungsmethode von SequenceType(für Sequenzen von EquatableElementen) und keine globale Methode wie in früheren Versionen.

Bemerkungen:

• Diese contains()Methode erfordert, dass die Sequenzelemente das EquatableProtokoll übernehmen, z . B. Andrews Antwort .
• Wenn die Sequenzelemente Instanzen einer NSObjectUnterklasse sind, müssen Sie diese überschreiben isEqual:, siehe NSObject-Unterklasse in Swift: hash vs hashValue, isEqual vs == .
• Es gibt eine andere - allgemeinere - contains()Methode, bei der die Elemente nicht gleichwertig sein müssen und ein Prädikat als Argument verwendet wird. Siehe z. B. Kurzschrift, um zu testen, ob ein Objekt in einem Array für Swift vorhanden ist. .

Schnelle ältere Versionen:

let elements = [1,2,3,4,5]
if contains(elements, 5) {
    println("yes")
}

Für diejenigen, die hierher gekommen sind, um ein Objekt zu finden und aus einem Array zu entfernen:

Schnell 1

if let index = find(itemList, item) {
    itemList.removeAtIndex(index)
}

Swift 2

if let index = itemList.indexOf(item) {
    itemList.removeAtIndex(index)
}

Swift 3, 4

if let index = itemList.index(of: item) {
    itemList.remove(at: index)
}

Swift 5.2

if let index = itemList.firstIndex(of: item) {
    itemList.remove(at: index)
}

Verwenden Sie diese Erweiterung:

extension Array {
    func contains<T where T : Equatable>(obj: T) -> Bool {
        return self.filter({$0 as? T == obj}).count > 0
    }
}

Benutzen als:

array.contains(1)

Aktualisiert für Swift 2/3

Beachten Sie, dass ab Swift 3 (oder sogar 2) die Erweiterung nicht mehr erforderlich ist, da die globale containsFunktion in ein Paar von Erweiterungsmethoden umgewandelt wurde Array, mit denen Sie Folgendes ausführen können:

let a = [ 1, 2, 3, 4 ]

a.contains(2)           // => true, only usable if Element : Equatable

a.contains { $0 < 1 }   // => false

Wenn Sie überprüfen, ob eine Instanz einer benutzerdefinierten Klasse oder Struktur in einem Array enthalten ist, müssen Sie das Equatable- Protokoll implementieren , bevor Sie .contains (myObject) verwenden können.

Zum Beispiel:

struct Cup: Equatable {
    let filled:Bool
}

static func ==(lhs:Cup, rhs:Cup) -> Bool { // Implement Equatable
    return lhs.filled == rhs.filled
}

dann können Sie tun:

cupArray.contains(myCup)

Tipp : Die == Überschreibung sollte auf globaler Ebene erfolgen und nicht in Ihrer Klasse / Struktur

Ich habe Filter verwendet.

let results = elements.filter { el in el == 5 }
if results.count > 0 {
    // any matching items are in results
} else {
    // not found
}

Wenn Sie möchten, können Sie dies komprimieren

if elements.filter({ el in el == 5 }).count > 0 {
}

Ich hoffe, das hilft.

Update für Swift 2

Hurra für Standardimplementierungen!

if elements.contains(5) {
    // any matching items are in results
} else {
    // not found
}

(Swift 3)

Überprüfen Sie, ob ein Element in einem Array vorhanden ist (das einige Kriterien erfüllt), und fahren Sie in diesem Fall mit dem ersten solchen Element fort

Wenn die Absicht ist:

1. Um zu überprüfen, ob ein Element in einem Array vorhanden ist (/ einige boolesche Kriterien erfüllt, nicht unbedingt Gleichheitstests),
2. Und wenn ja, fahren Sie fort und arbeiten Sie mit dem ersten solchen Element.

Dann eine Alternative zu contains(_:)als blueprinted Sequenceist first(where:)von Sequence:

let elements = [1, 2, 3, 4, 5]

if let firstSuchElement = elements.first(where: { $0 == 4 }) {
    print(firstSuchElement) // 4
    // ...
}

In diesem erfundenen Beispiel mag seine Verwendung albern erscheinen, aber es ist sehr nützlich, wenn Arrays nicht grundlegender Elementtypen nach der Existenz von Elementen abgefragt werden, die eine bestimmte Bedingung erfüllen. Z.B

struct Person {
    let age: Int
    let name: String
    init(_ age: Int, _ name: String) {
        self.age = age
        self.name = name
    }
}

let persons = [Person(17, "Fred"),   Person(16, "Susan"),
               Person(19, "Hannah"), Person(18, "Sarah"),
               Person(23, "Sam"),    Person(18, "Jane")]

if let eligableDriver = persons.first(where: { $0.age >= 18 }) {
    print("\(eligableDriver.name) can possibly drive the rental car in Sweden.")
    // ...
} // Hannah can possibly drive the rental car in Sweden.

let daniel = Person(18, "Daniel")
if let sameAgeAsDaniel = persons.first(where: { $0.age == daniel.age }) {
    print("\(sameAgeAsDaniel.name) is the same age as \(daniel.name).")
    // ...
} // Sarah is the same age as Daniel.

Alle verketteten Operationen mit .filter { ... some condition }.firstkönnen vorteilhafterweise durch ersetzt werden first(where:). Letzteres zeigt die Absicht besser und hat Leistungsvorteile gegenüber möglichen nicht faulen Geräten von .filter, da diese das gesamte Array passieren, bevor das (mögliche) erste Element, das den Filter passiert, extrahiert wird.

Überprüfen Sie, ob ein Element in einem Array vorhanden ist (das einige Kriterien erfüllt), und entfernen Sie in diesem Fall das erste derartige Element

Ein Kommentar unter Fragen:

Wie kann ich das firstSuchElementaus dem Array entfernen ?

Ein ähnlicher Anwendungsfall wie oben besteht darin , das erste Element zu entfernen, das ein bestimmtes Prädikat erfüllt. Zu diesem Zweck kann die index(where:)Methode von Collection(die für die Array-Sammlung leicht verfügbar ist) verwendet werden, um den Index des ersten Elements zu finden, das das Prädikat erfüllt, wonach der Index mit der remove(at:)Methode von Arrayto (möglich; vorausgesetzt, dass er existiert) verwendet werden kann. Entfernen Sie dieses Element.

var elements = ["a", "b", "c", "d", "e", "a", "b", "c"]

if let indexOfFirstSuchElement = elements.index(where: { $0 == "c" }) {
    elements.remove(at: indexOfFirstSuchElement)
    print(elements) // ["a", "b", "d", "e", "a", "b", "c"]
}

Wenn Sie das Element aus dem Array entfernen und damit arbeiten möchten , wenden Sie die Optionalfolgende map(_:)Methode an : s , um das Ergebnis von bedingt (für die .some(...)Rückgabe von index(where:)) zu verwenden index(where:), um das entfernte Element aus dem Array zu entfernen und zu erfassen (innerhalb einer optionalen Bindungsklausel). .

var elements = ["a", "b", "c", "d", "e", "a", "b", "c"]

if let firstSuchElement = elements.index(where: { $0 == "c" })
    .map({ elements.remove(at: $0) }) {

    // if we enter here, the first such element have now been
    // remove from the array
    print(elements) // ["a", "b", "d", "e", "a", "b", "c"]

    // and we may work with it
    print(firstSuchElement) // c
}

Beachten Sie, dass es sich bei dem erfundenen Beispiel oben um einfache Werttypen ( StringInstanzen) handelt. Die Verwendung eines Prädikats zum Auffinden eines bestimmten Elements ist daher etwas übertrieben , da wir die Gleichheit möglicherweise einfach mit der einfacheren index(of:)Methode testen , wie in der Antwort von @ DogCoffee gezeigt . Wenn Sie jedoch den obigen Find-and-Remove-Ansatz auf das PersonBeispiel anwenden , ist die Verwendung index(where:)mit einem Prädikat angemessen (da wir nicht mehr auf Gleichheit testen, sondern ein angegebenes Prädikat erfüllen).

Der einfachste Weg, dies zu erreichen, ist die Verwendung eines Filters für das Array.

let result = elements.filter { $0==5 }

resulthat das gefundene Element, wenn es existiert, und ist leer, wenn das Element nicht existiert. Wenn resultSie also einfach überprüfen, ob es leer ist, können Sie feststellen, ob das Element im Array vorhanden ist. Ich würde folgendes verwenden:

if result.isEmpty {
    // element does not exist in array
} else {
    // element exists
}

Swift 4/5

Eine andere Möglichkeit, dies zu erreichen, ist die Filterfunktion

var elements = [1,2,3,4,5]
if let object = elements.filter({ $0 == 5 }).first {
    print("found")
} else {
    print("not found")
}

Ab Swift 2.1 können NSArrays containsObjectwie folgt verwendet werden:

if myArray.containsObject(objectImCheckingFor){
    //myArray has the objectImCheckingFor
}

Nur für den Fall, dass jemand versucht herauszufinden, ob a indexPathzu den ausgewählten gehört (wie in a UICollectionViewoder UITableView cellForItemAtIndexPathFunktionen):

    var isSelectedItem = false
    if let selectedIndexPaths = collectionView.indexPathsForSelectedItems() as? [NSIndexPath]{
        if contains(selectedIndexPaths, indexPath) {
            isSelectedItem = true
        }
    }

Array

let elements = [1, 2, 3, 4, 5, 5]

Überprüfen Sie das Vorhandensein von Elementen

elements.contains(5) // true

Elementindex abrufen

elements.firstIndex(of: 5) // 4
elements.firstIndex(of: 10) // nil

Elementanzahl abrufen

let results = elements.filter { element in element == 5 }
results.count // 2

Hier ist meine kleine Erweiterung, die ich gerade geschrieben habe, um zu überprüfen, ob mein Delegatenarray ein Delegatenobjekt enthält oder nicht ( Swift 2 ). :) Es funktioniert auch mit Werttypen wie einem Zauber.

extension Array
{
    func containsObject(object: Any) -> Bool
    {
        if let anObject: AnyObject = object as? AnyObject
        {
            for obj in self
            {
                if let anObj: AnyObject = obj as? AnyObject
                {
                    if anObj === anObject { return true }
                }
            }
        }
        return false
    }
}

Wenn Sie eine Idee haben, wie Sie diesen Code optimieren können, lassen Sie es mich einfach wissen.

Wenn der Benutzer bestimmte Array-Elemente findet, verwenden Sie den folgenden Code wie den ganzzahligen Wert.

var arrelemnts = ["sachin", "test", "test1", "test3"]

 if arrelemnts.contains("test"){
    print("found")   }else{
    print("not found")   }

Schnell

Wenn Sie kein Objekt verwenden, können Sie diesen Code für enthält verwenden.

let elements = [ 10, 20, 30, 40, 50]

if elements.contains(50) {

   print("true")

}

Wenn Sie NSObject Class in Swift verwenden. Diese Variablen entsprechen meiner Anforderung. Sie können für Ihre Anforderung ändern.

var cliectScreenList = [ATModelLeadInfo]()
var cliectScreenSelectedObject: ATModelLeadInfo!

Dies gilt für denselben Datentyp.

{ $0.user_id == cliectScreenSelectedObject.user_id }

Wenn Sie AnyObject eingeben möchten.

{ "\($0.user_id)" == "\(cliectScreenSelectedObject.user_id)" }

Voller Zustand

if cliectScreenSelected.contains( { $0.user_id == cliectScreenSelectedObject.user_id } ) == false {

    cliectScreenSelected.append(cliectScreenSelectedObject)

    print("Object Added")

} else {

    print("Object already exists")

 }

Wie wäre es mit einer Hash-Tabelle für diesen Job?

Erstellen Sie zunächst eine generische Funktion "Hash Map", um das Sequenzprotokoll zu erweitern.

extension Sequence where Element: Hashable {

    func hashMap() -> [Element: Int] {
        var dict: [Element: Int] = [:]
        for (i, value) in self.enumerated() {
            dict[value] = i
        }
        return dict
    }
}

Diese Erweiterung funktioniert, solange die Elemente im Array mit Hashable übereinstimmen, z. B. Ganzzahlen oder Zeichenfolgen. Hier ist die Verwendung ...

let numbers = Array(0...50) 
let hashMappedNumbers = numbers.hashMap()

let numToDetect = 35

let indexOfnumToDetect = hashMappedNumbers[numToDetect] // returns the index of the item and if all the elements in the array are different, it will work to get the index of the object!

print(indexOfnumToDetect) // prints 35

Aber jetzt konzentrieren wir uns nur darauf, ob sich das Element im Array befindet.

let numExists = indexOfnumToDetect != nil // if the key does not exist 
means the number is not contained in the collection.

print(numExists) // prints true

Swift 4.2 + Mit
der folgenden Funktion können Sie leicht überprüfen, ob Ihre Instanz ein Array ist oder nicht.

func verifyIsObjectOfAnArray<T>(_ object: T) -> Bool {
   if let _ = object as? [T] {
      return true
   }

   return false
}

Sogar Sie können wie folgt darauf zugreifen. Sie erhalten, nilwenn das Objekt kein Array wäre.

func verifyIsObjectOfAnArray<T>(_ object: T) -> [T]? {
   if let array = object as? [T] {
      return array
   }

   return nil
}