• Swift 柯里化


    前言

    • 由于柯里化在业务层的应用较少,所以从 Swift 3.0 开始移除了柯里化的用法,但是 Swift 的很多底层特性是使用柯里化来表达的。

    1、柯里化

    1.1 柯里化简介

    • 柯里化(Currying),又称部分求值(Partial Evaluation),是一种函数式编程思想,就是把接受多个参数的函数转换成接收一个单一参数(最初函数的第一个参数)的函数,并且返回一个接受余下参数的新函数技术。

    • uncurried: 普通函数

      // 接收多个参数的函数(与类相关的函数,统称为方法,但是这里就直接说函数了,方便理解)
      func add(a: Int, b: Int, c: Int) -> Int {
      
          print("(a) + (b) + (c)")
          return a + b + c
      }
      
    • curried: 柯里化函数

      // 柯里化函数,Swift 3.0 之前支持这样的语法,可以直接写
      func addCur(a: Int)(b: Int)(c: Int) -> Int {
      
          println("(a) + (b) + (c)")
          return a + b + c
      }
      

    1.2 如何定义柯里化函数

    • 定义柯里化函数

      func function name (parameters)(parameters) -> return type {
      
          statements
      }
      

    1.3 柯里化函数实现原理

    • uncurried: 普通函数

      class Currying {
      
          // 接收多个参数的函数
          func add(a: Int, b: Int, c: Int) -> Int {
      
              print("(a) + (b) + (c)")
              return a + b + c
          }
      }
      
    • 系统自带的柯里化函数

      class Currying {
      
          func addCur(a: Int)(b: Int)(c: Int) -> Int {
      
              print("(a) + (b) + (c)")
              return a + b + c
          }
      }
      
    • 手动实现柯里化函数

      • 把上面的函数转换为柯里化函数,首先转成接收第一个参数 a,并且返回接收余下第一个参数 b 的新函数(采用闭包).

      • 这里为什么能使用参数 a、b、c ?

        • 利用闭包的值捕获特性,即使这些值作用域不在了,也可以捕获到他们的值。
        • 闭包会自动判断捕获的值是值拷贝还是值引用,如果修改了,就是值引用,否则值拷贝。
        • 注意只有在闭包中才可以,a、b、c 都在闭包中。
        class Currying {
        
            // (a: Int)                    : 参数
            // (b: Int) -> (c: Int) -> Int : 函数返回值(一个接收参数 b 的函数,并且这个函数又返回一个接收参数 c,
            //                               返回值为 Int 类型的函数)
        
            // 定义一个接收参数 a,并且返回一个接收参数 b 的函数,并且这个函数又返回一个接收参数 c,返回值为 Int 类型的函数。
            func add(a: Int) -> (b: Int) -> (c: Int) -> Int {
        
                // 返回一个接收参数 b 的函数,并且这个函数又返回一个接收参数 c,返回值为 Int 类型的函数
                return { (b:Int) -> (c: Int) -> Int in
            
                    // 返回一个接收余下第一个参数 c,并且返回结果为 Int 类型的函数
                    return { (c: Int) -> Int in
                
                        return a + b + c;
                    }
                }
            }
        }
        

    1.4 如何调用柯里化函数

    • 创建柯里化类的实例

      var curryInstance = Currying()
      
    • 手动实现的柯里化函数调用

      var result: Int = curryInstance.add(a: 10)(b: 20)(c: 30)
      
      • 可能很多人都是第一次看这样的调用,感觉有点不可思议。
      • 让我们回顾下 OC 创建对象 [[Person alloc] init],这种写法应该都见过吧,就是一下发送了两个消息,alloc 返回一个实例,再用实例调用 init 初始化,上面也是一样,一下调用多个函数,每次调用都会返回一个函数,然后再次调用这个返回的函数。
    • 手动实现的柯里化函数拆解调用

      • curryInstance.add(a: 10) 调用一个接收参数 a,并且返回一个接收参数 b 的函数,并且这个函数又返回一个接收参数 c,返回值为 Int 类型的函数。

        // functionB: 一个接收参数 b 的函数,并且这个函数又返回一个接收参数 c,返回值为 Int 类型的函数
        let functionB = curryInstance.add(a: 10)
        
      • functionB(b: 20) 调用一个接收参数 b 的函数,并且这个函数又返回一个接收参数 c,返回值为 Int 类型的函数。

        // functionC: 一个接收参数 c,返回值为 Int 类型的函数
        let functionC = functionB(b: 20)
        
      • functionC(c: 30) 调用一个接收参数 c,返回值为 Int 类型的函数。

        // result: 函数的返回值
        var result: Int = functionC(c: 30);
        
    • 系统的柯里化函数调用

      var result: Int = curryInstance.addCur(a: 10)(b: 20)(c: 30)
      
    • 系统的柯里化函数拆解调用

      • curryInstance.addCur(a: 10) 调用一个接收参数 a,并且返回一个接收参数 b 的函数,并且这个函数又返回一个接收参数 c,返回值为 Int 类型的函数。

        // Swift是强类型语言,这里没有报错,说明调用系统柯里化函数返回的类型和手动的 functionB 类型一致
        // functionB: 一个接收参数 b 的函数,并且这个函数又返回一个接收参数 c,返回值为 Int 类型的函数
        functionB = curryInstance.addCur(a: 10)
        
      • functionB(b: 20) 调用一个接收参数 b 的函数,并且这个函数又返回一个接收参数 c,返回值为 Int 类型的函数。

        // functionC: 一个接收参数c,返回值为Int类型的函数
        functionC = functionB(b: 20)
        
      • functionC(c: 30) 调用一个接收参数 c,返回值为 Int 类型的函数。

        // result: 函数的返回值
        result = functionC(c: 30)
        
        // 打印 60,60,60 说明手动实现的柯里化函数,和系统的一样。
        print("(r), (res), (result)")
        

    1.5 柯里化函数使用注意

    • 必须按照参数的定义顺序来调用柯里化函数,否则就会报错。

    • 柯里化函数的函数体只会执行一次,只会在调用完最后一个参数的时候执行柯里化函数体。

      • 以下调用 functionC(c: 30) 才会执行函数体,这个可以自己断点调试。

        // curried: 柯里化函数
        func addCur(a: Int)(b: Int)(c: Int) -> Int {
        
            println("(a) + (b) + (c)")
            return a + b + c
        }
        
        // 创建柯里化类的实例
        var curryInstance = Currying()
        
        // 不会执行柯里化函数体
        functionB = curryInstance.addCur(a: 10)
        
        // 不会执行柯里化函数体
        functionC = functionB(b: 20)
        
        // 执行柯里化函数体
        result = functionC(c: 30)
        

    1.6 柯里化函数的好处

    • 这里就需要了解函数式编程思想了,柯里化函数就是运用了函数式编程思想,推荐看这篇文章函数式编程初探

    • 特点

      • 1)只用 “表达式” (表达式: 单纯的运算过程,总是有返回值),不用 “语句” (语句: 执行某种操作,没有返回值)。
      • 2)不修改值,只返回新值。
    • 好处

      • 1)代码简洁。
      • 2)提高代码复用性。
      • 3)代码管理方便,相互之间不依赖,每个函数都是一个独立的模块,很容易进行单元测试。
      • 4)易于 “并发编程”,因为不修改变量的值,都是返回新值。

    1.7 柯里化函数的实用性

    • 实用性一:复用性

      • 需求 1:地图类产品,很多界面都有相同的功能模块,比如搜索框。

        • 我们可以利用柯里化函数,来组装界面,把界面分成一个个小模块,这样其他界面有相同的模块,直接运用模块代码,去重新组装下就好了。
    • 实用性二:延迟性

      • 柯里化函数代码需要前面的方法调用完成之后,才会来到柯里化函数代码中。

      • 需求 2:阅读类产品,一个界面的显示,依赖于数据,需要加载完数据之后,才能判断界面显示。

        • 这时候也可以利用柯里化函数,来组装界面,把各个模块加载数据的方法抽出来,等全部加载完成,再去执行柯里化函数,柯里化函数主要实现界面的组装。
    • 举例说明

      // 组合接口
      // 为什么要定义接口,为了程序的扩展性,以后只需要在接口中添加对应的组合方法就好了。
      protocol CombineUI {
      
          func combine(top: () -> ())(bottom: () -> ())()
      }
      
      // 定义一个界面类,遵守组合接口
      class UI: CombineUI {
      
          func combine(top: () -> ())(bottom: () -> ())() {
          
              // 搭建顶部
              top()
              
              // 搭建底部
              bottom()
          }
      }
      

    2、Swift 中实例方法的柯里化

    • Swift 中实例方法就是一个柯里化函数。

    2.1 Swift 中实例方法的柯里化调用

    • Swift 中实例方法的柯里化调用

      • 示例结构体

        struct Example {
        
            var internalStr = ""
        
            func combine(externalStr: String) {
                print(internalStr + " " + externalStr)
            }
        }
        
      • 调用实例方法的常用格式

        let example = Example(internalStr: "hello")
        
        example.combine(externalStr: "word")            // hello word
        
      • 调用实例方法的柯里化格式

        let example = Example(internalStr: "hello")
        
        Example.combine(example)(externalStr: "word")   // hello word
        
  • 相关阅读:
    VS Code 快捷键(中英文对照版)
    一些网络资源
    VS Code插件
    Angular for TypeScript 语法快速指南 (基于2.0.0版本)
    Angular2 中的依赖包详解
    《ECMAScript 6 入门》阮一峰
    《JavaScript 标准参考教程》阮一峰
    Angular内提供了一个可以快速建立测试用web服务的方法:内存 (in-memory) 服务器
    由angular命令行工具(angular-cli)生成的目录和文件
    Angular 4.x 修仙之路
  • 原文地址:https://www.cnblogs.com/QianChia/p/8876174.html
Copyright © 2020-2023  润新知