JavaScript中的“new”关键字是什么？

Question

这个新的JavaScript中的关键字在第一次遇到时可能会非常混乱，因为人们往往认为JavaScript不是面向对象的编程语言。

• 这是怎么一回事？
• 它解决了什么问题？
• 什么时候合适，什么时候不合适？

Answer 1

它做5件事：

1. 它创建一个新对象。此对象的类型很简单对象.
2. 它设置这个新对象的内部不可访问，[[原型]]（即。__原型__)属性作为构造函数的外部、可访问、，原型对象（每个函数对象自动具有原型属性）。
3. 它使这变量指向新创建的对象。
4. 它执行构造函数，在任何时候都使用新创建的对象这提到。
5. 它返回新创建的对象，除非构造函数返回非-无效的对象引用。在这种情况下，将返回该对象引用。

注：构造函数函数指的是新的关键字，如

新建ConstructorFunction（arg1，arg2）

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

这方面最困难的部分是第2点。每个对象（包括函数）都有一个名为[[原型]].它可以只有在对象创建时设置，可以使用新的，使用对象.创建，或基于文本（函数默认为功能.原型，数字到编号.原型等）。它只能与一起阅读Object.getPrototypeOf（someObject）。有不获取或设置此值的其他方法。

除了隐藏的[[原型]]属性，也有一个名为原型，您可以通过访问和修改来为所创建的对象提供继承的属性和方法。

---

下面是一个示例：

ObjMaker=function（）{this.a='first'；}；//“ObjMaker”只是一个函数，没有什么特别的//这使它成为一个构造函数。ObjMaker.prototype.b=“第二个”；//与所有函数一样，ObjMaker有一个可访问的“prototype”属性//我们可以改变。我刚刚在其中添加了一个名为“b”的属性。例如//所有对象，ObjMaker还有一个无法访问的`[[prototype]]`属性//我们无能为力obj1=新的ObjMaker（）；//刚刚发生了3件事。//创建了一个名为“obj1”的新空对象。起初`obj1`//只是{}。然后将`obj1`的`[[prototype]]`属性设置为当前//`ObjMaker.prototype`的对象值//分配了一个新的对象值，`obj1`的`[[prototype]]`不会更改，但您//可以更改“ObjMaker.prototype”的属性以将//`prototype`和`[[prototype]]`）。已执行“ObjMaker”函数//`obj1`代替`this`。。。因此“obj1.a”被设置为“first”。目标1.a；//返回“第一个”对象1.b；//“obj1”没有名为“b”的属性，因此JavaScript会进行检查//它是`[[原型]]`。其`[[prototype]]`与`ObjMaker.prototype相同`//“ObjMaker.prototype”的属性名为“b”，值为“second”//返回“秒”

这就像类继承一样，因为现在，您使用新建ObjMaker（）似乎也继承了“b”属性。

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

SubObjMaker=函数（）{}；SubObjMaker.prototype=新ObjMaker（）；//注意：此模式已弃用！//因为我们使用了“new”，SubObjMaker.prototype的[[prototype]]属性//现在设置为ObjMaker.prototype的对象值。//现代的方法是使用Object.create（），它是在ECMAScript 5中添加的：//SubObjMaker.prototype=Object.create（ObjMaker.trototype）；SubObjMaker.prototype.c=“第三个”；obj2=新的SubObjMaker（）；//obj2的[[prototype]]属性现在设置为SubObjMaker.prototype//请记住，SubObjMaker.prototype的[[prototype]]属性//是ObjMaker.prototype。现在obj2有了一个原型链！//obj2-->SubObjMaker.prototype--->对象生成原型目标2.c；//从SubObjMaker.prototype返回“第三个”对象2.b；//从ObjMaker.prototype返回“second”目标2.a；//从SubObjMaker.prototype返回“first”，因为SubObjMaker.proptotype//是使用ObjMaker函数创建的，该函数为我们分配了

---

我读了很多关于这个主题的垃圾，最后才发现本页，用漂亮的图表很好地解释了这一点。

Answer 2

假设您具有此功能：

var Foo=函数（）{这个。A=1；这个。B=2；};

如果将其作为独立函数调用，如下所示：

Foo（）；

执行此函数将向窗口对象(A类和B类). 它将其添加到窗口因为窗口是这样执行时调用函数的对象，并且这函数中是调用函数的对象。至少在JavaScript中。

现在，这样称呼它新的:

var bar=新Foo（）；

当您添加新的对于函数调用，将创建一个新对象（只需var bar=新对象（）)和这函数内指向新对象您只是创建了，而不是调用函数的对象。所以酒吧现在是具有属性的对象A类和B类.任何函数都可以是构造函数；这并不总是有意义的。

Answer 3

除了丹尼尔·霍华德的回答，这是什么新的会（或至少看起来会）：

函数新建（func）{var res=｛｝；if（函数原型！==空）{res.__proto__=功能原型；}var ret=func.apply（res，Array.prototype.slice.call（arguments，1））；if（（typeof ret===“object”||typeof ret===”function“）&&ret！==null）{返回ret；}返回res；}

While期间

var obj=新（A，1，2）；

等于

var obj=新的A（1,2）；

Answer 4

让初学者更好地理解

在浏览器控制台中尝试以下代码。

函数Foo（）{返回此；}var a=Foo（）；//返回“window”对象var b=新Foo（）；//返回foo的空对象Window的一个实例；//真的Foo的一个实例；//False（错误）b Window实例；//False（错误）b Foo实例；//真的

现在您可以阅读社区wiki答案:)

Answer 5

所以这可能不是为了创造对象的实例

它正是为此而使用的。您可以这样定义函数构造函数：

职能人员（姓名）{this.name=名称；}var john=新人（“john”）；

然而，ECMAScript的额外好处是您可以使用.原型所以我们可以做一些像。。。

Person.prototype.getName=函数（）{return this.name；}

从这个构造函数创建的所有对象现在都有一个获取名称因为他们可以访问原型链。

Answer 6

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

Answer 7

总结：

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

1. 创建新对象
2. 将此对象的原型设置为构造函数的原型属性
3. 绑定这关键字添加到新创建的对象并执行构造函数
4. 返回新创建的对象

例子：

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

具体发生了什么：

1. 康斯特小狗说：我们需要内存来声明变量。
2. 赋值运算符=表示：我们将使用=
3. 表达式是新狗（12）。JavaScript引擎会看到新的关键字，创建新对象并将原型设置为狗.原型
4. 构造函数用这值设置为新对象。在此步骤中，年龄被指定给新创建的小狗对象。
5. 新创建的对象将返回并分配给变量doggie。

Answer 8

请看一下我对案例III如下所示。这是关于当你有一个明确的返回函数中的语句新的起床。请看一下以下情况：

案例一:

var Foo=函数（）{这个。A=1；这个。B=2；};console.log（Foo（））//打印未定义console.log（window.A）//打印1

上面是调用变量指向的匿名函数的简单示例富。当您调用此函数时，它将返回未定义。由于没有任何显式返回语句，JavaScript解释器会强制插入返回未定义；语句。因此，上述代码示例相当于：

var Foo=函数（）{这个。A=1；这个。B=2；返回未定义；};console.log（Foo（））//打印未定义console.log（window.A）//打印1

什么时候？富函数被调用窗口是默认调用对象（上下文这)有了新的A类和B类属性。

案例二:

var Foo=函数（）{这个。A=1；这个。B=2；};var bar=新Foo（）；console.log（bar（））//非法不是指向函数而是指向对象控制台.log（bar.A）//打印1

这里是JavaScript解释器，可以看到新的关键字，创建作为调用对象的新对象（上下文这)匿名函数的富在这种情况下A类和B类成为新创建对象的属性（代替窗口对象）。由于没有任何显式返回语句，JavaScript解释器会强制插入一个返回语句，以返回由于使用新的关键字。

案例III:

var Foo=函数（）{这个。A=1；这个。B=2；返回{C:20，D:30}；};var bar=新Foo（）；控制台.log（bar.C）//打印20控制台.log（bar.A）//打印未定义。bar没有指向由于new关键字而创建的对象。

在这里，JavaScript解释器，看到新的关键字，创建作为调用对象的新对象（上下文这)匿名函数的富再一次，A类和B类成为新创建对象的属性。但这次您有一个显式返回语句，以便JavaScript解释器不自己做任何事。

要注意的事项案例III创建对象的原因是新的关键词从你的雷达中丢失了。酒吧实际上是指向一个完全不同的对象，该对象不是JavaScript解释器创建的对象，因为新的关键字。

引用David Flanagan的话JavaScript：最终指南（第6版），第4章，第62页：

计算对象创建表达式时，JavaScript首先创建一个新的空对象，就像对象创建的对象一样初始化器{}。接下来，它使用指定的参数，将新对象作为this的值传递关键字。然后，函数可以使用它来初始化属性新创建对象的。编写用作构造函数的函数不返回值，以及对象创建表达式的值是新创建和初始化的对象。如果构造函数这样做返回一个对象值，该值将成为对象的值创建表达式，则丢弃新创建的对象。

附加信息：

上述案例的代码段中使用的函数在JavaScript世界中具有特殊名称，如下所示：

案例#	姓名
案例一	构造函数函数
案例二	构造函数函数
案例III	工厂功能

您可以在中阅读构造函数函数和工厂函数之间的区别这个线程.

案例三中的气味代码-工厂功能应不与一起使用新的我在上面的代码片段中显示的关键字。我故意这么做只是为了解释这个概念。

Answer 9

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

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

Answer 10

这个新的关键字更改运行函数的上下文，并返回指向该上下文的指针。

当您不使用新的关键字，函数的上下文车辆（）runs是您从中调用车辆功能。这个这关键字将引用相同的上下文。当您使用新车（），将创建一个新上下文，以便关键字这函数内部引用新上下文。你得到的回报是新创建的上下文。

Answer 11

有时代码比文字更容易：

var func1=函数（x）{this.x=x；}//仅与“new”一起使用var函数2=函数（x）{var z={}；z.x=x；返回z；}//双向使用func1.prototype.y=11；函数2.prototype.y=12；A1=新函数1（1）；//有A1.x和A1.yA2=函数1（1）；//未定义（“此”指“窗口”）B1=新函数2（2）；//仅具有B1.xB2=函数2（2）；//只有B2.x

对我来说，只要我不原型化，我就使用func2的风格，因为它在函数内外都给了我更多的灵活性。

Answer 12

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

你们可以轻松检查：

常量a={name：“某物”}；console.log（a.prototype）；//'“undefined”，因为它不能直接访问常数b=函数（）{console.log（“somethin”）；};console.log（b.prototype）；//返回b{}

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

控制台.log（a.__proto__）；//返回{}控制台.log（b.__proto__）；//返回[函数]

你们可以在终端上轻松查看。那么什么是构造函数？

函数CreateObject（名称、年龄）{this.name=名称；this.age=年龄}

首先要注意五件事：

1. 使用调用构造函数时新的，调用函数的内部[[Construct]]方法来创建新的实例对象并分配内存。

2. 我们没有使用返回关键字。新的将处理它。

3. 函数名是大写的，因此当开发人员看到您的代码时，他们可以理解他们必须使用新的关键字。

4. 我们不使用箭头功能。因为这参数是在创建箭头函数时拾取的，即“窗口。箭头函数的范围是词汇上的，而不是动态的。这里的词汇表示本地。箭头函数带有其本地“this”值。

5. 与常规函数不同，不能使用new关键字调用箭头函数，因为它们没有[[Construct]]方法。箭头函数也不存在原型属性。

   const me=new CreateObject（“yilmaz”，“21”）

   新的调用该函数，然后创建一个空对象{}，然后添加值为“name”的“name”键，以及值为参数“age”的“age”键。

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

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

函数CreateObject（名称、年龄）{this.name=名称；this.age=年龄；const myJob=“开发人员”}

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

constme={name:“yilmaz”，age:21}//没有任何“myJob”键

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

CreateObject.prototype.myActions=函数（）{/*定义内容*/}

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

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

如果我创建

const a=新编号（5）；控制台.log（a）；//[编号：5]console.log（类型a）；//对象

使用创建的任何内容新的类型为对象。现在“a”可以访问存储在其中的所有方法编号.原型如果我定义

常数b=5；console.log（a===b）；//'假'

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

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

Answer 13

这个新的关键字用于创建新的对象实例。没错，JavaScript是一种动态编程语言，它支持面向对象的编程范式。关于对象命名的约定是：对于应该由新的关键字。

obj=新元素（）；

Answer 14

JavaScript不是面向对象程序设计（OOP）语言。因此仰望JavaScript中的进程使用委托过程也称为原型委托或原型继承。

如果试图从没有的对象中获取属性的值，JavaScript引擎会查找对象的原型（及其原型，一次一步）。它是原型链，直到链结束无效的哪个是Object.protype==空（标准对象原型）。

此时，如果未定义属性或方法，则未定义返回。

重要！功能包括都是一流的东西.

函数=函数+对象组合

FunctionName.prototype={共享子对象}

{//其他属性原型：{//自动获取[[原型]]链接的共享空间当“new”关键字用于创建“Constructor”实例时功能“}}

因此新的关键字，一些手动完成的任务，例如。，

1. 手动创建对象，例如newObj。
2. 使用创建隐藏债券原型（又名：扣篮原型)在JavaScript规范中[[原型]]（即。，原型)
3. 引用并将属性指定给新建对象
4. 返回新建对象对象。

所有操作都是手动完成的。

函数CreateObj（值1，值2）{const newObj=｛｝；newObj.properties 1=值1；newObj.property2=值2；return newObj；}var obj=创建对象（10,20）；obj.__proto__===对象原型；//真的Object.getPrototypeOf（obj）===对象原型//真

JavaScript关键字新的有助于实现此过程的自动化：

1. 创建一个新的对象文字，标识为此：{}
2. 引用并将属性指定给这
3. 隐性债券创建[[原型]]（即。原型)到功能.原型共享空间。
4. 隐式回报这对象{}

函数CreateObj（值1，值2）{this.property1=值1；this.property2=值2；}var obj=新CreateObj（10,20）；obj.__proto__===创建对象原型//真Object.getPrototypeOf（obj）==CreateObj.prototype//真

调用不带新关键字的构造函数：

=>this:窗口

函数CreateObj（值1，值2）{var isWindowObj=this===窗口；console.log（“正在指向窗口对象”，isWindowObj）；this.property1=值1；this.property2=值2；}var obj=新CreateObj（10,20）；//指向窗口对象为falsevar obj=创建对象（10,20）；//指向窗口对象为true窗口属性1；//10窗口属性2；//20

Answer 15

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

var Foo=函数（）{}；Foo.prototype.bar=“bar”；var foo=新foo（）；foo的foo实例；//真的

实例继承自原型构造函数的。所以根据上面的例子。。。

foo.bar；//'巴'

Answer 16

嗯，JavaScript本身可能因平台而异，因为它始终是原始规范的实现ECMA脚本（ES）。

无论如何，与实现无关，所有遵循ECMAScript规范的JavaScript实现都将为您提供一种面向对象的语言。根据ES标准：

ECMAScript是一种面向对象的编程语言，用于执行计算和操作计算对象在主机环境中。

现在我们已经同意JavaScript是ECMAScript的实现，因此它是一种面向对象的语言。定义新的在任何面向对象语言中的操作都表示这样一个关键字用于从特定类型的类（包括匿名类型，如C#）创建对象实例。

在ECMAScript中，我们不使用类，正如您可以从规范中看到的那样：

ECMAScript不使用C++、Smalltalk或Java中的类。相反，可以通过多种方式创建对象，包括通过文字符号或via构造函数，它创建对象，然后执行代码，通过指定初始值来初始化全部或部分对象值设置为其属性。每个构造函数都是一个具有名为―的属性prototype‖，用于实现基于原型的继承和共享属性。对象由创建在新表达式中使用构造函数；例如，newDate（2009,11）创建一个新的Date对象。调用构造函数不使用new的结果取决于构造函数。例如，Date（）生成当前日期和时间，而不是对象。

Answer 17

它有三个阶段：

1.创建：它创建一个新对象，并将该对象的[[prototype]]属性设置为构造函数的prototype属性。

2.执行：它指向新创建的对象并执行构造函数。

3.退货：在正常情况下，它将返回新创建的对象。但是，如果显式返回非空对象或函数，则返回此值。值得一提的是，如果返回非空值，但它不是对象（例如Symbol value，undefined，NaN），则忽略该值，并返回新创建的对象。

函数myNew（构造函数，…args）{常量对象={}Object.setPrototypeOf（obj，constructor.prototype）const returnedVal=构造函数.apply（obj，args）如果(returnedVal===“函数”的类型||（returnedVal的类型===“对象”&&returnedVal！==空）{返回returnedVal}返回对象}

有关的更多信息和测试my新建，您可以阅读我的博客：https://medial.com/@洋红2127/how-does-the-new-operator-work-f7eaac692026

Answer 18

这个问题已经回答了很多次了，但我只是想分享我的经验。在javascript中新的关键字创建类的对象。在javascript中，您可以使用一个称为类函数的函数来创建类。

函数MyClass（）{this.name=“卡兹！”this.init=（）=>{console.log（'I am init func'）} }

现在你可以调用上面的类函数，它的函数如下。

let obj=新MyClass（）对象初始化（）控制台.log（对象名称）。//打印“Kazi！”