/// 函数的定义

    ///

    /// - 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 = , y: Int = ) -> 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()

   //带参数 带会返回值的闭包

        let b3 = {

            (x: Int) -> Int in

            return x +

        }

        print(b3())

 //弱引用的对象 又一次执行 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)

        }

    }