Question

我有这段代码：

class A {
   static b() {

   }
}

class B {
  static c() {

  }
}

我正在尝试将这两个静态类合并为一个：

const combined = { ...A, ...B };

但是，组合对象会产生一个空对象，而我期待一个包含所有静态方法的对象。

我做错了什么？

Answer 1

您可以在新对象中设置方法

const combined = {A:A.b, B:B.c}

Answer 2

您可以使用Object.getOwnPropertyNames获取类的静态方法数组：

＆＃13;

class A {
  static staticMethod() {}
  nonStaticMethod() {}
}

console.log(Object.getOwnPropertyNames(A));

＆＃13;

有一些我们不感兴趣的属性，即prototype，length和name。我们可以手动过滤掉它们，例如像这样：

＆＃13;

class A {
  static staticMethod() {}
  nonStaticMethod() {}
}

console.log(
  Object.getOwnPropertyNames(A)
    .filter(prop => prop !=='prototype' && prop !== 'length' && prop !== 'name')
);

＆＃13;

好！现在我们可以创建combined对象并添加A过滤后的方法：

＆＃13;

class A {
  static b() {
    console.log('called A.b');
  }
}

const classAMethods = Object.getOwnPropertyNames(A)
                        .filter(prop => prop !== 'prototype' &&
                                        prop !== 'length' &&
                                        prop !== 'name');

const combined = {};
combined.A = {};

classAMethods.forEach(method => {
  combined.A[method] = () => A[method]();
});

console.log(combined);
combined.A.b();

＆＃13;

如果您希望能够拨打combined.b()，则可以执行以下操作。请注意，这种方式在多个类中具有相同名称的方法将发生冲突。例如。如果您同时定义A.b和B.b，则combined只能包含其中一个。

＆＃13;

class A {
  static b() {
    console.log('called A.b');
  }
}

const classAMethods = Object.getOwnPropertyNames(A)
                        .filter(prop => prop !== 'prototype' &&
                                        prop !== 'length' &&
                                        prop !== 'name');

const combined = {};

classAMethods.forEach(method => {
  combined[method] = () => A[method]();
});

console.log(combined);
combined.b();

＆＃13;

为了将所有人聚集在一起，我们有以下内容。请注意，我在调用类方法时使用...args添加了对传递参数的支持。

＆＃13;

class A {
  static b() {
    console.log('called A.b');
  }
}

class B {
  static c(name1, name2) {
    console.log('called B.c, hello', name1, 'and', name2);
    return 'returned by B.c';
  }
}


const getMethods = (cls) => Object.getOwnPropertyNames(cls)
                              .filter(prop => prop !== 'prototype' &&
                                              prop !== 'length' &&
                                              prop !== 'name');

const combined = {};

const addMethodsToCombined = (cls) => {
  combined[cls.name] = {};
  getMethods(cls).forEach(method => {
    combined[cls.name][method] = (...args) => cls[method](...args);
  });
};


addMethodsToCombined(A);
addMethodsToCombined(B);

console.log(combined);
combined.A.b();
console.log(combined.B.c('world', 'universe'));

＆＃13;

.as-console-wrapper { max-height: 100% !important; top: 0; }

＆＃13;

当您向班级A或B添加新的静态方法时，它们也会自动通过combined提供。如果您创建新课程C，则只需致电addMethodsToCombined(C)。

Answer 3

您可以从A扩展B，然后从B扩展另一个类。

如果你正在使用静态类，那么最好只使用对象文字

＆＃13;

class A {
   static b() {
      console.log('called A.b')
   }
}

class B extends A {
  static c() {
    console.log('called B.c')
  }
}

class Combined extends B {}

Combined.b()
Combined.c()

＆＃13;

Javascript es6将2个静态类组合成一个对象

3 个答案: