Swift 3: Tableau de Dictionnaire?

Sur Swift 4, vous pouvez atteindre cet objectif en utilisant du Dictionnaire grouping:by: initialiseur

Par ex:
Vous disposez de classe nommée Un

class A {

    var name: String

    init(name: String) {
        self.name = name
    }
    //.
    //.
    //.
    //other declations and implementions
}

Ensuite, vous avez un tableau d'objets de type Un

let a1 = A(name: "Joy")
let a2 = A(name: "Ben")
let a3 = A(name: "Boy")
let a4 = A(name: "Toy")
let a5 = A(name: "Tim")

let array = [a1, a2, a3, a4, a5]

Disons que vous voulez créer un Dictionnaire par le regroupement de tous les noms par leur première lettre. Vous utilisez les Martinets Dictionary(grouping:by:) pour atteindre cet

let dictionary = Dictionary(grouping: array, by: { $0.name.first! })
//this will give you a dictionary
// ["J": [a1], "B": [a2, a3], "T": [a4, a5]] 

source

OriginalL'auteur

Que les autres ont déjà dit, nous avons besoin de comprendre qui sont les clés.

Cependant je suis en train d'essayer d'apporter une solution à mon interprétation de votre question.

struct User {
    let id: String
    let firstName: String
    let lastName: String
}

Ici, je suis en supposant que les 2 utilisateurs avec le même id ne peut pas exister

let users: [User] = ...

let dict = users.reduce([String:User]()) { (result, user) -> [String:User] in
    var result = result
    result[user.id] = user
    return result
}

Maintenant dict est un dictionnaire où l' key est le user id et la value est le user value.

À l'accès d'un utilisateur par l'intermédiaire de son id vous pouvez maintenant simplement écrire

let user = dict["123"]

Mise à jour #1: approche Générale

Donné un tableau d'un type donné Element, et une fermeture de déterminer la key d'un Element, la suivante de la fonction générique va générer un Dictionary de type [Key:Element]

func createIndex<Key, Element>(elms:[Element], extractKey:(Element) -> Key) -> [Key:Element] where Key : Hashable {
    return elms.reduce([Key:Element]()) { (dict, elm) -> [Key:Element] in
        var dict = dict
        dict[extractKey(elm)] = elm
        return dict
    }
}

Exemple

let users: [User] = [
    User(id: "a0", firstName: "a1", lastName: "a2"),
    User(id: "b0", firstName: "b1", lastName: "b2"),
    User(id: "c0", firstName: "c1", lastName: "c2")
 ]

let dict = createIndex(elms: users) { $0.id }
// ["b0": {id "b0", firstName "b1", lastName "b2"}, "c0": {id "c0", firstName "c1", lastName "c2"}, "a0": {id "a0", firstName "a1", lastName "a2"}]

Mise à jour #2

Comme l'a noté Martin R la réduire permettra de créer un nouveau dictionnaire pour chaque itération de la fermeture. Cela pourrait conduire à une consommation de mémoire.

Voici une autre version de la createIndex fonction où l'espace est en O(n) où n est la longueur des ormes.

func createIndex<Key, Element>(elms:[Element], extractKey:(Element) -> Key) -> [Key:Element] where Key : Hashable {
    var dict = [Key:Element]()
    for elm in elms {
        dict[extractKey(elm)] = elm
    }
    return dict
}

OriginalL'auteur

Juste de le faire simplement,

let items = URLComponents(string: "https://im.qq.com?q=13&id=23")!.queryItems!

var dic = [String: Any?]()
items.foreach {
    dic[$0.name] = $0.value
}

reduce n'est pas très approprié,

let dic: [String: Any?] = items.reduce([:]) { (result: [String: Any?], item: URLQueryItem) -> [String: Any?] in
   var r = result
   r[item.name] = item.value //will create an copy of result!!!!!!
   return r
}

OriginalL'auteur

Le suivant convertit un tableau d'un dictionnaire.

let firstArray = [2,3,4,5,5] 

let dict = Dictionary(firstArray.map { ($0, 1) } , uniquingKeysWith: +)

OriginalL'auteur