Temukan objek dalam array?

Apakah Swift memiliki sesuatu seperti _.findWhere di Underscore.js?

Saya memiliki array tipe struct Tdan ingin memeriksa apakah array berisi objek struct yang namepropertinya sama dengan Foo.

Sudah mencoba menggunakan find()dan filter()tetapi mereka hanya bekerja dengan tipe primitif, misalnya Stringatau Int. Melempar kesalahan tentang tidak mematuhi Equitableprotokol atau sesuatu seperti itu.

FWIW, jika Anda tidak ingin menggunakan fungsi atau ekstensi khusus, Anda dapat:

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

Ini menghasilkan namearray pertama, lalu finddarinya.

Jika Anda memiliki array besar, Anda mungkin ingin melakukan:

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

atau mungkin:

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

SWIFT 5

Periksa apakah ada elemen

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

Dapatkan elemennya

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

Dapatkan elemen dan offsetnya

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
}

Dapatkan offsetnya

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

Anda dapat menggunakan indexmetode yang tersedia Arraydengan predikat ( lihat dokumentasi Apple di sini ).

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

Untuk contoh spesifik Anda, ini akan menjadi:

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

Cepat 3

Jika Anda perlu menggunakan objek:

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

(Jika Anda memiliki lebih dari satu objek bernama "Foo" maka firstakan mengembalikan objek pertama dari pemesanan yang tidak ditentukan)

Anda bisa memfilter array dan kemudian hanya memilih elemen pertama, seperti yang ditunjukkan pada Find Object with Property in Array .

Atau Anda menentukan ekstensi khusus

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

Contoh penggunaan:

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
}

Di Swift 3 Anda dapat menggunakan first(where:)metode yang ada (seperti yang disebutkan dalam komentar ):

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

Cepat 2.1

Pemfilteran dalam properti objek sekarang didukung di swift 2.1. Anda dapat memfilter array Anda berdasarkan nilai struct atau kelas di sini sebagai contoh

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

ATAU

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

Swift 4 ,

Cara lain untuk mencapai ini menggunakan fungsi filter,

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

Cepat 3

Anda dapat menggunakan indeks (di mana :) di Swift 3

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

contoh

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

Cepat 3

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

Cepat 2 atau lebih baru

Anda dapat menggabungkan indexOfdan mapmenulis fungsi "find element" dalam satu baris.

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")"

Menggunakan filter+ firstterlihat lebih bersih, tetapi filtermengevaluasi semua elemen dalam array. indexOf+ mapterlihat rumit, tetapi evaluasi berhenti ketika kecocokan pertama dalam array ditemukan. Kedua pendekatan memiliki pro dan kontra.

Gunakan contains:

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

Atau Anda bisa mencoba apa yang Martin tunjukkan, di komentar dan filtercoba lagi: Temukan Objek dengan Properti di Array .

Cara lain untuk mendapatkan akses ke array.index (dari: Any) adalah dengan mendeklarasikan objek Anda

import Foundation
class Model: NSObject {  }

Gunakan Dollar yang merupakan Lo-Dash atau Underscore.js untuk Swift:

import Dollar

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

Swift 3:

Anda dapat menggunakan fungsionalitas bawaan Swift untuk menemukan objek khusus dalam Array.

Pertama, Anda harus memastikan objek kustom Anda sesuai dengan: Protokol yang setara .

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

Dengan fungsi Equatable yang ditambahkan ke objek Anda, Swift sekarang akan menunjukkan kepada Anda properti tambahan yang dapat Anda gunakan pada array:

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

Untuk Swift 3,

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

Misalnya, jika kami memiliki array angka:

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

Kami dapat menemukan nomor ganjil pertama seperti ini:

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

Itu akan mengirim kembali 4 sebagai bilangan bulat opsional, karena angka ganjil pertama (9) adalah pada indeks empat.