如何在JavaScript中将对象用作数组而不修改它？

前几天，我偶然发现了一些代码，其中我需要多次将对象处理为常规数组。当然，可以使用Object.keys()、Object.values()或Object.entries()来实现，但这很快变得冗长。

所以我想我可以创建一种包装器，它可以接受一个对象并为其定义一些类似数组的行为。我主要需要Array.prototype.map()、Array.prototype.find()、Array.prototype.includes()和Array.prototype.length。使用Object方法创建所有这些功能非常简单。所谓的棘手部分只是让对象作为可迭代对象，这需要使用Symbol.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);
};

// 对象创建
const x = toKeyedArray({ a: 'A', b: 'B' });

// 访问属性和值 x.a; // 'A' x.keys; // ['a', 'b'] x.values; // ['A', 'B'] [...x]; // ['A', 'B'] x.length; // 2

// 插入值 x.c = 'c'; // x = { a: 'A', b: 'B', c: 'c' } x.length; // 3

// 数组方法 x.forEach((v, i) => console.log(${i}: ${v})); // 输出: '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' ```