Dizideki bir nesneyi mi buldunuz?

Swift, Underscore.js'de _.findWhere gibi bir şeye sahip mi?

Tür yapıları bir dizi var ve dizi özelliği eşit Tbir yapı nesnesi içerip içermediğini denetlemek istiyorum .nameFoo

Kullanmaya çalıştım find()ve filter()sadece ilkel tiplerle çalışıyorlar, örneğin Stringveya Int. EquitableProtokole veya buna benzer bir şeye uymama konusunda bir hata atar .

FWIW, özel işlev veya uzantı kullanmak istemiyorsanız şunları yapabilirsiniz:

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

Bu nameönce diziyi sonra da diziyi oluşturur find.

Büyük bir diziniz varsa, şunları yapmak isteyebilirsiniz:

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

ya da belki:

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

SWIFT 5

Öğenin var olup olmadığını kontrol edin

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

Elemanı al

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

Elemanı ve ofsetini alı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
}

Ofseti alın

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

Sen kullanabilirsiniz indexgeçerli yöntem Array(bir yüklemi burada Apple'ın belgelerine bakın ).

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

Özel örneğiniz için bu şöyle olur:

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

Hızlı 3

Nesne kullanımına ihtiyacınız varsa:

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

("Foo" adında birden fazla nesneniz varsa first, ilk nesneyi belirtilmemiş bir siparişten döndürür)

Sen edebilir filtre dizisi ve gösterildiği gibi sonra sadece birinci elemanı almak Array Mülkü'yle Bul Nesne .

Veya özel bir uzantı tanımlarsınız

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

Kullanım örneği:

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
}

In Swift 3 varolan kullanabilirsiniz first(where:)yöntemi (aynı Bir yorumda ):

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

Hızlı 2.1

Nesne özelliklerinde filtreleme artık hızlı 2.1'de destekleniyor. Dizinizi yapının veya sınıfın herhangi bir değerine göre filtreleyebilirsiniz burada bir örnek

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

VEYA

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

Swift 4 ,

Filtre işlevini kullanarak bunu başarmanın başka bir yolu,

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

Hızlı 3

Swift 3'te index (where :) kullanabilirsiniz

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

misal

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

Hızlı 3

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

Swift 2 veya üstü

Bir araya getirebilir indexOfve map"bul eleman" fonksiyonunu tek bir satıra yazabilirsiniz.

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+ Kullanımı firstdaha temiz görünür, ancak filterdizideki tüm öğeleri değerlendirir. indexOf+ mapkarmaşık görünüyor, ancak dizideki ilk eşleşme bulunduğunda değerlendirme durur. Her iki yaklaşımın da artıları ve eksileri vardır.

Kullanım contains:

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

Veya yorumlarda Martin'in işaret ettiği şeyi filterdeneyebilir ve başka bir deneme yapabilirsiniz: Array'da Mülkiyetli Nesne Bul .

Array.index'e (of: Any) erişmenin başka bir yolu da nesnenizi bildirmektir

import Foundation
class Model: NSObject {  }

Swift için Lo-Dash veya Underscore.js olan Dolar'ı kullanın :

import Dollar

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

Hızlı 3:

Bir Dizideki özel nesneleri bulmak için yerleşik işlevsellikleri kullanabilirsiniz.

Öncelikle özel nesnenizin: Equatable protokolüne uygun olduğundan emin olmalısınız .

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

Nesnenize Eşitlenebilir işlevsellik eklendiğinde, Swift artık bir dizide kullanabileceğiniz ek özellikler gösterecek:

//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 için,

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

Örneğin, bir dizi sayımız olsaydı:

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

İlk tek sayıyı şu şekilde bulabiliriz:

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

Bu, 4'ü isteğe bağlı bir tamsayı olarak geri gönderir, çünkü ilk tek sayı (9) dördüncü dizindedir.