func doubler(i: Int) -> Int {
return i * 2
}
func test5() {
let res = [1, 2, 3, 4].map(doubler)
print(res)
}
例如2: 使用闭包表达式
// 使用闭包表达式
func test6() {
let doubleAlt = {(i: Int) -> Int in
return i * 2
}
let res = [1, 2, 3, 4].map(doubleAlt)
print(res)
let res1 = [1, 2, 3].map{ $0 * 2}
// MARK: 笔记3
// 简化之路:
let res2 = [1, 2, 3].map( { (i: Int) -> Int in return i * 2 } ) //最原始写法
let res3 = [1, 2, 3].map( { i in return i * 2 } ) // 根据数组自动推导参数类型为Int
let res4 = [1, 2, 3].map( {i in i * 2 } ) // 只包含单一表达式,可以省略return
let res5 = [1, 2, 3].map( {$0 * 2 } ) // swift自动为函数的参数提供简写形式,$0表示第一个参数,$1表示第二个参数,以此类推
let res6 = [1, 2, 3].map() { $0 * 2 } // 函数的最后一个参数是闭包表达式,可以将闭包表达式移到函数调用的圆括号的外部
let res7 = [1, 2, 3].map { $0 * 2 } // 如果一个函数除了闭包表达式没有别的参数,那么方法名后面的调用时的圆括号也可以省略
print(res1,res2,res3,res4,res5,res6,res7)
}
例如3:使用闭包避免for循环
func test7() {
var arr = [UInt32]()
for _ in 0..<3 {
let res = arc4random()
arr.append(res)
print(res)
}
print(arr)
let res = (0..<3).map{ _ in arc4random() }
print(res)
}
例如4:闭包的类型推导
func test8() {
let isEven = { $0 % 2 == 0 } // 这里isEven被推断为: Int -> Bool
// ExpressibleByIntegerLiteral
// 指定其他返回类型的几种方式
let isEvenAlt = { (i: Int8) -> Bool in i % 2 == 0 }
let isEvenAlt2: (Int8) -> Bool = { $0 % 2 == 0 }
let isEvenAlt3 = { $0 % 2 == 0 } as (Int8) -> Bool
let a: NSInteger = 3
// a.NSIntegerisEven
// 4.isEven
let res = isEvenV(i: 3)
print(res)
}
例如5: 定义一个顶层函数
// 定义一个顶层函数
func isEvenV<T: FixedWidthInteger>(i: T) -> Bool {
return i % 2 == 0
}
// 如果想要把这个顶层函数赋值给变量,那么需要决定它的具体类型.
// 因为变量不能持有泛型函数
func test9() {
let int8isEven: (Int8) -> Bool = isEvenV
let a: Int8 = 3
let res = int8isEven(3)
print(res)
}
// 也可以写个扩展
/*
extension Int {
var isEven: Bool {
return self % 2 == 0
}
}
extension NSInteger {
var NSIntegerisEven: Bool {
return self % 2 == 0
}
}
*/