Probably the least understood part of JavaScript, standing beside the prototype chain.
So the question is: how does...
new dataObj(args);
...actually create an object, and define its prototype chain/constructors/etc?
Best is to show an alternative, to fully understand this keyword.
The new
operator uses the internal [[Construct]]
method, and it basically does the following:
[[Prototype]]
of this object, pointing to the Function prototype
property.
prototype
property is not an object (a primitive values, such as a Number, String, Boolean, Undefined or Null), Object.prototype
is used instead.this
value. An equivalent implementation of what the new
operator does, can be expressed like this (assuming that the ECMAScript 5 Object.create
method is available):
function NEW(f) {
var obj, ret, proto;
// Check if `f.prototype` is an object, not a primitive
proto = Object(f.prototype) === f.prototype ? f.prototype : Object.prototype;
// Create an object that inherits from `proto`
obj = Object.create(proto);
// Apply the function setting `obj` as the `this` value
ret = f.apply(obj, Array.prototype.slice.call(arguments, 1));
if (Object(ret) === ret) { // the result is an object?
return ret;
}
return obj;
}
// Example usage:
function Foo (arg) {
this.prop = arg;
}
Foo.prototype.inherited = 'baz';
var obj = NEW(Foo, 'bar');
obj.prop; // 'bar'
obj.inherited; // 'baz'
obj instanceof Foo // true
The expression new C(arg1, arg2)
:
Assuming C is a JavaScript function (otherwise you get an error):
prototype
" property of C
.
prototype
for a function is an object (automatically created when the function is declared) with its prototype set to Object.prototype
and a constructor
property pointing back to the function C
. C
with ' this
' set to the new object, and with the supplied arguments.C
returns an object, this object is the result of the expression. Otherwise the newly created object is the result of the expression. An alternative to new
in ECMAScript 5 would be to use the builtin Object.createObject
method.
new C(arg1, arg2)
would be equivalent to:
var obj = Object.createObject(C.prototype);
C.apply(obj, [arg1, arg2]);
Standard JavaScript does not allow you to explicitly set the prototype of an object, so Object.createObject
cannot be implemented in the language itself. Some implementations does allow it through the non-standard property __proto__. In that case, new C
can be simulated like this:
var obj = {};
obj.__proto__ = C.prototype;
C.apply(obj, [arg1, arg2]);
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.