Trouver un objet dans un tableau?

Swift a-t-il quelque chose comme _.findWhere dans Underscore.js?

J'ai un tableau de structures de type Tet je voudrais vérifier si array contient un objet struct dont la namepropriété est égale à Foo.

J'ai essayé d'utiliser find()et filter()mais ils ne fonctionnent qu'avec des types primitifs, par exemple Stringou Int. Lève une erreur concernant le non-respect du Equitableprotocole ou quelque chose comme ça.

FWIW, si vous ne souhaitez pas utiliser de fonction ou d'extension personnalisée, vous pouvez:

let array = [ .... ]
if let found = find(array.map({ $0.name }), "Foo") {
    let obj = array[found]
}

Cela génère named'abord le tableau, puis à findpartir de celui-ci.

Si vous avez un énorme tableau, vous pouvez faire:

if let found = find(lazy(array).map({ $0.name }), "Foo") {
    let obj = array[found]
}

ou peut-être:

if let found = find(lazy(array).map({ $0.name == "Foo" }), true) {
    let obj = array[found]
}

SWIFT 5

Vérifier si l'élément existe

if array.contains(where: {$0.name == "foo"}) {
   // it exists, do something
} else {
   //item could not be found
}

Obtenez l'élément

if let foo = array.first(where: {$0.name == "foo"}) {
   // do something with foo
} else {
   // item could not be found
}

Obtenir l'élément et son décalage

if let foo = array.enumerated().first(where: {$0.element.name == "foo"}) {
   // do something with foo.offset and foo.element
} else {
   // item could not be found
}

Obtenez le décalage

if let fooOffset = array.firstIndex(where: {$0.name == "foo"}) {
    // do something with fooOffset
} else {
    // item could not be found
}

Vous pouvez utiliser la indexméthode disponible sur Arrayavec un prédicat ( voir la documentation Apple ici ).

func index(where predicate: (Element) throws -> Bool) rethrows -> Int?

Pour votre exemple spécifique, ce serait:

Swift 5.0

if let i = array.firstIndex(where: { $0.name == "Foo" }) {
    return array[i]
}

Swift 3.0

if let i = array.index(where: { $0.name == Foo }) {
    return array[i]
}

Swift 2.0

if let i = array.indexOf({ $0.name == Foo }) {
    return array[i]
}

Swift 3

Si vous avez besoin de l'objet, utilisez:

array.first{$0.name == "Foo"}

(Si vous avez plus d'un objet nommé "Foo" first, le premier objet retournera d'un ordre non spécifié)

Vous pouvez filtrer le tableau, puis choisir simplement le premier élément, comme indiqué dans Rechercher un objet avec une propriété dans un tableau .

Ou vous définissez une extension personnalisée

extension Array {

    // Returns the first element satisfying the predicate, or `nil`
    // if there is no matching element.
    func findFirstMatching<L : BooleanType>(predicate: T -> L) -> T? {
        for item in self {
            if predicate(item) {
                return item // found
            }
        }
        return nil // not found
    }
}

Exemple d'utilisation:

struct T {
    var name : String
}

let array = [T(name: "bar"), T(name: "baz"), T(name: "foo")]

if let item = array.findFirstMatching( { $0.name == "foo" } ) {
    // item is the first matching array element
} else {
    // not found
}

Dans Swift 3, vous pouvez utiliser la first(where:)méthode existante (comme mentionné dans un commentaire ):

if let item = array.first(where: { $0.name == "foo" }) {
    // item is the first matching array element
} else {
    // not found
}

Swift 3.0

if let index = array.index(where: { $0.name == "Foo" }) {
    return array[index]
}

Swift 2.1

Le filtrage dans les propriétés des objets est désormais pris en charge dans swift 2.1. Vous pouvez filtrer votre tableau en fonction de n'importe quelle valeur de la structure ou de la classe, voici un exemple

for myObj in myObjList where myObj.name == "foo" {
 //object with name is foo
}

OU

for myObj in myObjList where myObj.Id > 10 {
 //objects with Id is greater than 10
}

Swift 4 ,

Une autre façon d'y parvenir en utilisant la fonction de filtre,

if let object = elements.filter({ $0.title == "title" }).first {
    print("found")
} else {
    print("not found")
}

Swift 3

vous pouvez utiliser index (où :) dans Swift 3

func index(where predicate: @noescape Element throws -> Bool) rethrows -> Int?

exemple

if let i = theArray.index(where: {$0.name == "Foo"}) {
    return theArray[i]
}

Swift 3

if yourArray.contains(item) {
   //item found, do what you want
}
else{
   //item not found 
   yourArray.append(item)
}

Swift 2 ou version ultérieure

Vous pouvez combiner indexOfet mapécrire une fonction "find element" sur une seule ligne.

let array = [T(name: "foo"), T(name: "Foo"), T(name: "FOO")]
let foundValue = array.indexOf { $0.name == "Foo" }.map { array[$0] }
print(foundValue) // Prints "T(name: "Foo")"

L'utilisation de filter+ firstsemble plus propre, mais filterévalue tous les éléments du tableau. indexOf+ mapsemble compliqué, mais l'évaluation s'arrête lorsque la première correspondance du tableau est trouvée. Les deux approches ont des avantages et des inconvénients.

Utilisez contains:

var yourItem:YourType!
if contains(yourArray, item){
    yourItem = item
}

Ou vous pouvez essayer ce que Martin vous a indiqué dans les commentaires et filterréessayer: Rechercher un objet avec une propriété dans un tableau .

Une autre façon d'accéder à array.index (of: Any) est de déclarer votre objet

import Foundation
class Model: NSObject {  }

Utilisez Dollar qui est Lo-Dash ou Underscore.js pour Swift:

import Dollar

let found = $.find(array) { $0.name == "Foo" }

Swift 3:

Vous pouvez utiliser la fonctionnalité intégrée Swifts pour rechercher des objets personnalisés dans un tableau.

Vous devez d'abord vous assurer que votre objet personnalisé est conforme au protocole : Equatable .

class Person : Equatable { //<--- Add Equatable protocol
    let name: String
    var age: Int

    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }

    //Add Equatable functionality:
    static func == (lhs: Person, rhs: Person) -> Bool {
        return (lhs.name == rhs.name)
    }
}

Avec la fonctionnalité Equatable ajoutée à votre objet, Swift vous montrera désormais des propriétés supplémentaires que vous pouvez utiliser sur un tableau:

//create new array and populate with objects:
let p1 = Person(name: "Paul", age: 20)
let p2 = Person(name: "Mike", age: 22)
let p3 = Person(name: "Jane", age: 33)
var people = [Person]([p1,p2,p3])

//find index by object:
let index = people.index(of: p2)! //finds Index of Mike

//remove item by index:
people.remove(at: index) //removes Mike from array

Pour Swift 3,

let index = array.index(where: {$0.name == "foo"})

Par exemple, si nous avions un tableau de nombres:

let numbers = [2, 4, 6, 8, 9, 10]

Nous pourrions trouver le premier nombre impair comme ceci:

let firstOdd = numbers.index { $0 % 2 == 1 }

Cela renverra 4 comme entier facultatif, car le premier nombre impair (9) est à l'index quatre.