Swift语言的函数和闭包
//定义int属性
let a: Int = 4
//定义函数
func xx() {
}
func add(a: Int,b: Int) ->Int {
return a+b
}
func multi(a: Int,b: Int) -> Int {
return a * b
}
//函数属性的定义语法 (Int,Int) -> Int (参数,参数,...)->返回值类型
var f: (Int,Int) -> Int = add
f(12,23)
f = multi
f(12,23)
let f2: (Int,Int) -> Int = multi
f2(1,4)
//在Swift语言里,函数是一等公民
//普通例子
func processArray() ->[Int] {
let array = [1,4,7,5,8,2,4]
var result: [Int] = []
for item in array {
if item % 2 == 0 {
result.append(item)
}
}
return result
}
processArray()
//带有函数属性的例子
func processArray2(suanfa: (Int) ->Bool) -> [Int] {
let array = [1,3,4,5,2,8]
var result: [Int] = []
for item in array {
if suanfa(item) {
result.append(item)
}
}
return result
}
func suanfa(a: Int) ->Bool {
return a % 2 == 0
}
func suanfa2(a: Int) -> Bool {
return a * 2 == 4
}
processArray2(suanfa)
processArray2(suanfa2)
//闭包的表达式(表达式)
/*
闭包的表达式语法:
{
(参数,参数,...) -> 返回类型 in
//
//
//...
}
*/
//拿上面的带函数参数的例子来看效果
let result = processArray2({
(a: Int) -> Bool in
return a % 2 == 0
})
result
let array = [1,3,5,7,9]
func compare(a: Int,b: Int) ->Bool {
return a > b
}
//array.sort(compare)
//array.sort()
//**闭包的精简语法**
//传闭包表达式,不需要额外定义函数
let result2 = array.sort({
(a: Int,b: Int) -> Bool in return a < b
})
result2
//参数类型与返回值类型的推断
let result3 = array.sort({
(a,b) in return a < b
})
result3
//单行代码自动返回此代码的结果
let result4 = array.sort({
(a,b) in a < b
})
result4
//自动提供剪短的参数名 $0,$1,$2...
let result5 = array.sort({$0 < $1})
result5
//如果一个函数(sort),它只有一个参数,此参数的类型是函数类型,那么可以把大括号中得内容放到小括号外面
let result6 = array.sort(){$0 < $1}
result6
//或者是可以省略括号的
let result7 = array.sort{$0 < $1}
result7
//闭包(闭包 closure)
func funcFactory() ->() -> Int { //这里是指返回值是一个函数类型,没有参数的int函数类型
var total = 0
func innerFunc() -> Int {
total = total + 1
return total
}
return innerFunc
}
let r1 = funcFactory()
r1()
r1()
var r2 = funcFactory()
r2()
r2()
let r3 = r2
r3() //通过代码可部分看出r3是引用类型
/*
闭包可以理解通过下面的类实例化出来的一个对象 : 例子1
1.闭包hi一个对象,是个引用类型
2.闭包是一个函数类型的对象
*/
//例子1:
class InnerFunct {
func Inner() {
}
var total = 0
}
let i = InnerFunct()
i.total
//****自动闭包******
//定义例子1与例子2 形成对比,主要是例子2
func autoClosutrDemo(x: () -> String) {
// let rusult = x() 报错
// print(result)
}
autoClosutrDemo({"chenhe"})
func autoClosureDemo2(@autoclosure x: () -> String) {
let result = x()
print(result)
}
autoClosureDemo2("陈鹤")
//闭包的另一种用法,可以直接给函数类型赋值
let le: () -> String = {"陈璇"}
le()
class XX {
var i = 5
lazy var close: () -> Void = {
print(self.i)
//闭包要用到类里面的实例成员,必须要加self或者 额外声明变量(此内容在内存管理时阐述)
}
}
XX().close()