Rechercher le premier élément de la condition de correspondance dans Swift array (par exemple EKSource)

J'aimerais trouver le premier EKSource de type EKSourceType.Local avec un "simple"de la ligne de l'expression en Swift. Voici ce que j'ai actuellement:

let eventSourceForLocal = 
    eventStore.sources[eventStore.sources.map({ $0.sourceType })
        .indexOf(EKSourceType.Local)!]

Est-il une meilleure manière de faire ceci (comme sans de cartographie et/ou avec une version générique de find)?

InformationsquelleAutor Drux | 2015-11-19

37

Il y a une version de indexOf qui prend un prédicat de la fermeture de l'utiliser pour trouver l'index de la première source locale (si elle existe), et ensuite utiliser cet index sur eventStore.sources:
```
if let index = eventStore.sources.indexOf({ $0.sourceType == .Local }) {
    let eventSourceForLocal = eventStore.sources[index]
}
```
Alternativement, vous pouvez ajouter un générique find méthode via une extension sur SequenceType:
```
extension SequenceType {
    func find(@noescape predicate: (Self.Generator.Element) throws -> Bool) rethrows -> Self.Generator.Element? {
        for element in self {
            if try predicate(element) {
                return element
            }
        }
        return nil
    }
}

let eventSourceForLocal = eventStore.sources.find({ $0.sourceType == .Local })
```
(Pourquoi n'est-ce pas là déjà?)
- je ne suis pas sûr pourquoi, mais peut-être parce que "type de séquence ne comporte aucune exigence sur la conformité des types de quant à savoir si ils seront de façon destructrice "consommée" par itération. Pour s'assurer de la non-destructive itération, les contraindre votre séquence de CollectionType."
- aussi il manque essayez de partie (prédicat peut jeter)
- Bonne prise sur la try, fixe. Toutes les opérations de séquence permettra de consommer de la séquence (carte, contient, etc), donc je ne pense pas que c'est. indexOf fonctionne très bien, mais est limité aux collections.
- J'ai appelé le mien findFirst parce que des thats un peu plus d'auto-documentation:)
- Bonne nouvelle, Swift 3 inclut désormais un first(where:) méthode sur des séquences qui fait juste cela.
- c'est génial @NateCook !
- Lien vers la proposition github.com/apple/swift-evolution/blob/master/proposals/...
InformationsquelleAutor Nate Cook
80

Alternativement dans Swift3, vous pouvez utiliser:
```
let local = eventStore.sources.first(where: {$0.sourceType == .Local}) 
```
- Dans Swift4, qui devient: let local = eventStore.sources.first {$0.sourceType == .Local}
- C'est la bonne réponse, à l'aide de filter puis first est sous-optimale, parce qu'il oblige pire des cas de n temps de la complexité. Cela signifie que même lorsque vous avez trouvé l'élément, filtre va encore faire une boucle par le reste de la matrice. first(where:{}) les courts-circuits de la traversée et les pauses après il trouve la première occurrence.
InformationsquelleAutor Bueno
19

Je ne comprends pas pourquoi vous utilisez map à tous. Pourquoi ne pas utiliser filter? Vous aurez ensuite jusqu'à la fin avec toutes les sources locales, mais, en réalité, il n'y aura probablement qu'un seul, voire aucun, et vous pouvez facilement le trouver en posant pour la première (il sera nil si il n'y a pas un):
```
let local = eventStore.sources.filter{$0.sourceType == .Local}.first
```
- Alors que c'est la plus straight-forward solution, elle a l'inconvénient de toujours filtrage de l'ensemble de la collection, même si il n'a besoin que le premier élément correspondant. Je ne dis pas pour l'optimisation prématurée, mais pour les grandes collections qui comptent.
- Je suis d'accord, j'aime Nate Cuire la réponse de mieux.
- OMI optimisation prématurée n'a même pas entrer en jeu ici, évitant complètement inutile le travail n'est ni prématurée, ni d'optimisation.
- Afin de vous faire let local = eventStore.sources.lazy.filter{$0.sourceType == .Local}.first
InformationsquelleAutor matt
10

Swift 4 solution qui s'occupe également de la situation, quand il n'y a pas d'éléments dans votre tableau qui correspondent à votre état:
```
if let firstMatch = yourArray.first{$0.id == lookupId} {
  print("found it: \(firstMatch)")
} else {
  print("nothing found :(")
}
```
InformationsquelleAutor budidino
2

Essayons quelque chose de plus fonctionnel:
```
let arr = [0,1,2,3]
let result = arr.lazy.map{print("");return $0}.first(where: {$0 == 2})
print(result)//3x  then 2
```
Ce qui est cool à ce sujet?

Vous obtenez l'accès à l'élément ou j'tandis que vous recherchez. Et il est fonctionnel.

InformationsquelleAutor eonist

Pour Swift 3, vous aurez besoin de faire quelques petits changements à Nate réponse ci-dessus. Voici la Swift 3 version:

public extension Sequence {
    func find(predicate: (Iterator.Element) throws -> Bool) rethrows -> Iterator.Element? {
        for element in self {
            if try predicate(element) {
                return element
            }
        }
        return nil
    }
}

Changements: SequenceType > Sequence, Self.Generator.Element > Iterator.Element

InformationsquelleAutor Tyler Sheaffer

Vous devez vous connecter pour publier un commentaire.

Essayons quelque chose de plus fonctionnel: