reorder array with ids array

reorder array.md

struct Model {
    
    var id : Int
    var name : String
}

var modelArray = [
    Model(id: 0, name: "하하"),
    Model(id: 1, name: "호호"),
    Model(id: 2, name: "정대리"),
    Model(id: 3, name: "호호호"),
    Model(id: 4, name: "쩡대리"),
    Model(id: 5, name: "개발하는")
]



let idArray = [2,3,5,4,1,0]


class TestVM : ObservableObject {
    
    init(){

        
        var preSortPlayerList = [
            Model(id: 0, name: "하하"),
            Model(id: 1, name: "호호"),
            Model(id: 2, name: "정대리"),
            Model(id: 3, name: "호호호"),
            Model(id: 4, name: "쩡대리"),
            Model(id: 5, name: "개발하는")
        ]
        
        let positionOrders = [2,3,5,4,1,0]
        
        let dict = preSortPlayerList.reduce([Int : [Model]]()) {
            var map = $0
            if var tmp = map[$1.id] {
              tmp.append($1)
              map[$1.id] = tmp
            } else {
              map[$1.id] = [$1]
            }
            return map
        }

        let playersArray: [Model] = positionOrders.flatMap { dict[$0] ?? [Model]() }
        
//        let orderedList = reOrderArray(existingArray: preSortPlayerList, orderingArray: positionOrders)
        
        let orderedList = preSortPlayerList.reOrderArray(orderingArray: positionOrders, matchTo: {
            $0.id
        })
        
        
        let result = orderedList.map{ ($0.id, $0.name) }
        
        print("\(result)")
        
        
        
    }
    
    func reOrderArray(existingArray : [Model], orderingArray: [Int]) -> [Model] {
        
        // 딕셔너리로 정렬
        let dict = existingArray.reduce([Int : [Model]]()) {
            var map = $0
            if var tmp = map[$1.id] {
              tmp.append($1)
              map[$1.id] = tmp
            } else {
              map[$1.id] = [$1]
            }
            return map
        }

        // 정렬한 딕셔너리 -> 배열로 변환 납작하게
        let orderedArray: [Model] = orderingArray.flatMap { dict[$0] ?? [Model]() }
        
//        let result = playersArray.map{ $0.id }
        return orderedArray
    }

}

extension Array where Element: Any {
    
    func reOrderArray<O : Hashable>(orderingArray: [O], matchTo: (Element) -> O) -> [Element] {
        
        // 딕셔너리로 정렬
        let dict = self.reduce([O : [Element]]()) {
            var map = $0
            if var tmp = map[matchTo($1)] {
              tmp.append($1)
              map[matchTo($1)] = tmp
            } else {
              map[matchTo($1)] = [$1]
            }
            return map
        }

        // 정렬한 딕셔너리 -> 배열로 변환 납작하게
        return orderingArray.flatMap { dict[$0] ?? [Element]() }
    }
}