Question

我有一个静态方法的类：

class User {
  constructor() {
    User.staticMethod();
  }

  static staticMethod() {}
}

对于静态方法是否存在类似的情况（即，在没有实例的情况下引用当前类）。

this.staticMethod()

所以我不必写下课程名称＆＃39; User＆＃39;。

Answer 1

来自MDN文档

静态方法调用直接在类上进行，而不是可以在类的实例上调用。静态方法经常被用来创建效用函数。

有关详情，请参阅=＆gt; https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/static

你可以做这样的事情=＆gt; this.constructor.staticMethod());调用静态方法。

class StaticMethodCall {
  constructor() {
    console.log(StaticMethodCall.staticMethod()); 
    // 'static method has been called.' 

    console.log(this.constructor.staticMethod()); 
    // 'static method has been called.' 
  }

  static staticMethod() {
    return 'static method has been called.';
  }
}

Answer 2

代替此User.staticMethod（），您可以添加this.constructor.staticMethod（）

Answer 3

static事物绑定到类而不是实例。所以你必须至少指定类名。

如果您不想将它们绑定到某个类，请将它们设为全局。

Answer 4

将javascript中一个类的静态成员添加为类属性，您可以使用代码查看列表

        console.log(Object.getOwnPropertyNames(PaymentStrategy));

并且仅用于访问成员

const memberFun = PaymentStrategy["memberName"];
//if member is a function then execute 
memberFun();
 //or 
memberFun(data);

示例：

class PaymentStrategy{

    static Card(user){
        console.log(`${user} will pay with a credit card`);
    }

    static PayPal(user){
        console.log(`${user} will pay through paypal`);

    }

    static BKash(user){
        console.log(`${user} will pay through Bkash`);
    }
}

export default PaymentStrategy;

import PaymentStrategy from "./PaymentStrategy";
class Payment{
    constructor(strategy = "BKash"){
        this.strategy = PaymentStrategy[strategy];
        console.log(Object.getOwnPropertyNames(PaymentStrategy));
    }

    changeStrategy(newStratgey){
        this.strategy = PaymentStrategy[newStratgey];

        console.log(`***Payment Strategy Changed***`);
    }

    showPaymentMethod(user){
        this.strategy(user);
    }
}

export default Payment;
```
```
import Payment from "./Payment"


const strategyPattern = (()=>{
    const execute = ()=>{
        const paymentMethod = new Payment();

        paymentMethod.showPaymentMethod("Suru");
        paymentMethod.showPaymentMethod("Nora");

        paymentMethod.changeStrategy("PayPal");

        paymentMethod.showPaymentMethod("Rafiq");
    }
    return{
        execute:execute
    }
})();

export {strategyPattern}
```

Answer 5

在@Ninjaneer接受的答案中：

class StaticMethodCall {   constructor() {
    console.log(StaticMethodCall.staticMethod()); 
    // 'static method has been called.' 

    console.log(this.constructor.staticMethod()); 
    // 'static method has been called.'    }

  static staticMethod() {
    return 'static method has been called.';   } }

this.constructor.staticMethod()将引发错误，因为您必须在访问构造函数中的this之前调用超级构造函数。

假设您解决了上述问题，没有双关语，我认为调用this.constructor.staticMethod()的唯一好处就是您不必依赖类的名称-如果它改变了。但是，这种好处可能微不足道，因为它仅有益于从类内部进行的静态方法调用。外部进行的静态方法调用必须类似于StaticMethodCall.constructor.staticMethod()之类的方法，它无法达到目的并且看起来很傻。

摘要：

如果您打算在类之外使用静态方法，那么我肯定会坚持使用StaticMethodCall.staticMethod（），因为它更加惯用和简洁。

如果您仅打算在类中使用静态方法，则可以使用this.constructor.staticMethod()，但这可能会使其他开发人员感到困惑并使他们回到此页面：-）

Answer 6

我刚刚遇到了一个类似的问题（引用了超静态方法），在这里留下一个答案，以防其他人觉得它有用。

本质上，解决方案是将类本身传递给静态方法。例如：

class Foo {
  static greet(Type) {
    return `Hello, ${Type.name()}`
  }
  static name() {
    return 'foo'
  }
}
class Bar extends Foo {
  static name() {
    return 'bar'
  }
}

现在你可以打电话了

Bar.greet(Bar) // returns 'Hello, bar'

js从类中调用静态方法

6 个答案: