什么是原型
JavaScript 中,万物皆对象!但对象也是有区别的。分为普通对象和函数对象,Object ,Function 是JS自带的函数对象。每个对象都有原型(null和undefined除外),你可以把它理解为对象的默认属性和方法。
console.log(Object.prototype);
//Object{}
var o = new Object();
console.log(o.prototype); //undefined
console.log(Array.prototype);
//[Symbol(Symbol.unscopables): Object]
console.log(Function.prototype);
//function(){}
function hello(){
console.log("hello");
}
hello.prototype = "hello world";
console.log(hello.prototype);
//hello world
Object:Object是一个函数对象,Object的原型就是一个Object对象,它里面存在着一些对象的方法和属性,例如最常见的toString方法。
新建对象:用new Object或者{}建的对象是普通对象,它没有prototype属性,只有__proto__属性,它指向Object.prototype。
Array:Array也是一个函数对象,它的原型就是Array.prototype,它里面存在着一些数组的方法和属性,例如常见的push,pop等方法。
Function:Function也是一个函数对象,但它有点特殊,它的原型就是一个function空函数。
自定义函数:它的原型就是你给它指定的那个东西。如果你不指定,那它的原型就是一个Object.prototype。
什么是原型链
在JavaScript 中,每个对象都有一个指向它的原型(prototype)对象的内部链接。这个原型对象又有自己的原型,直到某个对象的原型为 null 为止(也就是不再有原型指向),组成这条链的最后一环。这种一级一级的链结构就称为原型链(prototype chain)。
JavaScript 对象是动态的属性“包”(指其自己的属性)。JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时,它不仅仅在该对象上搜寻,还会搜寻该对象的原型,以及该对象的原型的原型,依此层层向上搜索,直到找到一个名字匹配的属性或到达原型链的末尾。
当你用new Object或者直接定义一个对象时,它的原型链就是:
o ==》 Object.prototype ==》 null
但你访问o上没有的属性或方法时,JS会往Object.prototype上寻找该属性和方法。如果有则直接返回,如果没有,方法则报错,这个方法未定义,属性则返回undefined。
你用构造函数(构造函数我们一般首字母大写)建立一个对象时,它的原型链就是:
tsrot ==》 Person.prototype ==》 Object.prototype ==》 null
如果没有定义Person.prototype这一环,则直接跳到下一环。
当你需要父类的属性和方法时,你可以把它的原型指向父类的原型。此时的原型链就是:
child ==》 Parent.prototype ==》 Object.prototype ==》 null
数组也是一个对象,不过它是由Array构造函数new而来的,所以它的原型链就是:
arr ==》 Array.prototype ==》 Object.prototype ==》 null
fun是一个函数对象,它是由Function构造函数new而来的,所以它的原型链就是:
fun ==》 Function.prototype ==》 Object.prototype ==》 null
prototype与__proto__
JS在创建对象(不论是普通对象还是函数对象)的时候,都有一个叫做__proto__的内置属性,用于指向创建它的函数对象的原型对象prototype。
普通对象的__proto__
var o = {name:"tsrot"};
console.log(o.__proto__);
//Object{}
console.log(o.prototype);
//undefined
console.log(o.__proto__ === Object.prototype);
//true
构造对象的__proto__
function Parent(){
this.name = "i am parent";
}
Parent.prototype = {age:24};
function Child(){
this.name = "i am child";
}
Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child;
var child = new Child();
console.log(child.__proto__); //Object{}
console.log(Child.prototype); //Object{}
console.log(child.__proto__ === Child.prototype);
//true
console.log(Parent.prototype.__proto__ ===
Object.prototype); //true
数组的__proto__
var arr = [1,2,3];
console.log(arr.__proto__);
//[Symbol(Symbol.unscopables): Object]
console.log(Array.prototype);
//[Symbol(Symbol.unscopables): Object]
console.log(arr.__proto__ === Array.prototype); //true
函数的__proto__
var fun = function(){
var hello = "i am function"
}
fun.prototype = {name:"tsrot"};
console.log(fun.prototype);
//Object {name: "tsrot"}
console.log(fun.__proto__);
//function(){}
console.log(fun.prototype === fun.__proto__);
//false
console.log(fun.__proto__ === Function.prototype);
//true
new
JavaScript中 new 操作符可以通过构造函数创建对象。
var obj = {};
var arr = [];
// 其实这只是JavaScript中创建对象的语法糖,本质上为
var obj = new Object();
var arr = new Array();
new Object()分为三步
- 创建一个空对象 {};
- 将空对象的 proto 原型对象 指向 Object.prototype;
- 将Object构造函数的this指向当前空对象
var obj;
创建空对象:{};
{}.__proto__ = Object.prototype;
Object.call({});
obj = {};
this
this指向当前调用该方法最近的对象
function f(){
console.log(this)
}
f() // window
构造函数
this指向被构造函数创建的实例对象。
构造函数通常不会手动设置返回值,这样在调用构造函数时会默认返回一个this引用的实例对象,如果手动设置了返回值且该返回值不是一个对象时会返回this。
function O(){
this.f = function(){
console.log(this);
}
}
var obj = new O();
obj.f() // obj
call apply
当一个函数通过call/apply调用时,该函数的this指向call/apply的第一个参数对象, 如果第一个参数不是对象,JS会尝试将其转换成对象并指向它。
function func(){
console.log(this.a + this.b)
}
var obj = {a:1, b:2};
func.call(obj); // 3
function printThis() {
console.log(this);
}
printThis.call(1); // Number {[[PrimitiveValue]]: 1}
printThis.call('str'); // String {0: "s", 1: "t", 2: "r", length: 3, [[PrimitiveValue]]: "str"}