Swift 中的基础语法(二)

 /// 函数的定义
    ///
    /// - Parameters:
    ///   - x: 形参
    ///   - y: 形参
    /// - Returns: 返回值
    func sum(x: Int, y: Int) -> Int {
        return x + y
    }

　　　　print(sum(x: 10, y: 20))

   /*
        外部参数就是在形参前面加了一个字
     外部参数不会影响函数内部的细节
     外部参数会让外部调用看起来更加直观
     外部参数如果使用了‘_‘，在外部调用函数时，会忽略形参的名字
     "_" 就是可以忽略任意不感兴趣的内容
     */
    func sum1(num1 x: Int, num2 y:Int) -> Int {
        
        return x + y;
    }

　　　　print(sum1(num1: 10, num2: 20))

 func sum2(_ x: Int, _ y:Int) -> Int {
        return x + y;
    }
    print(sum3())

   // 默认值
    func sum3(x: Int = 1, y: Int = 2) -> Int {
        return x + y
    }
这里比较灵活

print(sum3(x: 10, y: 20))
print(sum3(x: 10))
print(sum3(y: 20))

  func demo1() {
        print("哈哈")
    }
    
    func demo2() -> (){
        print("呵呵")
    }
    
    func demo3() -> Void {
        print("嘻嘻")
    }

demo1()
demo2()
demo3()

 // 1.闭包,最简单的闭包
        //n 如果没有参数，没有返回值 可以省略 连 in 都一起省略
        // option + click
        let  b1 = {
            print("hello")
        }
        b1()

    // 带参数的闭包
        //闭包中，参数，返回值 实现的代码都是写在{}中
        // 需要使用一个关键字 “in” 分隔定义和实现
        // {形参列表 -> 返回值类型 in // 实现代码}
        let b2 = {
            (x: Int) -> () in
            print(x)
        }
        
      b2(100)

   //带参数 带会返回值的闭包
        let b3 = {
            (x: Int) -> Int in
            
            return x + 1
        }
        print(b3(10))

 //弱引用的对象 又一次执行 nil的机会
        weak var weakSelf = self
        loadData { (result) in
            print(result,weakSelf)
        }
    }

    //[weak self] 和 __weak typeof(self) 作用类似  -> 对象被回收是 内存地址会自动指向nil  更加安全 推荐使用这种方式
    func methodInSwift1() {
        loadData { [weak self] (result) in
            print(result,self)
        }
    }

    // [unowned self] 和 __unsafe__retained作用类似  -> 对象被回收是 内存地址不会自动指向nil 会造成野指针访问
    
    func methodInSwift2() {

        loadData { [unowned self] (result) in
            print(result,self)
        }
    }