前言

接上篇, 这篇聊一下 Swift中的 函数, 闭包

一 函数

    // MARK: -函数定义  格式 func 函数名(形参列表) -> 返回值类型 {}
    func sum(a: Int, b: Int) -> Int {
        return a + b
    }

 // MARK: - 外部参数
    /** 
        - 外部参数就是在 形参前面加一个名字
        - 外部参数不会影响函数内部的细节
        - 外部参数使用'_', 调用时 会忽略形参的名字
     */
    func sum1(num1 x: Int, num2 y: Int) -> Int {
        return x + y
    }
    func sum2(_ x: Int, _ y: Int) -> Int {    
        return x + y
    }

// MARK: - 默认值
    /** 
        - 通过给参数设置默认值, 在调用时候, 可以任意组合参数, 如果不指定就使用默认值
     */
    func sum3(x: Int = 1, y: Int = 3) -> Int {
        
        return x + y
    }

   /** 测试默认值 调用
        print(sum3())  => 4
        print(sum3(x: 10, y: 30))  => 40
        print(sum3(x: 10))  => 13
        print(sum3(y: 30))  => 31
     */

 // MARK: - 无返回值
    /** 
        - 直接省略 () Viod 
     */
    func demo() {
        print("直接省略")
    }

二 闭包

func demo1() -> () {
        
        /** 
         *  闭包中 参数, 返回值, 实现代码都写在 {} 中
         *  需要使用关键字 'in' 分割定义和实现
         *  {形参列表 -> 返回值类型 in // 实现代码}
         */
        
        // 1. 最简单闭包
        // () -> () 无参无返回值闭包, 连 'in' 也可以省略
        let b = {
        
            print("hello")
        }
        b()
        
        // 2. 有参数无返回值闭包
        // (Int, Int) -> ()
        let b1 = { (a: Int, b: Int) -> () in
        
            print(a + b)
        }
        b1(1, 99)
        
        // 3. 有参数有返回值
        // (Int, Int) -> Int
        let b2 = { (x: Int, y: Int) -> Int in
        
            return x * y
        }
        print(b2(10, 12))
        
    }

// MARK: - 闭包作为函数的参数
    // ( 闭包名:()->() ) -> ()
    // Function types cannot have argument labels
    // 函数类型不能有参数标签, (在Swift3中, 把闭包的参数名 取消了)
    func loadData(success : @escaping(_ : [String]) -> ()) -> () {
        
        let json = ["新闻", "图片", "热点"]
        
        success(json)
    }
    
    //@noescape : 如果这个闭包是在这个函数结束前被调用，就是非逃逸的闭包(默认)。
    //@escaping : 如果这个闭包是在函数执行完后才被调用，调用的地方超过了这函数的范围，所以叫逃逸闭包。

 /*调用*/
 // 尾随闭包 : 如果函数最后一个参数是闭包, 函数参数可以提前结果, 最后一个参数直接使用 {} 包装闭包的代码
        // (相当于没有参数)
        loadData { (result) in
            
            print(result)
        }
        // 按照函数本身编写结果
        loadData(success: { (result) -> () in
        
            print(result)
        })
        
        // 闭包与block相同, 也有循环引用, 推荐用 [weak self]
        loadData { [weak self] (result) in
            
            print(self?.view as Any)
            print(result)
        }

 // MARK: - 网络请求
    func handleData(urlStr: String, completion: @escaping(String) -> ()) -> () {
        
        let url0 = URL(string: urlStr)
        
        guard let url = url0 else {
            print("网址为空")
            return
        }
        
        URLSession.shared.dataTask(with: url) { (data, response, error) in
            
            guard let data = data else {
                
                print("网络请求失败 \(String(describing: error))")
                return
            }
            
            let html = String(data: data, encoding: .utf8)
            completion(html!)
            
        }.resume()
        
    }

 /*调用*/
      handleData(urlStr: "https://wwww.baidu.com") { (result) in
            
           print(result)
      }

Swift 基础 先介绍三篇, 以后有机会再写.

以 上 !