ios深度解析之Swift(函数)

// 函数
// 语法格式
//func name (参数列表) -> 返回值 {
//    // 函数实现体
//}

// .无参, 无返回值
func hello1() {
    print("hello1");
}

func hello2() -> Void {
    print("hello2")
}
// 函数调用
hello1()

// .有参
// 1,关于内部参数名
// 只在函数作用域内部使用的参数名
func hello3 (name: String , name2: String) {
    print("你好\(name) and \(name2)")
}
// 除了第一个参数 后面的参数在调用的时候会自动生成一个与外部参数名相同的外部参数名
// 原则上 第一个参数的外部参数名应该写在函数名的末尾
hello3("小林林", name2: "猪八戒")


func hello4 (mingzi1 name: String, mingzi2 name2: String) {
    print("你好\(name) and \(name2)")
}
// 内部参数名的添加规则 在外部参数名前面声明中间用空格隔开
hello4(mingzi1: "小林林", mingzi2: "猪八戒")

// 使用占位符 _ 省略掉自动生成的外部参数名
func hello5 (name: String,_ name2: String) {
    print("你好 \(name) and \(name2)")
}

hello5("小林林",  "猪八戒")

// 可以为参数赋初始值 调用时传参则更改 不传参使用初始值
func hello6 (name: String = "张三", name2: String = "李四") {
    print("你好 \(name) and \(name2)")

}
//hello6()
hello6(name2:"王五")

// 有返回值情况
// 返回值直接给类型
func hi1() ->String {
    return "hehehheheh"
}
hi1()


// 输出元音和辅音个数
func count (tempStr: String) -> (Int , Int) {

    var number1:Int = 0
    var number2:Int = 0
    
    for num in tempStr.characters {
        switch num {
            case "a", "e", "i", "o", "u":
            number1++
            
        default:
            number2++
            
        }
    }
    return (number1, number2)
}
count("gerageargshshsshsthjstjhshshnaiou")

// 不确定参数个数. 参数个数可变
func count2 (numbers:Int...) ->Int {
    var sum = 0
    // 不确定个数的参数, 作为数组使用
    for num in numbers {
        sum += num
    }
    return sum
}
count2(1,2,3,4,5,6)


// 参数在函数体内 默认是不可变的,用var修饰之后才可变
func count3 (var a:Int, b:Int) -> Int {
//    a += b
    a++
//   b++
    return a
}

var c = 10
count3(c , b: 0)

// inout 修饰参数 将外部变量的地址传进来 从而改变外部变量的值
func changeValue (inout a:Int) {
    a++
}
changeValue(&c)
c

//声明一个函数 实现功能 传入 "+", "-", "/".的字符串 返回对应运算的函数 : "+" --- 返回 Int + Int = Int
// 函数的返回值是函数 可以用函数嵌套的形式实现 但并不是必须使用函数嵌套

// 方法一
func hello3(i:String)-> ((Int, Int) -> Int) {
    
    func sum(a:Int, b:Int) -> Int {
        
        switch i {
            case "+":
            return a + b
            case "-":
            return a - b
            case "/":
            return a / b
            case "*":
            return a * b
        default:
            return 0
        }
        
    }
     return sum
    
    
}

let hanshu1 = hello3("+")
hanshu1(1, 2)

let hanshu2 = hello3("-")
hanshu2(1, 2)
let hanshu3 = hello3("*")
hanshu3(1, 2)
let hanshu4 = hello3("/")
hanshu4(4, 2)

let hanshu5 = hello3("+")
let result = hanshu5(1, 2)




// 方法二
    func sum1(a:Int, b:Int) -> Int {
        return a - b
    }
    func sum2(a:Int, b:Int) -> Int {
        return a + b
    }
    func sum3(a:Int, b:Int) -> Int {
        return a * b
    }
    func sum4(a:Int, b:Int) -> Int {
        return a / b
    }

    func hello3(i:String)-> ((Int, Int) -> Int)? {
        switch i {
        case "+":
            return sum2
        case "-":
            return sum1
        case "/":
            return sum3
        case "*":
            return sum4
        default:
            return nil
        }
        
}

let han = hello3("+")
let result = han!(1, 2)

// 指定类型别名
typealias funcType = ((Int, Int) ->Int)
typealias funcType2 = String
func func3 () ->funcType {

    func hanshu3(num1: Int, num2: Int) -> Int {
        return 0
    }
    return hanshu3
}

// ++++++++++++++++++++++++ 闭包: 相当于block
// 闭包 又叫做 匿名函数
//{
//
//    (参数列表) -> 返回值 in 函数的实现体
//}


// 使用系统排序函数对闭包的省略机制进行说明
var numbers = [11, 44, 33, 66, 22]
var numbers_result = numbers.sort({

    (n1:Int, n2:Int)-> Bool in
    return n1 > n2

})
// 闭包的参数类型可以省略
// 根据上下文进行类型推断
var numbers_result1 = numbers.sort({

    (n1, n2)-> Bool in
    return n1 > n2
})

// in 前面的语句 可以省略
// 此时 没有参数名 自动生成$0, $1 进行替代
var numbers_result2 = numbers.sort({
    
    return $0 > $1 // 此处 return也可以省略
})
// return 也可以省略 条件是:函数实现体内只有return语句
var numbers_result3 = numbers.sort({
    
     $0 > $1 // 此处 return也可以省略
})

// 极简模式
var numbers_result4 = numbers.sort(>)
// +++++++++++以上是闭包的省略机制


// 尾随闭包
// 当闭包作为参数列表的最后一个参数时 并且内容相对复杂 可以尾随在参数列表的外面
var numbers_result5 = numbers.sort(){
    
    (n1, n2)-> Bool in
    return n1 > n2
    
}

typealias myType = ((String) -> String)

func getPigName(name:String)-> String {
    return "pig = \(name)"
}

func pig(canshu:myType)->myType {
    
    return getPigName
}
pig({

    (name:String)-> String in
    
    return "pig = \(name)"
})
// 闭包常用于参数 函数常用于返回值

// "3" + "4" = "7"
// "3" + "4" = 7
typealias myType2 = ((String, String) -> Int)

func closure (clo:myType2) ->String {

    let result_clo = clo("3" , "4")
    
    return result_clo.description // 转成字符串
    
}

closure({

    (a:String, b:String)-> Int in
    return Int(a)! + Int(b)!
    
})