JavaScript中的新关键字在第一次遇到时可能会非常令人困惑,因为人们倾向于认为JavaScript不是一种面向对象的编程语言。
这是怎么一回事?它解决了什么问题?什么时候合适,什么时候不合适?
JavaScript中的新关键字在第一次遇到时可能会非常令人困惑,因为人们倾向于认为JavaScript不是一种面向对象的编程语言。
这是怎么一回事?它解决了什么问题?什么时候合适,什么时候不合适?
当前回答
JavaScript不是面向对象编程(OOP)语言。因此,JavaScript中的查找过程使用委托过程,也称为原型委托或原型继承。
如果您试图从一个没有的对象中获取属性的值,JavaScript引擎会查找该对象的原型(以及它的原型,一步一步)。它是原型链,直到链结束为null,即Object.prototype==null(标准对象原型)。
此时,如果未定义属性或方法,则返回undefined。
重要的函数是一类对象。
函数=函数+对象组合框
FunctionName.prototype={共享子对象}
{
// other properties
prototype: {
// shared space which automatically gets [[prototype]] linkage
when "new" keyword is used on creating instance of "Constructor
Function"
}
}
因此,使用新关键字。,
手动创建对象,例如newObj。使用JavaScript规范[[prototype]](即proto)中的proto(AKA:dunderproto)创建隐藏键引用并将财产分配给newObj返回newObj对象。
所有操作都是手动完成的。
function CreateObj(value1, value2) {
const newObj = {};
newObj.property1 = value1;
newObj.property2 = value2;
return newObj;
}
var obj = CreateObj(10,20);
obj.__proto__ === Object.prototype; // true
Object.getPrototypeOf(obj) === Object.prototype // true
JavaScript关键字new有助于自动化此过程:
创建了一个新的对象文本,其标识如下:{}引用并为此分配财产隐藏键创建[[prototype]](即proto)到Function.prototype共享空间。此对象{}的隐式返回
function CreateObj(value1, value2) {
this.property1 = value1;
this.property2 = value2;
}
var obj = new CreateObj(10,20);
obj.__proto__ === CreateObj.prototype // true
Object.getPrototypeOf(obj) == CreateObj.prototype // true
调用不带new关键字的构造函数:
=>此:窗口
function CreateObj(value1, value2) {
var isWindowObj = this === window;
console.log("Is Pointing to Window Object", isWindowObj);
this.property1 = value1;
this.property2 = value2;
}
var obj = new CreateObj(10,20); // Is Pointing to Window Object false
var obj = CreateObj(10,20); // Is Pointing to Window Object true
window.property1; // 10
window.property2; // 20
其他回答
new关键字用于创建新的对象实例。是的,JavaScript是一种动态编程语言,它支持面向对象的编程范式。关于对象命名的约定是:对于应该由new关键字实例化的对象,始终使用大写字母。
obj = new Element();
除了丹尼尔·霍华德的回答之外,以下是new的作用(或者至少看起来是这样):
function New(func) {
var res = {};
if (func.prototype !== null) {
res.__proto__ = func.prototype;
}
var ret = func.apply(res, Array.prototype.slice.call(arguments, 1));
if ((typeof ret === "object" || typeof ret === "function") && ret !== null) {
return ret;
}
return res;
}
虽然
var obj = New(A, 1, 2);
相当于
var obj = new A(1, 2);
每个函数都有一个原型对象,该对象自动设置为使用该函数创建的对象的原型。
你们可以轻松检查:
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中的所有方法。
当您想要创建多个具有相同财产和方法的类似对象时,构造函数非常有用。这样,您就不会分配额外的内存,因此代码将更高效地运行。
假设您有此函数:
var Foo = function(){
this.A = 1;
this.B = 2;
};
如果将其作为独立函数调用,如下所示:
Foo();
执行此函数将向窗口对象(A和B)添加两个财产。它将其添加到窗口中,因为当您这样执行函数时,window是调用函数的对象,而函数中的this是调用该函数的对象。至少在JavaScript中。
现在,用新的:
var bar = new Foo();
当您向函数调用添加新对象时,将创建一个新对象(仅var bar=new object()),并且函数中的this指向您刚刚创建的新对象,而不是调用函数的对象。所以bar现在是一个具有财产A和B的对象。任何函数都可以是构造函数;这并不总是有意义的。
JavaScript不是面向对象编程(OOP)语言。因此,JavaScript中的查找过程使用委托过程,也称为原型委托或原型继承。
如果您试图从一个没有的对象中获取属性的值,JavaScript引擎会查找该对象的原型(以及它的原型,一步一步)。它是原型链,直到链结束为null,即Object.prototype==null(标准对象原型)。
此时,如果未定义属性或方法,则返回undefined。
重要的函数是一类对象。
函数=函数+对象组合框
FunctionName.prototype={共享子对象}
{
// other properties
prototype: {
// shared space which automatically gets [[prototype]] linkage
when "new" keyword is used on creating instance of "Constructor
Function"
}
}
因此,使用新关键字。,
手动创建对象,例如newObj。使用JavaScript规范[[prototype]](即proto)中的proto(AKA:dunderproto)创建隐藏键引用并将财产分配给newObj返回newObj对象。
所有操作都是手动完成的。
function CreateObj(value1, value2) {
const newObj = {};
newObj.property1 = value1;
newObj.property2 = value2;
return newObj;
}
var obj = CreateObj(10,20);
obj.__proto__ === Object.prototype; // true
Object.getPrototypeOf(obj) === Object.prototype // true
JavaScript关键字new有助于自动化此过程:
创建了一个新的对象文本,其标识如下:{}引用并为此分配财产隐藏键创建[[prototype]](即proto)到Function.prototype共享空间。此对象{}的隐式返回
function CreateObj(value1, value2) {
this.property1 = value1;
this.property2 = value2;
}
var obj = new CreateObj(10,20);
obj.__proto__ === CreateObj.prototype // true
Object.getPrototypeOf(obj) == CreateObj.prototype // true
调用不带new关键字的构造函数:
=>此:窗口
function CreateObj(value1, value2) {
var isWindowObj = this === window;
console.log("Is Pointing to Window Object", isWindowObj);
this.property1 = value1;
this.property2 = value2;
}
var obj = new CreateObj(10,20); // Is Pointing to Window Object false
var obj = CreateObj(10,20); // Is Pointing to Window Object true
window.property1; // 10
window.property2; // 20