Swift3.0- 函数和闭包

函数的几种类型

1.无参无返

func great() -> Void {
            
        }
        func great() {
            
        }

2.有参无返

 func includeParameterNoneReturnValue(person: String, day : String) {
            
            print("Hello \(person), today is \(day)")
        }
        
        includeParameterNoneReturnValue(person: "Judy",day: "23")

2.1 省略外部参数名

        
        func omitOutParameter(_ person : String, _ day : String) -> String {
            
            return "Hello \(person), today is \(day)."
            
        }
        
        print(omitOutParameter("流川枫", "8"))

3.有参有返

        func includeParameterAndReturnValue (_ person : String, _ day : String) -> String {
            return "Houston player \(person) join at \(day)"
        }
        
        print(includeParameterAndReturnValue("周琦", "9"))

4.无参有返

func NoneParameterReturnValue () -> String {
            return "I hate bitch!"
        }

参数和返回值

1.参数可以是那些？

基本类型的值,对象,数组,字典,元组,可变数量的参数,函数,闭包函数,协议,结构体,枚举值

2.怎么定义参数

//a.单值
        
        func calculate(a:Int) {
            let b = a
        }
        
        //b. 多值
        func calculates(a: Int...) {
            for _ in a {
                
            }
        }
        
        //c. 元祖
        func calculatess(a:(name:String, age:Int)){
            let name = a.name
            let age = a.age
        }
        
        //d. 数组
        func calculate_s(a:[String]){
            
            for student in a {
                
            }
        }
        
        //e. 字典
        
        func calculate_d (a:[String:Int]){
            
            for student in a {
                print(student.key)
                print(student.value)
            }
            
        }
        
        //f. 函数作为参数
        
        func add(a:Int,b:Int) -> Int {//作为函数参数的函数
            return a + b
        }
        
        func calculate_fa(asd:(Int,Int) -> Int) {//定义的参数为函数的函数
           print( asd(3,5))
        }
        
        calculate_fa(asd: add(a:b:))
        
        //g. 闭包写法
        
        calculate_fa { (a, b) -> Int in
            
            return a + b
        }
        
        calculate_fa{ (a, b) in a + b }//省略写法（由于swift有推断能力，这样写就能够帮你推断出上面的写法）

        //h. 参数为协议的方法
//        protocol Player{  // 定义协议
//            func play()
//        }
//        
//        func playMusicWithPlayer(player:Player){
//            player.play()
//        }
        
        //i. 参数为结构体
        
//        struct Student{
//            var name:String
//            var age:Int
//        };
//        
//        func getStudentDescription(student:Student){
//            print(student.name)
//            print(student.age)
//        }
        
        //j.  参数为枚举类型
        
        // 定义枚举值
        enum CarType:String{
            case Lincoln = "林肯"
            case MERCURY = "水星"
            case SUZUKI = "铃木"
        }
        // 参数为协议的方法
        func describeCar(carType:CarType){
            print(carType.rawValue);
        }

函数内部定义函数

        func getValueByFlag(flag:Bool) -> (Int, Int) -> Int {
            
            func add_f(a:Int, b:Int) -> Int {
                return a + b
            }
            
            func descrase(a:Int,b:Int) -> Int {
                return a - b
            }
            
            if flag {
                return add
            } else {
                return descrase
            }
        }
        
        let addFunc = getValueByFlag(flag: false)
        
        print(addFunc(2,4))

设置默认参数值

        func addStudent(student:(name:String, nunbers:Double)=("姓名",23554411)){
            print(student.name)
            print(student.nunbers)
        }
        
        addStudent()
        addStudent(student: ("元昊",111307302))

inout的使用

需求: 创建一个函数,交换两个Int类型值

a.如果参数为let修饰的常量

func swapTwoInts( a:  Int, b: Int){
let temporaryA = a
a = b
b = temporaryA
}

报错:系统提示错误,说常量不能修改值

b.我们将参数变成变量var

func swapTwoInts( var a:  Int, var b: Int){
let temporaryA = a
a = b
b = temporaryA
}

报错,不能使用var 修饰参数

c.inout 修饰的参数可以修改值

func swapTwoInts(  a: inout Int, b:inout Int){
    let temporaryA = a
    a = b
    b = temporaryA
}
var a = 30
var b = 40
swapTwoInts(a: &a, b: &b)
print(a)
print(b)


40
30

Warning:

1.inout的位置 在: 后面,数据类型前面
2.inout 修饰的参数不能有默认值
3.inout 不能用于修饰多值(如a:Int...)

others:函数类型的变量不能用标签修饰参数

// 错误的写法  不能使用a,b标签
var swap1:( a :inout Int, b: inout Int)->Void = swapTwoInts
// 你应该像下面这样
var swap1:( _ :inout Int, _: inout Int)->Void = swapTwoInts
// 或者下面这样也可以,a,b 不一定要和实际函数对应
var swap1:( _ a:inout Int, _ b: inout Int)->Void = swapTwoInts
// 建议还是用下面这种
var swap1:( inout Int, inout Int)->Void = swapTwoInts

定义闭包类型数据

        var customersInLine = ["Chirs","Alex","Ewa"]
        let customerprovider = { customersInLine.remove(at: 0)}
        print(customersInLine.count)
        print("Now Serving \(customerprovider())!")
        print(customersInLine.count)

提示:上面那种闭包其实是无参有返的闭包形式,原形如下

let customerProvider:()->String= { customersInLine.remove(at: 0)}