sort

有一个数组

let Arr = [13, 45, 27, 80, 22, 53]

// 使用sort进行排序,不省略任何类型
let sortOneArr = Arr.sorted { (a: Int, b: Int) -> Bool in
    return a < b
}

// 编译器可以自动推断出返回类型,所以可以省略

let sortTwoArr = Arr.sorted { (a: Int, b: Int) in
    return a < b
}

// 编译器可以自动推断出参数类型

let sortThreeArr = Arr.sorted { (a, b) in
    return a < b
}

// 编译器可以自动推断出参数个数,所以可以用1替代

let sortFourArr = Arr.sorted {
    return $0 < $1
}

// 如果闭包中的函数体只有一行,且需要有返回值,return可以省略

let sortFiveArr = Arr.sorted {
    $0 < $1
}

// 最简化: 可以直接传入函数<

let sortSixArr = Arr.sorted(by: <)

map

// 每个元素的平方

let mapArr = Arr.map { $0 * $0 }

compactMap

/// Returns an array containing the non-nil results of calling the given
/// transformation with each element of this sequence.

let optionalArr = [nil, 4, 12, 7, Optional(3), 9]
let compactMapArr = optionalArr.compactMap { $0 }

///

   let possibleNumbers = ["1", "2", "three", "///4///", "5"]
   let mapped: [Int?] = possibleNumbers.map { str in Int(str) }
   // [1, 2, nil, nil, 5]
   let compactMapped: [Int] = possibleNumbers.compactMap { str in Int(str) }
    // [1, 2, 5]

filter

// 过滤偶数

let evenArr = Arr.filter { $0 % 2 == 0 }

reduce

所有字符相连或者相加

let stringArr = ["1", "2", "3", "*", "a"]
let allStr = stringArr.reduce("") { $0 + $1 }
//// 123*a

let sum = intArr.reduce(0) { $0 + $1 }
// 240
let sum2 = intArr.reduce(0, +)

高阶函数连掉

// 对数组进行偶数过滤、之后进行所有元素秋平方、之后加和

let chainArr = [4, 3, 5, 8, 6, 2, 4, 7]

let resultArr = chainArr.filter {
                            $0 % 2 == 0
                        }.map {
                            $0 * $0
                        }.reduce(0) {
                            $0 + $1
                        }
// 136