ECMAScript不像Ruby对Hash es那样为对象中缺少的键设置默认值。然而，你可以使用 * 动态内省元编程 * 来做类似的事情，使用ECMAScript Proxy对象：

const defaultValue = 42;
const proxyHandler = {
    get: (target, name) => name in target ? target[name] : defaultValue
};
const underlyingObject = {};

const hash = new Proxy(underlyingObject, proxyHandler);

1 in hash
//=> false
1 in underlyingObject
//=> false

hash[1]
//=> 42
underlyingObject[1]
//=> undefined

字符串
所以，你可以这样做：

arr.reduce(
    (acc, el) => { acc[el]++; return acc }, 
    new Proxy(
        {},
        { get: (target, name) => name in target ? target[name] : 0 }
    )
)
//=> Proxy [ { '0': 5, '1': 3 }, { get: [Function: get] } ]

型
然而，这仍然不等同于Ruby版本，其中the keys of the Hash can be arbitrary objects，而ECMAScript对象中的属性键只能是Strings和Symbols。
Ruby Hash的直接等价物是ECMAScript Map。
不幸的是，ECMAScript Map s也没有默认值。我们可以使用与对象相同的技巧来创建Proxy，但这会很尴尬，因为我们必须拦截对Map的get方法的访问，然后提取参数，调用has，等等。
幸运的是，Map被设计为可子类化：

class DefaultMap extends Map {
    #defaultValue;

    constructor(iterable=undefined, defaultValue=undefined) {
        super(iterable);
        this.#defaultValue = defaultValue;
    }

    get(key) {
        return this.has(key) ? super.get(key) : this.#defaultValue;
    }
}

const hash = new DefaultMap(undefined, 42);

hash.has(1)
//=> false

hash.get(1)
//=> 42

型
这允许我们做这样的事情：

arr.reduce(
    (acc, el) => acc.set(el, acc.get(el) + 1), 
    new DefaultMap(undefined, 0)
)
//=> DefaultMap [Map] { 1 => 3, 0 => 5 }

型
当然，一旦我们开始定义自己的Map，我们可能会一直这样做：

class Histogram extends DefaultMap {
    constructor(iterator=undefined) {
        super(undefined, 0);

        if (iterator) {
            for (const el of iterator) {
                this.set(el);
            }
        }
    }

    set(key) {
        super.set(key, this.get(key) + 1)
    }
}

new Histogram(arr)
//=> Histogram(2) [Map] { 1 => 3, 0 => 5 }

型
这也证明了一个非常重要的教训：数据结构的选择可以极大地影响算法的复杂性。通过正确选择数据结构（a Histogram），算法 * 完全消失 *，我们所做的就是示例化数据结构。
请注意，在Ruby中也是如此。By choosing the right data structure (there are several implementations of a MultiSet floating around the web), your entire algorithm vanishes and all that is left is：

require 'multiset'

Multiset[*arr]
#=> #<Multiset:#5 0, #3 1>

型

在JavaScript中，你可以用Array.reduce来实现

const reducer = (acc, e) => acc.set(e, (acc.get(e) || 0) + 1);
[1, 0, 0, 0, 1, 0, 0, 1].reduce(reducer, new Map())
//⇒ Map(2) {1 => 3, 0 => 5}

字符串

你可以使用Map，

• 将hash初始化为Map
• 遍历数组，如果key已经存在于hash中，则将其值增加1，否则将其设置为1

let arr = [1, 0, 0, 0, 1, 0, 0, 1]
let hash = new Map()

arr.forEach(val => {
  hash.set(val, (hash.get(val) || 0) + 1)
})

console.log([...hash])

字符串