Ánh xạ mảng đối tượng vào Từ điển trong Swift

Tôi có một mảng các Personđối tượng của:

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

và mảng là:

let myArray = [p1,p1,p3]

Tôi muốn bản đồ myArraytrở thành một Từ điển của [position:name]giải pháp cổ điển là:

var myDictionary =  [Int:String]()

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

Swift có cách nào thanh lịch để làm điều đó với cách tiếp cận chức năng không map, flatMap... hoặc phong cách Swift hiện đại khác

Okay mapkhông phải là một ví dụ điển hình về điều này, vì nó giống như phép lặp, reducethay vào đó bạn có thể sử dụng , mỗi đối tượng của bạn phải kết hợp và biến thành một giá trị duy nhất:

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

Trong Swift 4 hoặc cao hơn, vui lòng sử dụng câu trả lời bên dưới để biết cú pháp rõ ràng hơn.

Vì Swift 4bạn có thể thực hiện cách tiếp cận của @ Tj3n một cách rõ ràng và hiệu quả hơn bằng cách sử dụng intophiên bản reduceNó loại bỏ từ điển tạm thời và giá trị trả về, vì vậy nó nhanh hơn và dễ đọc hơn.

Thiết lập mã mẫu:

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

Into tham số được truyền từ điển trống của loại kết quả:

let myDict = myArray.reduce(into: [Int: String]()) {
    $0[$1.position] = $1.name
}

Trực tiếp trả về một từ điển thuộc loại được truyền vào into:

print(myDict) // [2: "c", 0: "h", 4: "b"]

Kể từ Swift 4, bạn có thể làm điều này rất dễ dàng. Có hai trình khởi tạo mới xây dựng từ điển từ một chuỗi các bộ giá trị (cặp khóa và giá trị). Nếu các khóa được đảm bảo là duy nhất, bạn có thể làm như sau:

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

Điều này sẽ không thành công với lỗi thời gian chạy nếu bất kỳ khóa nào bị trùng lặp. Trong trường hợp đó, bạn có thể sử dụng phiên bản này:

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

Điều này hoạt động như vòng lặp for của bạn. Nếu bạn không muốn "ghi đè" các giá trị và dính vào ánh xạ đầu tiên, bạn có thể sử dụng điều này:

Dictionary(persons.map { ($0.position, $0.name) }) { first, _ in first }

=> [1: "Franz", 2: "Heinz"]

Swift 4.2 thêm trình khởi tạo thứ ba để nhóm các phần tử trình tự vào một từ điển. Các khóa từ điển được tạo ra bởi một bao đóng. Các phần tử có cùng khóa được đưa vào một mảng theo thứ tự như trong dãy. Điều này cho phép bạn đạt được kết quả tương tự như trên. Ví dụ:

Dictionary(grouping: persons, by: { $0.position }).mapValues { $0.last! }

=> [1: Person(name: "Hans", position: 1), 2: Person(name: "Heinz", position: 2)]

Dictionary(grouping: persons, by: { $0.position }).mapValues { $0.first! }

=> [1: Person(name: "Franz", position: 1), 2: Person(name: "Heinz", position: 2)]

Bạn có thể viết bộ khởi tạo tùy chỉnh cho Dictionaryloại, ví dụ từ các bộ giá trị:

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

và sau đó sử dụng mapcho mảng Person:

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

Làm thế nào về một giải pháp dựa trên KeyPath?

extension Array {

    func dictionary<Key, Value>(withKey key: KeyPath<Element, Key>, value: KeyPath<Element, Value>) -> [Key: Value] {
        return reduce(into: [:]) { dictionary, element in
            let key = element[keyPath: key]
            let value = element[keyPath: value]
            dictionary[key] = value
        }
    }
}

Đây là cách bạn sẽ sử dụng nó:

struct HTTPHeader {

    let field: String, value: String
}

let headers = [
    HTTPHeader(field: "Accept", value: "application/json"),
    HTTPHeader(field: "User-Agent", value: "Safari"),
]

let allHTTPHeaderFields = headers.dictionary(withKey: \.field, value: \.value)

// allHTTPHeaderFields == ["Accept": "application/json", "User-Agent": "Safari"]

Bạn có thể sử dụng một hàm giảm. Đầu tiên, tôi đã tạo một trình khởi tạo được chỉ định cho lớp Person

class Person {
  var name:String
  var position:Int

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

Sau đó, tôi đã khởi tạo Mảng giá trị

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

Và cuối cùng, biến từ điển có kết quả:

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

Đây là những gì tôi đã được sử dụng

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}

Sẽ rất tốt nếu có một cách để kết hợp 2 dòng cuối cùng để peopleByPositioncó thể thành a let.

Chúng tôi có thể tạo một phần mở rộng cho Array để thực hiện điều đó!

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

Sau đó, chúng ta chỉ có thể làm

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

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

Có lẽ một cái gì đó như thế này?

myArray.forEach({ myDictionary[$0.position] = $0.name })