Mapper un tableau d'objets au Dictionnaire dans Swift

J'ai un tableau de Person'objets:

class Person {
   let name:String
   let position:Int
}

et le tableau est:

let myArray = [p1,p1,p3]

Je veux la carte myArray être un Dictionnaire de [position:name] la solution classique est:

var myDictionary =  [Int:String]()

for person in myArray {
    myDictionary[person.position] = person.name
}

est-il de toute manière élégante par Swift à le faire avec l'approche fonctionnelle mapflatMap... ou d'autres modernes Swift style

source d'informationauteur iOSGeek

Bon map n'est pas un bon exemple, parce que sa vient de même que la boucle, vous pouvez utiliser reduce au lieu de cela, il a fallu à chacun de vos objets à combiner et de les transformer en valeur unique:

let myDictionary = myArray.reduce([Int: String]()) { (dict, person) -> [Int: String] in
    var dict = dict
    dict[person.position] = person.name
    return dict
}

//[2: "b", 3: "c", 1: "a"]

Dans Swift 4 vous pouvez le faire @Tj3n approche plus proprement et efficacement à l'aide de la into version de reduce Il se débarrasse de la temporaire de dictionnaire et de la valeur de retour de sorte qu'il est plus rapide et plus facile à lire.

struct Person { 
    let name: String
    let position: Int
}
let myArray = [Person(name:"h", position: 0), Person(name:"b", position:4), Person(name:"c", position:2)]
let myDict = myArray.reduce(into: [Int: String]()) {
    $0[$1.position] = $1.name
}
print(myDict)

Note: Ne fonctionne pas dans Swift 3.

Vous pouvez écrire personnalisé initialiseur pour Dictionary type, par exemple à partir des n-uplets:

extension Dictionary {
    public init(keyValuePairs: [(Key, Value)]) {
        self.init()
        for pair in keyValuePairs {
            self[pair.0] = pair.1
        }
    }
}

et ensuite utiliser map pour votre tableau de Person:

var myDictionary = Dictionary(keyValuePairs: myArray.map{($0.position, $0.name)})

3

Depuis Swift 4 vous pouvez le faire très facilement. Il y a deux nouveau initialiseurs que construire un dictionnaire à partir d'une séquence de n-uplets (paires de clés et de valeurs). Si les clés sont uniques, vous pouvez effectuer les opérations suivantes:
```
let persons = [Person(name: "Franz", position: 1),
               Person(name: "Heinz", position: 2),
               Person(name: "Hans", position: 3)]

Dictionary(uniqueKeysWithValues: persons.map { ($0.position, $0.name) })
```
=> [1: "Franz", 2: "Heinz", 3: "Hans"]

Cela échouera avec une erreur d'exécution si une touche est dupliqué. Dans ce cas, vous pouvez utiliser cette version:
```
let persons = [Person(name: "Franz", position: 1),
               Person(name: "Heinz", position: 2),
               Person(name: "Hans", position: 1)]

Dictionary(persons.map { ($0.position, $0.name) }) { _, last in last }
```
=> [1: "Hans", 2: "Heinz"]

Il se comporte comme votre boucle for. Si vous ne voulez pas "écraser" les valeurs et le bâton à la première cartographie, vous pouvez utiliser ceci:
```
Dictionary(persons.map { ($0.position, $0.name) }) { first, _ in first }
```
=> [1: "Franz", 2: "Heinz"]

Swift 4.2 ajoute un troisième initialiseur qui prend les éléments de la séquence comme dictionnaire des valeurs. Les clés de dictionnaire sont dérivées à partir des valeurs avec une fermeture. Par exemple:
```
let persons = [Person(name: "Franz", position: 1),
               Person(name: "Heinz", position: 2),
               Person(name: "Hans", position: 3)]

Dictionary(grouping: persons, by: { $0.position })
```
=> [1: Person(name: "Franz", position: 1), 2: Person(name: "Heinz", position: 2), 3: Person(name: "Hans", position: 3)]

Vous pouvez utiliser une fonction de réduction. Tout d'abord j'ai créé un désigné d'initialiseur de la classe Personne

class Person {
  var name:String
  var position:Int

  init(_ n: String,_ p: Int) {
    name = n
    position = p
  }
}

Plus tard, j'ai initialisé un Tableau de valeurs

let myArray = [Person("Bill",1), 
               Person("Steve", 2), 
               Person("Woz", 3)]

Et enfin, le dictionnaire de la variable a le résultat:

let dictionary = myArray.reduce([Int: Person]()){
  (total, person) in
  var totalMutable = total
  totalMutable.updateValue(person, forKey: total.count)
  return totalMutable
}

C'est ce que j'ai été en utilisant

struct Person {
    let name:String
    let position:Int
}
let persons = [Person(name: "Franz", position: 1),
               Person(name: "Heinz", position: 2),
               Person(name: "Hans", position: 3)]

var peopleByPosition = [Int: Person]()
persons.forEach{peopleByPosition[$0.position] = $0}

Serait bien si il y avait un moyen de combiner les 2 dernières lignes de sorte que peopleByPosition pourrait être un let.

Nous pourrions faire une extension de Tableau qui n'a que!

extension Array {
    func mapToDict<T>(by block: (Element) -> T ) -> [T: Element] where T: Hashable {
        var map = [T: Element]()
        self.forEach{ map[block($0)] = $0 }
        return map
    }
}

Alors nous pouvons simplement faire

let peopleByPosition = persons.mapToDict(by: {$0.position})

Vous devez vous connecter pour publier un commentaire.