ค้นหาวัตถุในอาร์เรย์หรือไม่

Swift มีบางอย่างเช่น_.findWhereใน Underscore.js หรือไม่

ฉันมีอาร์เรย์ของ structs ของพิมพ์Tและต้องการที่จะตรวจสอบว่าอาร์เรย์ประกอบด้วยวัตถุ struct ที่มีคุณสมบัติเท่ากับnameFoo

พยายามที่จะใช้find()และfilter()แต่พวกเขาเท่านั้นทำงานกับชนิดดั้งเดิมเช่นหรือString Intโยนข้อผิดพลาดเกี่ยวกับการไม่ปฏิบัติตามEquitableโปรโตคอลหรืออะไรทำนองนั้น

FWIW หากคุณไม่ต้องการใช้ฟังก์ชั่นหรือส่วนขยายที่กำหนดเองคุณสามารถ:

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

สิ่งนี้สร้างnameอาร์เรย์ก่อนfindจากนั้น

หากคุณมีอาร์เรย์ขนาดใหญ่คุณอาจต้องการ:

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

หรืออาจจะ:

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

สวิฟท์ 5

ตรวจสอบองค์ประกอบที่มีอยู่

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

รับองค์ประกอบ

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

รับองค์ประกอบและชดเชย

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
}

รับการชดเชย

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

คุณสามารถใช้indexวิธีที่มีให้พร้อมArrayกับเพรดิเคต ( ดูเอกสารประกอบของ Apple ที่นี่ )

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

สำหรับตัวอย่างเฉพาะของคุณสิ่งนี้จะเป็น:

สวิฟท์ 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]
}

สวิฟท์ 3

หากคุณต้องการใช้วัตถุ:

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

(หากคุณมีวัตถุมากกว่าหนึ่งชื่อ "Foo" firstจะส่งคืนวัตถุแรกจากการสั่งซื้อที่ไม่ระบุ)

คุณสามารถกรองอาร์เรย์และจากนั้นเพียงแค่เลือกองค์ประกอบแรกที่แสดงในพบวัตถุที่มีคุณสมบัติในอาร์เรย์

หรือคุณกำหนดนามสกุลที่กำหนดเอง

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

ตัวอย่างการใช้งาน:

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
}

ในSwift 3คุณสามารถใช้first(where:)วิธีการที่มีอยู่( ดังที่กล่าวไว้ในความคิดเห็น ):

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

สวิฟท์ 2.1

ตอนนี้การกรองในคุณสมบัติวัตถุได้รับการสนับสนุนใน swift 2.1 คุณสามารถกรองอาร์เรย์ของคุณตามค่าใด ๆ ของ struct หรือคลาสที่นี่เป็นตัวอย่าง

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

หรือ

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

สวิฟท์ 4 ,

อีกวิธีหนึ่งในการบรรลุเป้าหมายนี้โดยใช้ฟังก์ชั่นตัวกรอง

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

สวิฟท์ 3

คุณสามารถใช้ดัชนี (โดยที่ :) ใน Swift 3

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

ตัวอย่าง

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

สวิฟท์ 3

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

Swift 2 หรือใหม่กว่า

คุณสามารถรวมindexOfและmapเขียนฟังก์ชัน "ค้นหาองค์ประกอบ" ในบรรทัดเดียว

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

ใช้filter+ firstดูสะอาดตา แต่filterประเมินองค์ประกอบทั้งหมดในอาร์เรย์ indexOf+ mapดูซับซ้อน แต่การประเมินจะหยุดเมื่อพบคู่แรกในอาร์เรย์ ทั้งสองวิธีมีข้อดีข้อเสีย

การใช้contains:

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

หรือคุณสามารถลองสิ่งที่มาร์ตินชี้ไปที่คุณในความคิดเห็นและให้ filterลองอื่น: ค้นหาวัตถุที่มีคุณสมบัติในอาร์เรย์

อีกวิธีในการเข้าถึง array.index (of: Any) คือการประกาศวัตถุของคุณ

import Foundation
class Model: NSObject {  }

ใช้Dollarซึ่งเป็น Lo-Dash หรือ Underscore.js สำหรับ Swift:

import Dollar

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

สวิฟท์ 3:

คุณสามารถใช้ Swifts ในฟังก์ชันการทำงานเพื่อค้นหาวัตถุที่กำหนดเองใน Array

ก่อนอื่นคุณต้องตรวจสอบให้แน่ใจว่าวัตถุที่กำหนดเองของคุณเป็นไปตาม: โปรโตคอลที่เท่าเทียมกัน

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

ด้วยฟังก์ชั่น Equatable ที่เพิ่มให้กับวัตถุของคุณ Swift จะแสดงคุณสมบัติเพิ่มเติมที่คุณสามารถใช้กับอาเรย์:

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

สำหรับ Swift 3

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

ตัวอย่างเช่นถ้าเรามีจำนวนอาร์เรย์:

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

เราสามารถหาเลขคี่แรกเช่นนี้:

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

ที่จะส่งกลับ 4 เป็นจำนวนเต็มเผื่อเลือกเพราะเลขคี่แรก (9) อยู่ที่ดัชนีสี่