Swift修行之路-2

1.函数

语法：
func funcname(形参) -> returntype{
return parameters
}

    func runner(speed:String,jk:String) -> String {
        return speed + jk
    }
    func func2() -> String {
        return "无参数函数"
    }
    func func3(hh: String) -> Void {
        print("无返回值函数")
    }
    func func4(kk: String){
        print("无返回值函数")
    }
    func func5(){
        print("无参数+无返回值函数")
    }
    //返回值类型为元组，元组和数组类似，不同的是里面可以是任意类型的数据
    //关于for循环：1...arry.count :闭区间循环，从1-arry.count；1..<arry.count:开区间，从1-(arry.count-1)
    //如果不确定返回的元组一定不为nil，可以返回一个可选的元组类型：func minMax(array:[Int]) -> (min:Int,max:Int)?{}
    func minMax(array:[Int]) -> (min:Int,max:Int)?{
        if array.isEmpty {
            return nil
        }
        var currentMin = array[0];
        var currentMax = array[0];
        for value in array[1..<array.count] {
            if value < currentMin {
                currentMin = value
            }else if value > currentMax {
                currentMax = value
            }
        }
        return (currentMin,currentMax)
    }
    //外部参数名
    func pow(firstStr a : Int,secondStr b : Int)->Int{
        return a + b
    }
     //有外部参数时，调用的时候也要有外部参数
    pow(firstStr: 5, secondStr: 6)

    //可变参数函数
    func funsMu(first:Int,second:Int,others:Int...)->Int{
        var result = first + second
        for num in others{
            result += num
        }
        return result
    }
      //修改外部参数=======
        var aa = 5
        var bb = 9
        change(a: &aa, b: &bb)
        print("aa=\(aa)\n bb=\(bb)\n")//aa=9;bb=5
    //改变参数的值
    func change(a:inout Int,b:inout Int){
        let temp = a
        a = b
        b = temp
    }
     //=================
    //函数作为参数-先定义一个函数
    func sum(a:Int,b:Int) -> Int {
        return a + b
    }
    //定义一个参数是函数的函数
    func anotherFunc(funck:(Int,Int)->Int,a:Int,b:Int) -> Int {
        return funck(a,b) + a + b
    }
    //调用
    let addition: (Int,Int)->Int = sum;
    let funcResult =  anotherFunc(funck: addition, a: 2, b: 3)
    print(funcResult)

    //=================
    //函数嵌套,返回值是一个函数：()->Int，一个无参数，返回值是Int的函数
    func calcDecrement(total:Int) -> ()->Int {
        var aa = 0
        func decrement()->Int{
            aa -= total
            return aa
        }
        return decrement
    }
    //调用：
    let decrem = calcDecrement(total: 20)
    print(decrem())
   //=================

2.Swift闭包

闭包的有点：
1.根据上下文推断参数和返回值的类型
2.从单行的表达式闭包中隐式返回（也就是比好只有一行代码，可以省略return）
3.语法：{parameters->return type in
//表达式
}

        //闭包----单行、隐式返回，省略return
        let studyName = {print("swift 闭包示例，单行、隐式返回，省略return")}
        studyName()//调用
        //多参闭包
        let divide = {(val1:Int,val2:Int) ->Int in
            return val1 / val2
        }
        //调用
        let divideResult = divide(10,5)
        print(divideResult)

        //sorted 方法============
        let names = ["AT","AE","D","S","K","BE"]
        //闭包
        let backwards = {(a:String,b:String)->Bool in
            return a > b
        }
        //用闭包排序
        let reversed = names.sorted(by: backwards)
        print(reversed)
        //用函数排序
        let reversed2 = names.sorted(by: backwards2)
        print(reversed2)
    //函数
    func backwards2(a:String,b:String) -> Bool {
        return a > b
    }
        //Swift 自动为内联函数提供了参数名称缩写功能，您可以直接通过$0,$1,$2来顺序调用闭包的参数。
        let reversed3 = names.sorted(by: {$0 > $1})
        print(reversed3)
        //更简洁的方法
        let reversed4 = names.sorted(by: >)
        print(reversed4)
        //=======================
    尾随闭包
    尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。
        func someFunctionThatTakesAClosure(closure: () -> Void) {
    // 函数体部分
    }
let names = ["AT", "AE", "D", "S", "BE"]

//尾随闭包
var reversed = names.sorted() { $0 > $1 }
print(reversed)
sort() 后的 { $0 > $1} 为尾随闭包

3.结构体

struct markStuct {
    var mark:Int
    var fk:Int
    
    init(mark:Int,fk:Int) {
        self.mark = mark
        self.fk = fk
    }
}
        let astruct = markStuct(mark: 100, fk: 200)
        var bstruct = astruct//复制一份值给bstruct 
        bstruct.fk = 300//不会改变astruct的值
        print(astruct.fk)//输出200
        print(bstruct.fk)//输出300

4.类方法

    //可以直接用类名调用
    class func abs(number:Int)->Int{
        return number*2
    }
    //调用
    var hhh = ViewController.abs(number: 20)
    print(hhh)