原型链

理解 new 关键字的作用机制

理解 [[GET]]

对象有隐式原型，而函数有显示原型

隐式原型是指向显示原型的，然后一直递归下去，直到为null 就会返回undefined

new 关键字的作用机制

1.执行前

• 1.绑定this为空对象
• 2.让空对象[[Prototype]] –> 函数的 prototype属性
• 2.1 所有对象都有[[Prototype]] (__proto__)
• 2.2 所有的函数对象 –>prototype
• 3.正常执行函数
• 4.如果函数返回的基本类型，返回this的值，否则返回原函数的返回值

[[GET]]

如果要访问对象的属性，就需要用到一个隐式方法[[GET]]，会一直沿着原型链找，直到找到NULL的话，如果找不到这个属性的话会返回一个 undefined，而不会报错

1. 判断对象里面有没有
2. 判断它的__proto__指向的对象里面有没有

function foo(){
	console.log(1);
}

var a = new foo(); //返回值：this指向的对象的引用

console.log(a.b);  //undefined

原型链，共享方法和属性，节省内存开销

//阿里 四面
Object.prototype.a = function(){
    console.log("a");
}

Function.prototype.b = function(){
    console.log("b");
}

var F = function(){};

var f = new F();

f.a();  //a
f.b();  // 报错，没有b这个方法
F.a();  //a
F.b();   //b

静态方法和实例方法

function foo(){
    console.log(1);
}

//静态方法
foo.a = 1;  //这个是写在函数上面的，实例是拿不到的
var bar = new foo();
bar.a;  //undefined
//实例方法
foo.prototype.a = a;  //这个是写在构造函数的上的，实例是可以拿到的
var bar = new foo();
bar.a; //1

一些很奇怪的问题

//Object 和 Function

//关于{} 和 function(){}
//Object.prototype.__proto__   = null;  //不是所有对象都是 Object的实例
//Function.prototype.__prototype = Object.prototype;
//Object.__proto__  = Function.prototype  new Function
//Function.__proto__ = Function.prototype  new Function


//只要是对象就有 __proto__  ,只要是函数就有 prototype
//对象的隐式原型对象 指向 函数的显示原型对象
//函数的隐式原型对象  指向  函数的显示原型对象

原型链的引用

1. 面向对象编程 ->提高代码的可复用率 -> 更加合理的数据关系
2. 原型链的本质：对象的隐式原型和构造函数的显示原型的连接
3. 连接方式：new 关键字， 使用方式: [[GET]] 和 [[PUT]]

instanceof 的作用机制

var Studen = {
    age:12,
    name:"spider"
}

var s1 = new Student;

console.log(s1 instanceOf Object;)

作用：判断 s1 是不是 Object的一个实例

1. s1.__proto__ === Object.prototype
2. s1.proto.proto === Object.prototype
3. s1.proto = Student.prototype
4. s1.proto.proto = Student.prototype.proto = Object.prototype //true

手写一个 instanceOf

Object.myInstanceOf = funcrion(obj,fun){
    if(obj === null) return false; //找到了终点
    
    if(Object.getPrototypeOf(obj) === fun.prototype){
		return true;
    }else{
        return Object.myInstanceOf(Object.getPrototypeOf(obj),fun);
        //Object.getPrototypeOf(obj);  //返回obj的隐式原型
    }
}

数组和类数组

//数组
var a = [1,2,3];

a = {
    "0":1,
    "1":2,
    "2":3,
    "length":3,
    __proto:Array.prototype
}


//类数组
a = {
    "0":1,
    "1":2,
    "2":3,
    "length":3,
    __proto: XXX;   //这里是主要的区别，所以类数组拿不到数组的一些方法
    //不能通过 Array.prototype 拿到一些数组的方法
}

RHS(读) 和 LHS (写)

所有的程序都是一个状态机

状态机也就是数据的集合 -> RHS 读和 LHS 写

LHS RHS

[[PUT]] [[GET]]

修改一个对象的属性

[[PUT]] –> LHS

1.判断对象里面有没有属性

如果找到了

• 如果是基本类型： 覆盖
• 如果是引用类型：
  • 是对引用类型的引用 —> 覆盖
  • 对引用类型的访问 —> 修改

2.如果没有

• 沿着原型链找
• 如果没有找到，就一直找，直到原型链终点
• 如果终点都没有的话，就会自己创建一个