JavaScript：reduce全局函数

数组是有reduce函数的，求和之类的很方便。一些类数组对象，比如{score1 : 100, score2 : 90, score3 : 95 }，不能用reduce函数函数，不是很方便。所以考虑提供一个reduce全局函数。
实现的思路很简单，就是将对象的属性遍历出来，组成一个数组，那么就可以方便地使用reduce函数了

数组的reduce函数

• reduce() 方法对累加器和数组中的每个元素 (从左到右)应用一个函数，将其减少为单个值。

• 一次作用数组的每一个值，最后返回一个单一值。最经典的例子是累加求和。不过实际的应用很广泛，比如可以拼接字符串，求最大值等等。

• 如果函数参数不是一个函数的话，会出错。函数参数是必选参数。

• 这个变换函数本身最多提供4个参数，依次是accumulator，currentValue，currentIndex，array。一般情况下，给2个参数，accumulator，currentValue。

• 初始值initialValue是一个可选参数。在实际使用中，大多数情况下是需要提供的。提供合适的初始值，需要考虑一下。一般情况是0，或者空数组[]，空字符串''等等。

• 一般提倡给初始值initialValue，变换函数的参数accumulator一开始就是这个initialValue，然后依次参与迭代运算，思路比较顺。

• accumulator和initialValue，还有最终结果是相同的类型

• 如果不给初始值initialValue，那么accumulator一开始是数组的第1个值，currentValue一开始是数组的第2个值。这样，会导致迭代变换次数比数组的元素个数少1，理解上不是很方便。
  一般情况，给初始值initialValue，并且注意其格式，这个决定了最终结果的格式

• 最后的结果，和初始值initialValue的形式是一样的。所以期望什么样的结果，就给什么格式的初始值initialValue，这个要注意。

• 变换函数的array参数就是调用reduce函数的这个数组，可以改变，不过强烈建议不要改变数组。后面两个参数currentIndex，array，如果不是必须，一般不要列出来。

JavaScript数组的高级用法-reduce和reduceRight详解

Array.prototype.reduce()

JavaScript中reduce()方法不完全指南

对象属性的遍历

• for...in返回的是可枚举的属性，包括自己的属性以及原型链上的属性。按照类的说法，也就是说会把父类的属性也枚举出来。

• for...in如果要过滤掉父类的属性，也就是原型链上的属性忽略掉，那么要借助Object的hasOwnProperty属性进行判断和过滤

• Object.keys()相当于for...in + hasOwnProperty效果。只枚举自己的可枚举属性，不管父类的属性。

• Object.getOwnPropertyNames()只列举自己的属性，不会管父类的属性。不过，会列出所有的属性，不管这个属性标记为可枚举还是不可枚举。比如，数组对象，会把length属性也列举出来。

• 这几个函数最好用于Object类型，不要用于数组。对于数组，返回的是字符串的0,1,2,3 ...，没什么实际意义。

JavaScript中in操作符(for..in)、Object.keys()和Object.getOwnPropertyNames()的区别

Object.keys()

Object.getOwnPropertyNames()

for...in

reduce全局函数

• 导出单一函数的方式，方便使用。文件名reduce_function.js

// 全局函数，区别于数组的reduce()方法
module.exports = function reduceFunction(callback, initialValue, target) {
    // 如果f不是函数，调用数组的reduce会报错
    if ('function' !== typeFunction(callback)) {
        return target;
    }
    const type = typeFunction(target)
    if (type === 'array') {
        return '_' === initialValue           // 判断是否调用init参数
            ? target.reduce(callback)
            : target.reduce(callback, initialValue);
    } else if (type === 'object') {
        // ES7 , chrome浏览器已经可以用
        // const values = Object.values(target);
        const keys = Object.keys(target);
        const values = keys.map(function (key) {
            return target[key];
        })
        return '_' === initialValue           // 判断是否调用init参数
            ? values.reduce(callback)
            : values.reduce(callback, initialValue);
    } else {
        return target;
    }
}

// private
function typeFunction(object) {
    return Object.prototype.toString.call(object).slice(8, -1).toLowerCase();
}

• 测试代码，在同一目录下，文件名reduce_function_test.js

const reduceFunction = require('./reduce_function.js');
const log = console.log;

// 数组累加
const items = [10, 120, 1000];
const add = function(previous, current) { 
    return previous + current; 
};
const max = function(previous, current) { 
    return previous > current
        ? previous
        : current;
};
const multiply = function(previous, current) { 
    return previous * current; 
};
const append = function(previous, current) { 
    return previous + '::' + current; 
};

log(items.reduce(add, 0));                  // 1130
log(items.reduce(max, 0));                  // 1000
log(items.reduce(multiply, 1));             // 1200000
log(items.reduce(append));                  // '10::120::1000'
log(reduceFunction(add, 0, items));         // 1130 
log(reduceFunction(max, 0, items));         // 1000 
log(reduceFunction(multiply, 1, items));    // 1200000 
log(reduceFunction(append, '_', items));    // '10::120::1000'

// 对象属性累加
const scores = {
    score1 : 10,
    score2 : 120,
    score3 : 1000,
}

log(reduceFunction(add, 0, scores));        // 1130
log(reduceFunction(max, 0, scores));        // 1000
log(reduceFunction(multiply, 1, scores));   // 1200000
log(reduceFunction(append, '_', scores));   // '10::120::1000'

// 数组转数字的例子，比如[1,6,8,8,8] => 16888
function addDigitValue(previousValue, currentDigit, currentIndex, array) {
    const exponent = (array.length - 1) - currentIndex;
    const digitValue = currentDigit * Math.pow(10, exponent);
    return previousValue + digitValue;
}

log([1,6,8,8,8].reduce(addDigitValue, 0));    // 16888
log(reduceFunction(addDigitValue, 0, {
    万 : 168, 
    千 : 6, 
    百 : 8,
    十 : 8,
    个 : 8,
 }));                                          // 1686888