前几天，我偶然发现了一些代码，我需要将一个对象作为常规数组处理几次。这当然可以使用Object.keys(),Object.values()或来实现Object.entries()，但它很快就变得冗长了。
所以我想我可以创建某种包装器来接收一个对象并为它定义一些类似数组的行为。我主要需要Array.prototype.map(),Array.prototype.find(). 使用方法创建所有这些功能都非常简单 。可以这么说，唯一棘手的部分是让对象表现得像一个可迭代对象，这需要使用Array.prototype.includes()和Array.prototype.lengthObjectSymbol.iterator生成器函数。
将新功能注入到对象中可以像添加方法一样简单。这种方法的缺点是它们将成为实际对象的一部分，这可能是有问题的。如果我们想在少数对象上应用它，这也不是很可重用，这也无济于事。
输入Proxy 对象，它是 JavaScript 开发人员工具带中鲜为人知的工具之一，但却是一个非常强大的工具。它用于拦截对象的某些操作，例如属性查找、赋值等。在这种情况下，它可以巧妙地将所需的功能包装到一个围绕对象创建代理的函数中。
最终代码（可能是）可以在下面的示例中看到。它实现了我需要的功能，以及一些更好的Array测量方法：
const toKeyedArray = obj => {
const methods = {
map(target) {
return callback =>
Object.keys(target).map(key => callback(target[key], key, target));
},
reduce(target) {
return (callback, accumulator) =>
Object.keys(target).reduce(
(acc, key) => callback(acc, target[key], key, target),
accumulator
);
},
forEach(target) {
return callback =>
Object.keys(target).forEach(key => callback(target[key], key, target));
},
filter(target) {
return callback =>
Object.keys(target).reduce((acc, key) => {
if (callback(target[key], key, target)) acc[key] = target[key];
return acc;
}, {});
},
slice(target) {
return (start, end) => Object.values(target).slice(start, end);
},
find(target) {
return callback => {
return (Object.entries(target).find(([key, value]) =>
callback(value, key, target)
) || [])[0];
};
},
findKey(target) {
return callback =>
Object.keys(target).find(key => callback(target[key], key, target));
},
includes(target) {
return val => Object.values(target).includes(val);
},
keyOf(target) {
return value =>
Object.keys(target).find(key => target[key] === value) || null;
},
lastKeyOf(target) {
return value =>
Object.keys(target)
.reverse()
.find(key => target[key] === value) || null;
},
};
const methodKeys = Object.keys(methods);
const handler = {
get(target, prop, receiver) {
if (methodKeys.includes(prop)) return methods[prop](...arguments);
const [keys, values] = [Object.keys(target), Object.values(target)];
if (prop === 'length') return keys.length;
if (prop === 'keys') return keys;
if (prop === 'values') return values;
if (prop === Symbol.iterator)
return function* () {
for (value of values) yield value;
return;
};
else return Reflect.get(...arguments);
},
};
return new Proxy(obj, handler);
};
// Object creation
const x = toKeyedArray({ a: 'A', b: 'B' });
// Accessing properties and values
x.a; // 'A'
x.keys; // ['a', 'b']
x.values; // ['A', 'B']
[...x]; // ['A', 'B']
x.length; // 2
// Inserting values
x.c = 'c'; // x = { a: 'A', b: 'B', c: 'c' }
x.length; // 3
// Array methods
x.forEach((v, i) => console.log(`${i}: ${v}`)); // LOGS: 'a: A', 'b: B', 'c: c'
x.map((v, i) => i + v); // ['aA', 'bB, 'cc]
x.filter((v, i) => v !== 'B'); // { a: 'A', c: 'c' }
x.reduce((a, v, i) => ({ ...a, [v]: i }), {}); // { A: 'a', B: 'b', c: 'c' }
x.slice(0, 2); // ['A', 'B']
x.slice(-1); // ['c']
x.find((v, i) => v === i); // 'c'
x.findKey((v, i) => v === 'B'); // 'b'
x.includes('c'); // true
x.includes('d'); // false
x.keyOf('B'); // 'b'
x.keyOf('a'); // null
x.lastKeyOf('c'); // 'c'