Comment vérifier si un élément est dans un tableau

Dans Swift, comment puis-je vérifier si un élément existe dans un tableau? Xcode n'a pas de suggestions pour contain, includeou has, et une recherche rapide à travers le livre n'a rien donné . Une idée comment vérifier cela? Je sais qu'il existe une méthode findqui renvoie le numéro d'index, mais existe-t-il une méthode qui renvoie un booléen comme Ruby #include??

Exemple de ce dont j'ai besoin:

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()est une méthode d'extension de protocole de SequenceType(pour les séquences d' Equatableéléments) et non une méthode globale comme dans les versions précédentes.

Remarques:

• Cette contains()méthode nécessite que les éléments de séquence adoptent le Equatableprotocole, comparez par exemple la réponse d'Andrews .
• Si les éléments de séquence sont des instances d'une NSObjectsous - classe, vous devez remplacer isEqual:, voir Sous-classe NSObject dans Swift: hash vs hashValue, isEqual vs == .
• Il existe une autre contains()méthode - plus générale - qui ne nécessite pas que les éléments soient équitables et prend un prédicat comme argument, voir par exemple Shorthand pour tester si un objet existe dans un tableau pour Swift? .

Swift anciennes versions:

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

Pour ceux qui sont venus ici à la recherche d'une recherche et supprimer un objet d'un tableau:

Swift 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)
}

Utilisez cette extension:

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

Utilisé comme:

array.contains(1)

Mis à jour pour Swift 2/3

Notez que depuis Swift 3 (ou même 2), l'extension n'est plus nécessaire car la containsfonction globale a été transformée en une paire de méthodes d'extension Array, ce qui vous permet de faire l'une des choses suivantes:

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

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

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

Si vous vérifiez si une instance d'une classe ou d'une structure personnalisée est contenue dans un tableau, vous devrez implémenter le protocole Equatable avant de pouvoir utiliser .contains (myObject).

Par exemple:

struct Cup: Equatable {
    let filled:Bool
}

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

alors vous pouvez faire:

cupArray.contains(myCup)

Astuce : la substitution == doit être au niveau global, pas dans votre classe / structure

J'ai utilisé un filtre.

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

Si vous le souhaitez, vous pouvez le compresser en

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

J'espère que cela pourra aider.

Mise à jour pour Swift 2

Vive les implémentations par défaut!

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

(Swift 3)

Vérifiez si un élément existe dans un tableau (remplissant certains critères), et si oui, continuez à travailler avec le premier élément de ce type

Si l'intention est:

1. Pour vérifier si un élément existe dans un tableau (/ remplit certains critères booléens, pas nécessairement des tests d'égalité),
2. Et si oui, continuez et travaillez avec le premier élément de ce type,

Alors une alternative à contains(_:)as blueprinted Sequenceest first(where:)de Sequence:

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

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

Dans cet exemple artificiel, son utilisation peut sembler stupide, mais il est très utile si vous interrogez des tableaux de types d'éléments non fondamentaux pour l'existence de tout élément remplissant une condition. Par exemple

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.

Toute opération chaînée utilisant .filter { ... some condition }.firstpeut avantageusement être remplacée par first(where:). Ce dernier montre mieux l'intention et présente des avantages en termes de performances par rapport aux éventuels appareils non paresseux .filter, car ceux-ci passeront le tableau complet avant d'extraire le premier élément (possible) passant le filtre.

Vérifiez si un élément existe dans un tableau (remplissant certains critères), et si oui, supprimez le premier élément de ce type

Un commentaire ci-dessous interroge:

Comment puis-je supprimer le firstSuchElementdu tableau?

Un cas d'utilisation similaire à celui ci-dessus consiste à supprimer le premier élément qui remplit un prédicat donné. Pour ce faire, la index(where:)méthode de Collection(qui est facilement disponible pour la collection de tableaux) peut être utilisée pour trouver l'index du premier élément remplissant le prédicat, après quoi l'index peut être utilisé avec la remove(at:)méthode de Array(possible; étant donné qu'il existe) supprimer cet élément.

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"]
}

Ou, si vous souhaitez supprimer l'élément du tableau et travailler avec , appliquez la méthode Optional: s map(_:)à conditionnellement (pour le .some(...)retour de index(where:)) utiliser le résultat de index(where:)pour supprimer et capturer l'élément supprimé du tableau (dans une clause de liaison facultative) .

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
}

Notez que dans l'exemple artificiel ci-dessus, les membres du tableau sont des types de valeur simples ( Stringinstances), donc l'utilisation d'un prédicat pour trouver un membre donné est quelque peu exagérée , car nous pourrions simplement tester l'égalité en utilisant la index(of:)méthode la plus simple comme indiqué dans la réponse de @ DogCoffee . PersonCependant, si vous appliquez l'approche find-and-remove ci-dessus à l' exemple, l'utilisation index(where:)avec un prédicat est appropriée (puisque nous ne testons plus l'égalité mais pour remplir un prédicat fourni).

La façon la plus simple d'y parvenir est d'utiliser un filtre sur le tableau.

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

resultaura l'élément trouvé s'il existe et sera vide si l'élément n'existe pas. Donc, vérifier simplement si resultest vide vous dira si l'élément existe dans le tableau. J'utiliserais ce qui suit:

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

Swift 4/5

Une autre façon d'y parvenir est avec la fonction de filtre

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

Depuis Swift 2.1, les NSArrays containsObjectpeuvent être utilisés comme suit :

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

Juste au cas où quelqu'un essaierait de trouver si an indexPathest parmi ceux sélectionnés (comme dans a UICollectionViewou UITableView cellForItemAtIndexPathfonctions):

    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]

Vérifier la présence des éléments

elements.contains(5) // true

Obtenir l'index des éléments

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

Obtenir le nombre d'éléments

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

Voici ma petite extension que je viens d'écrire pour vérifier si mon tableau délégué contient ou non un objet délégué ( Swift 2 ). :) Il fonctionne également avec des types de valeur comme un charme.

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
    }
}

Si vous avez une idée comment optimiser ce code, faites-le moi savoir.

si l'utilisateur trouve des éléments de tableau particuliers, utilisez le code ci-dessous comme valeur entière.

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

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

Rapide

Si vous n'utilisez pas d'objet, vous pouvez utiliser ce code pour contient.

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

if elements.contains(50) {

   print("true")

}

Si vous utilisez NSObject Class dans swift. Cette variable est selon mes besoins. vous pouvez modifier selon vos besoins.

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

C'est pour un même type de données.

{ $0.user_id == cliectScreenSelectedObject.user_id }

Si vous souhaitez taper AnyObject.

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

État complet

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

    cliectScreenSelected.append(cliectScreenSelectedObject)

    print("Object Added")

} else {

    print("Object already exists")

 }

qu'en est-il de l'utilisation d'une table de hachage pour le travail, comme ça?

tout d'abord, en créant une fonction générique de "carte de hachage", étendant le protocole de séquence.

extension Sequence where Element: Hashable {

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

Cette extension fonctionnera tant que les éléments du tableau seront conformes à Hashable, comme les entiers ou les chaînes, voici l'utilisation ...

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

Mais pour l'instant, concentrons-nous juste pour vérifier si l'élément est dans le tableau.

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 +
Vous pouvez facilement vérifier que votre instance est un tableau ou non par la fonction suivante.

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

   return false
}

Même vous pouvez y accéder comme suit. Vous recevrez nilsi l'objet ne serait pas un tableau.

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

   return nil
}