我们可以把一个方法赋值给类的函数本身,而不是赋给它的 “prototype”。这样的方法被称为 静态的(static)
在一个类中,它们以 static 关键字开头,如下所示:

  1. class User {
  2. static staticMethod() {
  3. alert(this === User);
  4. }
  5. }
  6. User.staticMethod(); // true

这实际上跟直接将其作为属性赋值的作用相同:

  1. class User { }
  2. User.staticMethod = function() {
  3. alert(this === User);
  4. };
  5. User.staticMethod(); // true

在 User.staticMethod() 调用中的 this 的值是类构造器 User 自身(“点符号前面的对象”规则)。
通常,静态方法用于实现属于该类但不属于该类任何特定对象的函数。

  1. class Article {
  2. constructor(title, date) {
  3. this.title = title;
  4. this.date = date;
  5. }
  6. static compare(articleA, articleB) {
  7. return articleA.date - articleB.date;
  8. }
  9. }
  10. // 用法
  11. let articles = [
  12. new Article("HTML", new Date(2019, 1, 1)),
  13. new Article("CSS", new Date(2019, 0, 1)),
  14. new Article("JavaScript", new Date(2019, 11, 1))
  15. ];
  16. articles.sort(Article.compare);
  17. alert( articles[0].title ); // CSS

这里 Article.compare 代表“上面的”文章,意思是比较它们。它不是文章的方法,而是整个 class 的方法。
另一个例子是所谓的“工厂”方法。想象一下,我们需要通过几种方法来创建一个文章:

  1. 通过用给定的参数来创建(title,date 等)。
  2. 使用今天的日期来创建一个空的文章。
  3. ……其它方法。

第一种方法我们可以通过 constructor 来实现。对于第二种方式,我们可以创建类的一个静态方法来实现。
就像这里的 Article.createTodays():

  1. class Article {
  2. constructor(title, date) {
  3. this.title = title;
  4. this.date = date;
  5. }
  6. static createTodays() {
  7. // 记住 this = Article
  8. return new this("Today's digest", new Date());
  9. }
  10. }
  11. let article = Article.createTodays();
  12. alert( article.title ); // Today's digest

现在,每当我们需要创建一个今天的文章时,我们就可以调用 Article.createTodays()。再说明一次,它不是一个文章的方法,而是整个 class 的方法。
静态方法也被用于与数据库相关的公共类,可以用于搜索/保存/删除数据库中的条目, 就像这样:

  1. // 假定 Article 是一个用来管理文章的特殊类
  2. // 静态方法用于移除文章:
  3. Article.remove({id: 12345});

静态属性

A recent addition This is a recent addition to the language. Examples work in the recent Chrome.

静态的属性也是可能的,它们看起来就像常规的类属性,但前面加有 static:

  1. class Article {
  2. static publisher = "Levi Ding";
  3. }
  4. alert( Article.publisher ); // Levi Ding

这等同于直接给 Article 赋值:

  1. Article.publisher = "Levi Ding";

继承静态属性和方法

静态属性和方法是可被继承的。
例如,下面这段代码中的 Animal.compare 和 Animal.planet 是可被继承的,可以通过 Rabbit.compare 和 Rabbit.planet 来访问:

  1. class Animal {
  2. static planet = "Earth";
  3. constructor(name, speed) {
  4. this.speed = speed;
  5. this.name = name;
  6. }
  7. run(speed = 0) {
  8. this.speed += speed;
  9. alert(`${this.name} runs with speed ${this.speed}.`);
  10. }
  11. static compare(animalA, animalB) {
  12. return animalA.speed - animalB.speed;
  13. }
  14. }
  15. // 继承于 Animal
  16. class Rabbit extends Animal {
  17. hide() {
  18. alert(`${this.name} hides!`);
  19. }
  20. }
  21. let rabbits = [
  22. new Rabbit("White Rabbit", 10),
  23. new Rabbit("Black Rabbit", 5)
  24. ];
  25. rabbits.sort(Rabbit.compare);
  26. rabbits[0].run(); // Black Rabbit runs with speed 5.
  27. alert(Rabbit.planet); // Earth

现在我们调用 Rabbit.compare 时,继承的 Animal.compare 将会被调用。
它是如何工作的?再次,使用原型。你可能已经猜到了,extends 让 Rabbit 的 [[Prototype]] 指向了 Animal。
animal-rabbit-static.svg
所以,Rabbit extends Animal 创建了两个 [[Prototype]] 引用:

  1. Rabbit 函数原型继承自 Animal 函数。
  2. Rabbit.prototype 原型继承自 Animal.prototype。

结果就是,继承对常规方法和静态方法都有效。
这里,让我们通过代码来检验一下:

  1. class Animal {}
  2. class Rabbit extends Animal {}
  3. // 对于静态的
  4. alert(Rabbit.__proto__ === Animal); // true
  5. // 对于常规方法
  6. alert(Rabbit.prototype.__proto__ === Animal.prototype); // true

总结

静态方法被用于实现属于整个类的功能。它与具体的类实例无关。
举个例子, 一个用于进行比较的方法 Article.compare(article1, article2) 或一个工厂(factory)方法 Article.createTodays()。
在类生命中,它们都被用关键字 static 进行了标记。
静态属性被用于当我们想要存储类级别的数据时,而不是绑定到实例。
语法如下所示:

  1. class MyClass {
  2. static property = ...;
  3. static method() {
  4. ...
  5. }
  6. }

从技术上讲,静态声明与直接给类本身赋值相同:

  1. MyClass.property = ...
  2. MyClass.method = ...

静态属性和方法是可被继承的。
对于 class B extends A,类 B 的 prototype 指向了 A:B.[[Prototype]] = A。因此,如果一个字段在 B 中没有找到,会继续在 A 中查找。