[Swift] map, flatMap, compactMap ?

Map, flatMap, compactMap

map

• 배열 내부의 값을 하나씩 mapping
• 각 요소에 대한 값을 변경하고자 할 때 사용하고, 그 결과들을 배열의 상태로 반환

func map<T>(_ transform: (String) throws -> T) rethrows -> [T]

import Foundation

let cast = ["Vivien", "Marlon", "Kim", "Karl"]
let lowercaseNames = cast.map { $0.lowercased() }
print(lowercaseNames) // ["vivien", "marlon", "kim", "karl"]

let letterCounts = cast.map{ $0.count }
print(letterCounts) // [6, 6, 3, 4]

 

flatMap

• 배열을 flatten하게 만들어줌
• nil을 제거함
• 옵셔널 바인딩

func flatMap<SegementOfResult>(_ transform: ([Int]) throws -> SegementOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult: Sequence

import Foundation

let numbers = [1,2,3,4]

let mapped = numbers.map { Array(repeating: $0, count: $0)}
print(mapped) // [[1], [2,2], [3,3,3], [4,4,4,4]]

// # flatten #
let flatMapped = numbers.flatMap { Array(repeating: $0, count: $0)}
print(flatMapped) // [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]

---------------------------------------------------------------------------
// # nil 제거 #
let numbers = [1,2,nil,3,4]

let flatMapped = numbers.flatMap { $0 } 
print(flatMapped) // [1, 2, 3, 4]

flatMap을 이용해서 optional binding을 할 수 있지만,

compactMap을 사용하는 것을 추천한다고 한다.

 

https://sudonull.com/post/14814-Swift-41-why-Apple-renamed-flatMap-to-compactMap

위 링크에서는 flatmap 사용 시 map과 동일하게 사용되는 것을 방지하기 위해서라고 한다.

let possibleNumbers = ["1", "2", "three", "///4///", "5"]

let mapped: [Int?] = possibleNumbers.map { str in Int(str) }
print(mapped) // [Optional(1), Optional(2), nil, nil, Optional(5)]

// # Optional Binding #
let flatMapped: [Int] = possibleNumbers.flatMap { str in Int(str) }
print(flatMapped)  // [1, 2, 5]

-------> 해당 케이스(옵셔널 바인딩)에서는 compactMap 사용 권장 

 

 

compactMap

• nil을 제거함
• 옵셔널 바인딩

func compactMap<ElementOfResult>(_ transform: (Int?) throws -> ElementOfResult?) rethrows -> [ElementOfResult]

import Foundation

let numbers = [1,2,nil,3,4]

let compactMapped = numbers.compactMap { $0 }
print(compactMapped) // [1, 2, 3, 4]

---------------------------------------------------------------------------

// # Optional Binding #
let possibleNumbers = ["1", "2", "three", "///4///", "5"]

let mapped: [Int?] = possibleNumbers.map { str in Int(str) }
print(mapped) // [Optional(1), Optional(2), nil, nil, Optional(5)]

let compactMapped: [Int] = possibleNumbers.compactMap { str in Int(str) }
print(compactMapped) // [1, 2, 5]

---------------------------------------------------------------------------

 

flatMap vs compactMap

let arr: [[Int?]] = [[1, 2, 3], [nil, 5], [6, nil], [nil, nil]]
let flatMapped = arr.flatMap { $0 }
// [Optional(1), Optional(2), Optional(3), nil, Optional(5), Optional(6), nil, nil, nil]
let flatMappedAndflatMapped = arr.flatMap { $0 }.flatMap { $0 }
// [1, 2, 3, 5, 6]
let flatMappedAndcompactMapped = arr.flatMap { $0 }.compactMap { $0 } // flat 후 optional binding
// [1, 2, 3, 5, 6]

---------------------------------------------------------------------------

let compactMapped = arr.compactMap { $0 }
// [[Optional(1), Optional(2), Optional(3)], [nil, Optional(5)], [Optional(6), nil], [nil, nil]]
let compactMappedAndflatMapped = arr.compactMap { $0 }.flatMap { $0 }
// [Optional(1), Optional(2), Optional(3), nil, Optional(5), Optional(6), nil, nil, nil]
let compactMappedAndcompactMapped = arr.compactMap { $0 }.compactMap { $0 }
// [[Optional(1), Optional(2), Optional(3)], [nil, Optional(5)], [Optional(6), nil], [nil, nil]]