JavaScript是一种支持面向对象编程范式的动态编程语言，用于创建对象的新实例。

对象不需要类。JavaScript是一种基于原型的语言。

摘要：

new关键字在JavaScript中用于从构造函数创建对象。new关键字必须放置在构造函数调用之前，并将执行以下操作：

创建新对象将此对象的原型设置为构造函数的原型属性将this关键字绑定到新创建的对象并执行构造函数返回新创建的对象

例子：

功能狗（年龄）{this.age=年龄；}const doggie=新狗（12）；console.log（doggie）；console.log（Object.getPrototypeOf（doggie）==Dog.prototype）//true

具体情况：

const doggie说：我们需要内存来声明变量。赋值运算符=表示：我们将使用=表达式是new Dog（12）。JavaScript引擎看到新关键字，创建一个新对象，并将原型设置为Dog.prototype执行构造函数时，将此值设置为新对象。在此步骤中，将年龄指定给新创建的小狗对象。新创建的对象被返回并分配给变量doggie。

JavaScript是一种面向对象的编程语言，它完全用于创建实例。它是基于原型的，而不是基于类的，但这并不意味着它不是面向对象的。

它做5件事：

它将创建一个新对象。此对象的类型只是对象。它将此新对象的内部、不可访问的[[prototype]]（即__proto__）属性设置为构造函数的外部、可访问的原型对象（每个函数对象都自动具有原型属性）。它使该变量指向新创建的对象。每当提到这一点时，它都会使用新创建的对象来执行构造函数。它返回新创建的对象，除非构造函数返回非空对象引用。在这种情况下，将返回该对象引用。

注意：构造函数是指new关键字之后的函数，如

new ConstructorFunction(arg1, arg2)

完成此操作后，如果请求了新对象的未定义属性，脚本将检查对象的[[prototype]]对象的属性。这就是如何在JavaScript中获得类似于传统类继承的东西。

这方面最困难的部分是第2点。每个对象（包括函数）都有一个名为[[prototype]]的内部属性。只能在对象创建时使用new、object.create或基于文本（函数默认为Function.prototype，数字默认为Number.prototype等）设置它。只能使用object.getPrototypeOf（someObject）读取它。没有其他方法设置或读取此值。

除了隐藏的[[prototype]]属性外，函数还有一个名为prototype的属性，您可以通过它访问和修改，为所创建的对象提供继承的财产和方法。

下面是一个示例：

ObjMaker = function() {this.a = 'first';};
// ObjMaker is just a function, there's nothing special about it that makes 
// it a constructor.

ObjMaker.prototype.b = 'second';
// like all functions, ObjMaker has an accessible prototype property that 
// we can alter. I just added a property called 'b' to it. Like 
// all objects, ObjMaker also has an inaccessible [[prototype]] property
// that we can't do anything with

obj1 = new ObjMaker();
// 3 things just happened.
// A new, empty object was created called obj1.  At first obj1 was the same
// as {}. The [[prototype]] property of obj1 was then set to the current
// object value of the ObjMaker.prototype (if ObjMaker.prototype is later
// assigned a new object value, obj1's [[prototype]] will not change, but you
// can alter the properties of ObjMaker.prototype to add to both the
// prototype and [[prototype]]). The ObjMaker function was executed, with
// obj1 in place of this... so obj1.a was set to 'first'.

obj1.a;
// returns 'first'
obj1.b;
// obj1 doesn't have a property called 'b', so JavaScript checks 
// its [[prototype]]. Its [[prototype]] is the same as ObjMaker.prototype
// ObjMaker.prototype has a property called 'b' with value 'second'
// returns 'second'

这类似于类继承，因为现在，使用新的ObjMaker（）创建的任何对象都似乎继承了“b”属性。

如果你想要一个类似子类的东西，那么你可以这样做：

SubObjMaker = function () {};
SubObjMaker.prototype = new ObjMaker(); // note: this pattern is deprecated!
// Because we used 'new', the [[prototype]] property of SubObjMaker.prototype
// is now set to the object value of ObjMaker.prototype.
// The modern way to do this is with Object.create(), which was added in ECMAScript 5:
// SubObjMaker.prototype = Object.create(ObjMaker.prototype);

SubObjMaker.prototype.c = 'third';  
obj2 = new SubObjMaker();
// [[prototype]] property of obj2 is now set to SubObjMaker.prototype
// Remember that the [[prototype]] property of SubObjMaker.prototype
// is ObjMaker.prototype. So now obj2 has a prototype chain!
// obj2 ---> SubObjMaker.prototype ---> ObjMaker.prototype

obj2.c;
// returns 'third', from SubObjMaker.prototype

obj2.b;
// returns 'second', from ObjMaker.prototype

obj2.a;
// returns 'first', from SubObjMaker.prototype, because SubObjMaker.prototype 
// was created with the ObjMaker function, which assigned a for us

在最后找到这一页之前，我读了大量关于这一主题的垃圾，在那里用漂亮的图表很好地解释了这一点。

new关键字使用函数作为构造函数创建对象的实例。例如：

var Foo = function() {};
Foo.prototype.bar = 'bar';

var foo = new Foo();
foo instanceof Foo; // true

实例继承自构造函数的原型。因此，在上面的例子中。。。

foo.bar; // 'bar'

每个函数都有一个原型对象，该对象自动设置为使用该函数创建的对象的原型。

你们可以轻松检查：

const a = { name: "something" };
console.log(a.prototype); // 'undefined' because it is not directly accessible

const b = function () {
    console.log("somethign");
};

console.log(b.prototype); // Returns b {}

但每个函数和对象都有__proto__属性，该属性指向该对象或函数的原型__原型和原型是两个不同的术语。我认为我们可以这样评论：“每个对象都通过proto链接到原型”，但__proto__在JavaScript中并不存在。浏览器添加此属性只是为了帮助调试。

console.log(a.__proto__); // Returns {}
console.log(b.__proto__); // Returns [Function]

你们可以很容易地在终端上检查这个。那么什么是构造函数？

function CreateObject(name, age) {
    this.name = name;
    this.age = age
}

首先要注意的五件事：

当使用new调用构造函数函数时，调用函数的内部[[Construct]]方法来创建新的实例对象并分配内存。我们没有使用return关键字。new将处理它。函数的名称是大写的，因此当开发人员看到您的代码时，他们可以理解他们必须使用新的关键字。我们不使用箭头函数。因为这个参数的值是在创建箭头函数的那个一刻获取的，即“窗口”。箭头函数的作用域是词汇化的，而不是动态的。这里的词汇是本地的意思。箭头函数携带其本地“this”值。与常规函数不同，箭头函数永远不能用new关键字调用，因为它们没有[[Construct]]方法。箭头函数也不存在原型属性。const me=新建CreateObject（“yilmaz”，“21”）new调用该函数，然后创建一个空对象{}，然后添加值为“name”的“name”键和值为参数“age”的“age”键。

当我们调用函数时，将使用“this”和“arguments”创建一个新的执行上下文，这就是为什么“new”可以访问这些arguments的原因。

默认情况下，构造函数中的这个将指向“window”对象，但new会更改它。“this”指向创建的空对象{}，然后将财产添加到新创建的对象中。如果您有任何未定义“this”属性的变量，则不会将其添加到对象中。

function CreateObject(name, age) {
    this.name = name;
    this.age = age;
    const myJob = "developer"
}

myJob属性不会添加到对象中，因为没有引用新创建的对象。

   const me = {name: "yilmaz", age: 21} // There isn't any 'myJob' key

一开始我说每个函数都有一个“原型”属性，包括构造函数。我们可以将方法添加到构造函数的原型中，这样从该函数创建的每个对象都可以访问它。

 CreateObject.prototype.myActions = function() { /* Define something */  }

现在，“me”对象可以使用“myActions”方法。

JavaScript具有内置的构造函数：Function、Boolean、Number、String等。

如果我创建

const a = new Number(5);
console.log(a); // [Number: 5]
console.log(typeof a); // object

使用new创建的任何对象都具有对象类型。现在“a”可以访问Number.prototype中存储的所有方法

const b = 5;
console.log(a === b); // 'false'

a和b是5，但a是对象，b是基元。尽管b是原始类型，但在创建它时，JavaScript会自动用Number（）包装它，因此b可以访问Number.prototype中的所有方法。

当您想要创建多个具有相同财产和方法的类似对象时，构造函数非常有用。这样，您就不会分配额外的内存，因此代码将更高效地运行。