swift 从零开始 函数 元祖 闭包

定义一个方法。
func greet(firstStr:String, secondStr:String) -> String {
            return "first is \(firstStr), second is \(secondStr)"
    }

参数放在方法名字后面用括号,使用->指向返回值类型。

元组
    func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
        var min = scores[0]
        var max = scores[0]
        var sum = 0
        
        for score in scores {
            if score > max {
                max = score
            } else if score < min {
                min = score
            }
            sum += score
        }
        
        return (min, max, sum)
    }

看一下这个方法,返回值有多个int类型的数。其实这些返回值是一个整体,称为元组。

元祖可以将多个值组合在一起,这些值可以是不同的类型。
然后可以类似于数组通过索引去访问,
元祖中每个数值都可以有一个他的名字,可以像OC上的对象通过点名字去获取具体的值。

let person = (name: "lnj", age: 30, score: 100.0) 
let values: (String, Int, Double) = ("lnj", 30, 99.9) 
let values = ("lnj", 30, 99.9);
let (String, Int, Double) = values 
// 通过名称访问 
person.name 
person.age 
person.score

具体的用法就是当要返回多个数值的时候,直接返回一个元祖就可以了。

元祖的特性:

1.跳过无关的值:
当元祖中的某个数值无关紧要,可以跳过。

let (name,  _, age) = yuanzu //使用下划线去忽略
let yuanzu = (name:"gyz" ,true, age:22)  //或者不给它指定变量名

使用这两个方法都不能访问中间那个数值。

2.元祖的可变和不可变
用var定义的元祖就是可变元祖,用let定义的元祖就是不可变元祖。
但是不管是可变或者不可变的元祖都不能对元祖的长度改变,即不能增加和删除某个数值。
可变和不可变的区别就是可变的元祖可以修改某个数据的值。但是不能修改这个数据的数据类型。

func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(numbers: 42, 597, 12)

函数可以接受多个参数,然后把它们存放在数组中。但是传入参数都得是同一种类型。像本例中传入的类型就全是Int类型。

func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()

函数可以内嵌,里面的函数可以访问外面函数的变量。常使用内嵌函数来解决函数里面代码过长。

  func bigFunc() -> ((Int) -> Int) {
        func littleFunc (LittleN : Int) -> Int {
            return LittleN;
        }
        return littleFunc
    }
    let myFunc =  bigFunc()
    print(myFunc(9))

函数可以作为返回值返回,返回后定义一个常量myFunc指向它,这个常量myFunc本身的类型就是函数。

    //获取数组中等于二的数值个数
    func getMax(list: [Int], condition: (Int) -> (Bool)) -> Int {
        var count = 0
        for number in list {
            if condition(number) {
                count += 1
            }
        }
        return count
    }
    func compare(number :Int) -> Bool {
        if number == 2 {
            return true
        } else {
            return false
        }
    }
let myList = [2,6,2,0,10,44,2]
print(getMax(list: myList, condition: compare))

函数可以作为参数传入某个函数中。

闭包
一般形式:{
            (parameters) -> returnType in
             statements
           }

这里的参数(parameters),可以是in-out(输入输出参数),但不能设定默认值。如果是可变参数,必须放在最后一位,不然编译器报错。元组也可以作为参数或者返回值。

"in"关键字表示闭包的参数和返回值类型定义已经完成,闭包函数体即将开始。即由in引入函数

//一般形式
let calAdd:(Int,Int)->(Int) = {
    (a:Int,b:Int) -> Int in
    return a + b
}
print(calAdd(100,150))
//Swift可以根据闭包上下文推断参数和返回值的类型,所以上面的例子可以简化如下
let calAdd2:(Int,Int)->(Int) = {
    a,b in  //也可以写成(a,b) in
    return a + b
}
print(calAdd2(150,100))

//上面省略了返回箭头和参数及返回值类型,以及参数周围的括号。当然你也可以加括号,为了好看点,看的清楚点。(a,b)

//单行表达式闭包可以隐式返回,如下,省略return
let calAdd3:(Int,Int)->(Int) = {(a,b) in a + b}
print(calAdd3(50,200))
//如果闭包没有参数,可以直接省略“in”
let calAdd4:()->Int = {return 100 + 150}
print("....\(calAdd4())")
//这个写法,我随便写的。打印出“我是250”
//这个是既没有参数也没返回值,所以把return和in都省略了
let calAdd5:()->Void = {print("我是250")}
calAdd5()

总结: let calAdd:(Int,Int)->(Int)类似于这样的写法,=后面的代码段就是表示一个闭包。整个的意思就是声明一个常量 calAdd,这个常量的类型是(Int,Int)->(Int), 也可以说 这个常量的类型是闭包类型。 类似于OC中的block

闭包可以像OC中的block一样使用typedef起别名,swift上使用的typealias

typealias MyClosePage = (Int, Int) -> Int

let a: MyClosePage =  {
            b, c in
            return b + c;
        }
        print(a(3,4));

函数和闭包都属于引用类型, 只有当一个变量指向它的时候它可以保持存在,不被释放,同事内部的变量的值也存在,可以累积计算。

例如:
定义一个函数

    func captureValue(sums:Int) -> Int{
        var total = 0
        total += 1
        return total
    }

如果单纯的调用captureValue() , 调用完成,这个方法会释放,内部的值total也会释放。
如果使用
let a = captureValue()
这样去调用,函数被引用了,只要a不被释放,方法一直存在,方法里面的total的值保留。
使用闭包,同理。

逃逸闭包
func doSomething(some: @escaping () -> Void){
    //延时操作,注意这里的单位是秒
    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1) {
        //1秒后操作
        some()
    }
    print("函数体")
}
doSomething {
    print("逃逸闭包")
}

逃逸闭包指的是闭包当做参数出入到函数中,会在函数返回之后再去执行闭包。多用于线程的异步操作,一般用于网络请求完成后成功或者失败后的回调。
逃逸闭包的标志就是 @escaping 在参数和返回值之前添加。

自动闭包

顾名思义,自动闭包是一种自动创建的闭包,封装一堆表达式在自动闭包中,然后将自动闭包作为参数传给函数。而自动闭包是不接受任何参数的,但可以返回自动闭包中表达式产生的值。

var array = ["I","have","a","apple"]
print(array.count)
//打印出"4"
 
let removeBlock = {array.remove(at: 3)}//测试了下,这里代码超过一行,返回值失效。
print(array.count)
//打印出"4"
 
print("执行代码块移除\(removeBlock())")
//打印出"执行代码块移除apple" 这里自动闭包返回了apple值
 
print(array.count)
//打印出"3"

当自动闭包调用的时候,才会去执行里面的代码。 类似于OC中的懒加载。

你可能感兴趣的:(swift 从零开始 函数 元祖 闭包)