swif 函数 闭包 基本使用

拷贝到工程中 系统学习 直接上代码

import Foundation

//print("Hello, World!")

//1.函数

//定义： func 函数名（形参列表）-> 返回值类型 {}

func max1(x:Int,y:Int)->Int{
    
    return x+y
}
let z = max1(x:10,y:20)
print(z)

//返回空值得3种形式  省略“-> 返回值类型”  “->()” "->Void"

func foo() {
    
}
func foo1()->() {
    
}
func foo2()->Void {
    
}

//返回元组

func divide(num:Double) -> (String,String) {
    
    return (String(num) ,String())
}

//函数的形参

// 外部形参名 局部形参名 ： 形参类型

func funcDemo1(arg1 a:Int,arg2 b:Int){
    print(a+b)
}

func funcDemo2(a:Int,b:Int){
    print(a+b)
}

func funcDemo3(_ a:Int,arg2 b:Int){
    print(a+b)
}

funcDemo1(arg1: 2, arg2: 3)
funcDemo2(a: 5, b: 2)
funcDemo3(2, arg2: 3)

//个数可变的形参

func add(a:Int, b:Int ,others:Int ...) -> Int {
    var result = a + b
    for num in others {
        result += num
    }
    return result
}

let number = add(a:2, b:5, others: 2, 50, 4,5,6)
print(number)

//函数类型作为返回类型
func stepForward(input: Int) -> Int {
    return input + 1
}
func stepBackward(input: Int) -> Int {
    return input - 1
}

func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    return backwards ? stepBackward: stepForward
}

var currentValue = 3
let moveNearerToZero = chooseStepFunction(backwards: currentValue > 0)
print(moveNearerToZero(6))

//输入输出形式参数

//在形式参数定义开始的时候在前边添加一个 inout关键字可以定义一个输入输出形式参数。输入输出形式参数有一个能输入给函数的值，函数能对其进行修改，还能输出到函数外边替换原来的值
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")

//2.闭包

// 闭包表达式 { 参数列表 -> 返回值 in  闭包代码 }

let names = ["Chris","Alex","Ewa","Barry","Daniella"]

func backward(_ s1: String, _ s2: String) -> Bool {

    return s1 > s2

}

//var reversedNames = names.sorted(by: backward)
//print(reversedNames)

//初始版本
//var reversedNames=names.sorted(by:{(s1:String,s2:String)->Bool in return s1>s2})
//print(reversedNames)

//从上下文推断类型   由于sort(by:)函数需要一个(String,String)->Bool类型的参数，意味闭包的参数类型和返回值可以被推断出来，可以省略
//var reversedNames=names.sorted(by:{s1,s2 in return s1>s2});
//print(reversedNames)

//单语句闭包省略return关键字
//var reversedNames=names.sorted(by:{s1,s2 in  s1>s2});

//简写实际参数名  自动对行内闭包提供简写实际参数名，你也可以通过$0,$1,$2等名字来引用闭包的实际参数值。而不用使用像s1,s2这样的自定义形式参数名
//var reversedNames=names.sorted(by:{$0>$1})


//使用尾随闭包写闭包表达式  如果你需要将一个很长的闭包表达式作为函数最后一个实际参数传递给函数，使用尾随闭包将增强函数的可读性。尾随闭包是一个被书写在函数形式参数的括号外面（后面）的闭包表达式

//定义一个接受函数类型作为参数的函数
func someFunctionThatTakesAClosure(closure:() -> Void){
    //函数体
}


//不使用尾随闭包的闭包表达式写法

someFunctionThatTakesAClosure(closure: {
    //闭包的表达式写在这里，注意两种方法的大小括号位置
})

//使用尾随闭包的闭包表达式的写法

someFunctionThatTakesAClosure() {
    // 尾随闭包的表达式写在这里
}

//之前的sort(by:)函数使用尾随闭包的写法


//var reversedNames=names.sorted(){
//    $0>$1
//}

//因为只有一个参数，所以小括号也可以省略

//var reversedNames=names.sorted{
//    $0>$1
//}

//当闭包体很长的时候，使用尾随闭包的优势就能显现出来了

//let strings = numbers.map {
//    (number) -> String in
//    var number = number
//    var output = ""
//    repeat {
//        output = digitNames[number % 10]! + output
//        number /= 10
//    } while number > 0
//    return output
//}

var blockA:()->Void = { print("China") }
print(blockA)
var blockB:()->Double = { return 3.14 }
print(blockB)


//var  arr:Dictionary<Int,Int> = [12:120 , 13:130 , 14:110]