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()

 

转载于:https://www.cnblogs.com/osxchen/p/4974839.html