Tìm một đối tượng trong mảng?

Swift có cái gì đó như _.findWhere không trong Underscore.js không?

Tôi có một mảng các cấu trúc kiểu Tvà muốn kiểm tra xem mảng có chứa đối tượng struct có thuộc nametính bằng không Foo.

Đã thử sử dụng find()và filter()chúng chỉ hoạt động với các kiểu nguyên thủy, ví dụ Stringhoặc Int. Ném một lỗi về việc không tuân thủ Equitablegiao thức hoặc một cái gì đó tương tự.

FWIW, nếu bạn không muốn sử dụng chức năng tùy chỉnh hoặc tiện ích mở rộng, bạn có thể:

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

Điều này tạo ra namemảng đầu tiên, sau đófind từ nó.

Nếu bạn có mảng lớn, bạn có thể muốn làm:

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

hoặc có thể:

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

Chuyển 5

Kiểm tra xem phần tử có tồn tại không

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

Lấy phần tử

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

Lấy phần tử và phần bù của nó

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
}

Lấy phần bù

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

Bạn có thể sử dụng indexphương thức khả dụng Arrayvới một vị ngữ ( xem tài liệu của Apple tại đây ).

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

Ví dụ cụ thể của bạn, đây sẽ là:

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

Nếu bạn cần đối tượng sử dụng:

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

(Nếu bạn có nhiều hơn một đối tượng có tên "Foo" thì firstsẽ trả về đối tượng đầu tiên từ một thứ tự không xác định)

Bạn có thể lọc mảng và sau đó chỉ cần chọn phần tử đầu tiên, như được hiển thị trong Tìm đối tượng với thuộc tính trong mảng .

Hoặc bạn xác định tiện ích mở rộng tùy chỉnh

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

Ví dụ sử dụng:

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
}

Trong Swift 3, bạn có thể sử dụng first(where:)phương thức hiện có (như được đề cập trong một nhận xét ):

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

Lọc trong thuộc tính đối tượng hiện được hỗ trợ trong swift 2.1. Bạn có thể lọc mảng của mình dựa trên bất kỳ giá trị nào của struct hoặc class ở đây là một ví dụ

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

HOẶC LÀ

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

Swift 4 ,

Một cách khác để đạt được điều này bằng cách sử dụng chức năng lọc,

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

Swift 3

bạn có thể sử dụng chỉ mục (trong đó :) trong Swift 3

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

thí dụ

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 trở lên

Bạn có thể kết hợp indexOfvà mapviết hàm "tìm phần tử" trong một dòng.

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

Sử dụng filter+ firsttrông sạch hơn, nhưng filterđánh giá tất cả các yếu tố trong mảng. indexOf+ có mapvẻ phức tạp, nhưng việc đánh giá dừng lại khi tìm thấy kết quả khớp đầu tiên trong mảng. Cả hai cách tiếp cận đều có ưu và nhược điểm.

Sử dụng contains:

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

Hoặc bạn có thể thử những gì Martin chỉ cho bạn, trong các bình luận và filterthử lại: Tìm đối tượng với thuộc tính trong mảng .

Một cách khác để có quyền truy cập vào Array.index (of: Any) là khai báo đối tượng của bạn

import Foundation
class Model: NSObject {  }

Sử dụng Dollar là Lo-Dash hoặc Underscore.js cho Swift:

import Dollar

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

Swift 3:

Bạn có thể sử dụng Swifts tích hợp trong chức năng để tìm các đối tượng tùy chỉnh trong Mảng.

Trước tiên, bạn phải đảm bảo đối tượng tùy chỉnh của mình tuân thủ giao thức : Tương đương .

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

Với chức năng Equitable được thêm vào đối tượng của bạn, Swift sẽ hiển thị cho bạn các thuộc tính bổ sung mà bạn có thể sử dụng trên một mảng:

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

Dành cho Swift 3,

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

Ví dụ: nếu chúng ta có một dãy số:

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

Chúng ta có thể tìm thấy số lẻ đầu tiên như thế này:

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

Điều đó sẽ gửi lại 4 dưới dạng một số nguyên tùy chọn, bởi vì số lẻ đầu tiên (9) nằm ở chỉ số bốn.