Javascript 我们是否应该在ES6类的原型中包含方法以提高性能？

因此，当我进一步了解JS中的

原型继承

时，我在文章中阅读了以下内容（阅读此链接上方的行）

请注意，当我们调用构造函数时，每次都会定义greeting（），这并不理想。为了避免这种情况，我们可以在原型上定义函数，我们将在后面介绍

建议在函数上添加

属性

，在

原型上添加
方法
（阅读）

我在很多地方都是这样读的


对象创建速度更快，因为不是为每个对象创建都创建
fore
。这是因为它只创建一次并附加到
原型
，所有对象都链接到
原型

这些方法是在
原型链
上查找的，因此每个对象都链接到
原型
上的相同方法


现在是ES6课程。我有以下代码

class Person {
    constructor(first, last, age, gender, interests) {
        this.name = {
            first: first,
            last: last
        };
        this.age = age;
        this.gender = gender;
        this.interests = interests;
    }

    greeting () {
        console.log("Hi! I am", this.name.first);
    }

    farewell () {
        console.log(this.name.first, "has left the building. Bye for now!");
    }
}

似乎通过这种方法，
问候语
和
告别
将再次被创建（遵循与函数相同的逻辑，因为
类
是一种语法糖）

所以，我把课程改为

class Person {
    constructor(first, last, age, gender, interests) {
        this.name = {
            first: first,
            last: last
        };
        this.age = age;
        this.gender = gender;
        this.interests = interests;
    }
}

Person.prototype.greeting = function () {
    console.log("Hi! I am", this.name.first);
}

Person.prototype.farewell = function () {
    console.log(this.name.first, "has left the building. Bye for now!");
}

问题

1.后一种方法（在
ES6类中的
prototype
上添加方法）是推荐的方法吗？

2.创建新对象的
类
和传统的
新功能
的逻辑是否一致<代码>复制
vs
原型上的方法

如果我还缺什么，请告诉我

谢谢


更新

在回答了几个问题后，我重新尝试了我的例子并确认了答案。我的代码看起来像

class Phone {
  constructor(company, name, color, price) {
    this.company = company;
    this.name = name;
    this.color = color;
    this.price = price;
  }

  print() {
    console.log(this.company, this.name, this.color, this.price);
  }
}

class Apple extends Phone {
    constructor(name, color, price) {
        super("Apple", name, color, price);
        this.companyWork = "ClosedSource";
    }
}

let iPhone11 = new Apple("iPhone11", "black", 900);
iPhone11.print()

运行此代码后，我可以确认
print（）
在
Phone.prototype上可用
AFAIK

不，这不是推荐的方式。类方法作为原型上的方法创建。换句话说，类只是常规原型继承的语法糖
在这两种情况下，如果创建了多个对象，则不会多次创建方法。方法将只创建一次
阿法克

不，这不是推荐的方式。类方法作为原型上的方法创建。换句话说，类只是常规原型继承的语法糖
在这两种情况下，如果创建了多个对象，则不会多次创建方法。方法将只创建一次
正如您已经发现的，
class
定义将方法放在原型上。您要求提供一份参考资料，因此这里有一些代码您可以自己运行查看：


班级人员{
建造师（第一、最后、年龄、性别、兴趣）{
this.name={
第一:第一,，
最后：最后
};
这个。年龄=年龄；
这个。性别=性别；
这个。利益=利益；
}
问候语（）{
log（“嗨！我是”，这个名字，第一个）；
}
再见（）{
log（this.name.first，“已离开大楼，再见！”）；
}
}
让p=新人（“杰克”，“豆茎”，“201”，“巨人”，“粉碎的东西”，“跺脚的东西”）；
log（“Person”，Object.getOwnPropertyNames（Person））；
log（“p”，Object.getOwnPropertyNames（p））；
设p_prototype=Object.getPrototypeOf（p）；
log（“p_prototype==Person.prototype is”，p_prototype==Person.prototype）；
log（“Person.prototype”，Object.getOwnPropertyNames（Person.prototype））正如您已经发现的，
class
定义将方法放在原型上。您要求提供一份参考资料，因此这里有一些代码您可以自己运行查看：


班级人员{
建造师（第一、最后、年龄、性别、兴趣）{
this.name={
第一:第一,，
最后：最后
};
这个。年龄=年龄；
这个。性别=性别；
这个。利益=利益；
}
问候语（）{
log（“嗨！我是”，这个名字，第一个）；
}
再见（）{
log（this.name.first，“已离开大楼，再见！”）；
}
}
让p=新人（“杰克”，“豆茎”，“201”，“巨人”，“粉碎的东西”，“跺脚的东西”）；
log（“Person”，Object.getOwnPropertyNames（Person））；
log（“p”，Object.getOwnPropertyNames（p））；
设p_prototype=Object.getPrototypeOf（p）；
log（“p_prototype==Person.prototype is”，p_prototype==Person.prototype）；
log（“Person.prototype”，Object.getOwnPropertyNames（Person.prototype））这两个代码段做相同的事情。类方法是类的原型对象的属性。谢谢@Paulpro，你能引用一个参考吗？“似乎通过这种方法，问候和告别将再次被创建”-呃，不。它们不在
构造函数中，它们位于
类语法中，这将它们放在类的原型对象上。这两个代码段做同样的事情。类方法是类的原型对象的属性。谢谢@Paulpro，你能引用一个参考吗？“似乎通过这种方法，问候和告别将再次被创建”-呃，不。它们不在
构造函数中，它们位于
类语法中，这就把它们放在了类的原型对象上。谢谢@krl，你能引用一篇关于“类方法是作为原型上的方法创建的”的参考文章吗。非常感谢。我试着向上看，但找不到官员answer@daydreamer这行吗。。。在ES2015中引入了class关键字，但它是语法上的糖，JavaScript仍然基于原型谢谢@krl，请您引用关于“类方法作为原型上的方法创建”的参考。非常感谢。我试着抬头看，但看不见
class Phone {
  constructor(company, name, color, price) {
    this.company = company;
    this.name = name;
    this.color = color;
    this.price = price;
  }

  print() {
    console.log(this.company, this.name, this.color, this.price);
  }
}

class Apple extends Phone {
    constructor(name, color, price) {
        super("Apple", name, color, price);
        this.companyWork = "ClosedSource";
    }
}

let iPhone11 = new Apple("iPhone11", "black", 900);
iPhone11.print()