L'héritage de la non-protocole, non-Type de classe

Je veux une extension sur un Tableau où vous pouvez trouver un élément qui est d'un certain type.

J'ai essayé comme ceci:

  func findItem<U: Type>(itemToFind: U) -> AnyObject? {
    for item in self {
        if let obj = item as? itemToFind {
            return obj
        }
    }
    return nil
}

J'ai donc vérifier si c'est le même type et puis je veux le retour de l'obj.

L'erreur que j'obtiens est:

Héritage de non-protocole, non-classe "Type".

Comment puis-je résoudre ce que je peux passer à la fonction ViewController.self et que je serai de retour nul si on ne trouve pas ou le viewcontroller qui est dans le tableau?

Qu'est-ce que Type?
J'ai pensé que je pouvais l'utiliser parce que l'Objet.dynamicType donne le type? Ou n'est-ce pas possible?

InformationsquelleAutor user1007522 | 2016-08-29

generics swift

13

La syntaxe <U: Type> dans ce contexte signifie que vous êtes à la déclaration d'un nouveau générique de l'espace réservé U dans votre signature de fonction, qui hérite de l' (dans le cas des classes), ou est conforme à (dans le cas de protocoles) Type.

Comme Type est ni protocole, ni de classe, je suppose que ce que vous voulez vraiment est une contrainte générique de l'espace réservé, et, au contraire, veulent passer à un type donné comme argument à la fonction, qui va définir le type de U.

Dans ce cas, vous aurez envie d'utiliser le metatype U.Type que l'entrée de la fonction type (ainsi que U? pour le type de retour de fonction – en tant que le type de retour sera le type facultatif quel que soit le type que vous passez à la fonction). Par exemple:
```
extension Array {
    func firstElement<U>(ofType _: U.Type) -> U? {
        for element in self {
            if let element = element as? U {
                return element
            }
        }
        return nil
    }
}
```
```
let array : [Any] = [2, "bar", 3, "foo"]
print(array.firstElement(ofType: String.self)) // Optional("bar")
```
Comme une note de côté, cela pourrait être légèrement simplifié par l'utilisation de le pattern matching dans le for boucle:
```
func firstElement<U>(ofType _: U.Type) -> U? {
    for case let element as U in self {
        return element
    }
    return nil
}
```
- Je vous remercie. J'ai appris quelque chose de nouveau aujourd'hui 🙂
- Heureux de vous aider 🙂
- il donne l'idée à mon problème différent. nice.
InformationsquelleAutor Hamish

utilisation is à la place.

let arr : [Any] = ["jj", "j", 1, 1.0]

func findItems(of : Any.Type, from array: [Any]) -> Any? {
    for item in array { 
        if item is String {
            return item
        }
    }
    return nil
}

print(findItems(of: String.self, from: arr)) // jj

InformationsquelleAutor Honey

Vous devez vous connecter pour publier un commentaire.