模仿 TypeScript 中的扩展方法

Question

这是一个有趣的挑战。我正在阅读 TypeScript github 中的这个旧问题到 support Extension Methods，其用法类似于 C#。提出了两种主要的方法，一种是添加语法糖来扩展通常不受欢迎的对象原型，另一种是重写调用站点（参见优缺点here）。

我在想也许我们可以用另一种方式来模仿也适用于 JavaScript 的扩展方法。

假设我们有以下函数：

function includesAnyOf<T>(array: T[], ...searchElements: T[]) {
  return searchElements.some(_ => array.includes(_));
}

// example:
const a = [1, 2, 3];
const b = 3;
includesAnyOf(a, b); // true

// as extension method it would look like:
// a.includesAnyOf(b);

现在我想实现函数ext，这样我就可以做到：

ext(a).includesAnyOf(b)

罢工>

ext(a)(_ => _.includesAnyOf(b));

保留参数的所有类型。我想知道这是否可能，但我从这个开始，不知道如何完成它！

function ext(obj: any) {
  return {
    includesAnyOf: (...args: any[]) => includesAnyOf(...???)
  };
}

我认为这是一个有趣的挑战，您认为这可以如何实现，如何概括它，或者您能想到更好的方法吗？

Answer 1

我发现最简单的方法是使用lodash.partial 来执行currying。

function includesAnyOf<T>(array: T[], ...searchElements: T[]) {
  return searchElements.some(_ => array.includes(_));
}

import { partial } from 'lodash';

const a = [1, 2, 3];
const b = 3;
const ext = (o) => {
  return {
    includesAnyOf: partial(includesAnyOf, o)
  };
};

console.log(
  ext(a).includesAnyOf(b) // true
);

Answer 2

function ext<T, E>(obj: T, extension: E) {
   return (receiver: (extended: T & E) => any) => {
      receiver(new Proxy(obj, {
        get(target, prop, receiver) {
          if(prop in extension)
             return extension[prop];
          return Reflect.get(...arguments);
        },
        // TODO has, set, etc. according to needs
      } as T & E));
   };
}

ext(a, { includesAnyOf })(a => {
 a.includesAnyOf("stuff");
});

任务完成。

function ext(obj, extension) {
       return (receiver) => {
          receiver(new Proxy(obj, {
            get(target, prop, receiver) {
              if(prop in extension)
                 return extension[prop];
              return Reflect.get(...arguments);
            },
            // TODO has, set, etc. according to needs
          }));
       };
    }
    
    
function includesAnyOf(...searchElements) {
  return searchElements.some(_ => this.includes(_));
}
    
const a = [1, 2, 3];

ext(a, { includesAnyOf })(a => {
  console.log(a.includesAnyOf("stuff"));
});

你能想出更好的方法吗？

老实说，我认为常规函数没有任何好处。在 C# 和其他语言中，它很有用，因为您可以使用自动完成轻松找到这些扩展。无论你在 TS 中如何做到这一点，它都达不到这个目的。