《JavaScript函数式编程思想》——函数是一等值

悠悠 2022-03-21 14:39 237阅读 0赞

# 第4章  函数是一等值 #

在函数式编程的标准或特点中，“函数是一等值”是最基本和重要的，也是最为人所知的，所有介绍函数式编程的书籍和文章都会优先介绍这一点，以至于“一等值”几乎成为函数的专属头衔，听上去就像“王牌”一类的文学修辞，而实际上却两者皆不是。一等（First-class）是编程语言中值的通用修饰词，只要某个值满足以下三个条件，就能被称为一等值。

1.  可以作为参数传递给函数
2.  可以作为函数返回值
3.  可以被赋值给变量

所以数字、字符串等常用的值都是一等的。如果仅满足第一条，而不能作为函数返回值或被赋值给变量，就称为二等的（Second-class）。假如三条都不满足，则称为三等的（Third-class）。例如，标签（Label）在支持它的语言中基本上都是三等的（只能用于goto等语句，不能作为参数传递给函数等等）。函数值的情况最多样，在Basic语言中是三等值，在Pascal中是二等值，在C、Fortran、C\#等语言中是一等值，当然在所有函数式编程语言如Scheme、Haskell、Clojure中都是一等值。

此外，依赖变量和赋值是命令式编程的特点，函数式编程因为从原则上排斥状态，不鼓励使用变量，纯粹的函数式编程语言甚至没有变量，因而在这些语言中，函数是一等值的第三个条件就变为可以被赋值给常量。

4.1  函数参数      
4.1.1  数组的迭代方法      
4.1.2  设计函数参数      
4.2  函数返回值      
4.2.1  判断数据类型      
4.2.2  日志      
4.2.3  读取对象属性      
4.3  高阶函数      
4.3.1  组合谓词函数      
4.3.2  改变函数参数数目      
4.3.3  检查参数类型

### 4.3.4  记忆化 ###

缓存是提高程序性能的重要技术，对于输入输出、高耗资源的计算等需要花费较长时间的功能，将结果保存在能快速访问的载体里，以后遇上同样的调用，就直接读取上次保存的结果，从而大大节省时间，简言之，就是“以空间换时间”。在函数式编程中，对单个函数使用缓存的技术，称为记忆化（Memoization）。

我们选取用作缓存载体的数据类型是映射，这在JavaScript中有两种选择：通用的对象和专用的映射。根据2.7节中介绍的优点，映射更适合充当缓存。我们用一组函数来包装映射类型的方法。

// Map methods
    export const has = f.invoker('has');
    export const get=f.invoker('get');
    export const set = f.invoker('set');
    export const mapKeys = f.invoker('keys');
    
    /*
    读取嵌套的映射中对应于一组键的值。参数keys可能为单个键或多个键组成的数组。
     */
    export function mapGet(keys, map) {
        if (!Array.isArray(keys)) {
            return mapGet([keys], map);
        }
    
        // 循环算法
        for (let key of keys) {
            map = get(key, map);
        }
        // 若调用函数时没有提供keys，会返回map。
        return map;
    
        // 递归算法
        {
            if (f.isZeroLength(keys)) {
                return map;
            }
            const key = f.first(keys);
            map = get(key, map);
            return mapGet(f.rest(keys), map);
        }
    }
    
    /*
    检查嵌套的映射中是否有对应于一组键的值。
     */
    export function mapHas(keys, map) {
        if (!Array.isArray(keys)) {
            return mapHas([keys], map);
        }
    
        // 递归算法
        {
            if (f.isZeroLength(keys)) {
                return true;
            }
            const key = f.first(keys);
            if (has(key, map)) {
                map = get(key, map);
                return mapHas(f.rest(keys), map);
            } else {
                return false;
            }
        }
    }
    
    /*
     设置映射对应于一组键的值。若在该组键的路径上已经有值，且该值不是映射，用一个
     空的映射替换该值。
     keys必须为数组，若只有一个键，也需将其包容在数组中传入。
     */
    export function mapSet(keys, value, map) {
        const key = f.first(keys);
        if (keys.length === 1) {
            set(key, value, map);
            return;
        }
        if (!has(key, map) || !(get(key, map) instanceof Map)) {
            set(key, new Map(), map);
        }
        mapSet(f.rest(keys), value, get(key, map));
    }
    
    //可以用来判断一个数组是否为空。
    export function isZeroLength(obj) {
        return obj.length === 0;
    }

代码中用到的invoker函数的功能是将某个对象的方法转换成函数，将在5.4节中介绍。接下来我们可以定义memoize函数，它可以将任何函数变成一个记忆化的版本。奥妙在于，每当调用它返回的函数时，程序会以参数为键，检查位于该函数闭包中的一个作为缓存的映射；假如缓存中找到了对应于参数的值，就说明该函数曾经以同样的参数被调用过，无需重复计算，只要返回该值；假如没有找到，就说明该函数是第一次以这样的参数被调用，运行函数，将结果保存至缓存，再返回。注意函数的参数可能不止一个，我们不能将它们组成的数组用作映射的键，因为比较键值是否相等时，对于属于对象数据类型的数组，判断原则是看两个对象是否是同一个，即使两次调用函数时传递的参数值相同，它们组成的数组也不是同一个。所以这里的缓存是一个嵌套的映射，每个参数对应于嵌套中的一级，读写映射用到的mapHas、mapSet和mapGet函数可以接受多个键组成的数组，在嵌套的映射中逐级查找、写入和读取。

export function memoize(fn) {
        const cache = new Map();
        return function (...args) {
            let val;
            if (!m.mapHas(args, cache)) {
                val = fn(...args);
                m.mapSet(args, val, cache);
            }
            val = m.mapGet(args, cache);
            return val;
        }
    }

检验成果的时候到了，为了凸显记忆化的函数的效能，我们需要选用一个耗时很长的函数——计算圆周率小数点后的第58320493847362194位数字。

function piDigit(){
        //...
    }
    
    f.log(piDigit());
    //一年过去了
    //=>5
    
    f.log(piDigit());
    //又一年过去了
    //=>5
    
    const mPiDigit=f.memoize(piDigit);
    f.log(mPiDigit());
    //再一年过去了
    //=> 5
    
    f.log(mPiDigit());
    //=> 5

好吧，这次我们用一个真实的函数。

一般来说，与原函数相比，记忆化的函数首次运行时性能差不多，因为要读写缓存，用时可能会稍长，但之后以同样参数运行时，耗时都会稳定于一个很小的数字。上面的代码在不同的浏览器中运行结果略有差别，有些版本的浏览器首次运行记忆化的函数所费时间确实稍长于原函数，而以上的结果是在Chrome 65浏览器中测试所得，首次运行记忆化的函数所费时间比原函数还短，是得益于其JavaScript引擎再次运行某一函数时所作的性能优化。

4.4  小结