JS原型、原型链

目录

原型

原型链

---

原型

原型：
1.定义：原型是function对象的一个属性，它定义了构造函数制造出的对象的公共祖先。通过该构造函数产生的对象，可以继承该原型的属性和方法。原型也是对象。
2.利用原型特点和概念，可以提供共有属性。
3.对象如何查看原型-->隐式属性__proto__
4.对象如何查看对象的构造函数-->constructor

原型是在构造函数时就生成的，刚开始原型为空值

function Person() {

}
var person = new Person();
var person1 = new Person();
构造函数必须是大驼峰式命名
Person.prototype --原型
Person.prototype = {} 是祖先
    Person.prototype.name = "";
    function Person() {

    }
    var person = new Person();
    var person1 = new Person();       person和person1都可访问name属性
    当在控制台查看时，只有输入Person.name才能查看到属性，所以说定义了构造函数祖先
    如果构造函数中有声明对象，那就取构造函数中的属性值，如果没有再向祖先找

Car.prototype.height = 1400;
Car.prototype.lang = 4900;
Car.prototype.carName = 'BMW';
function Car(color, owner) {
    this.owner = owner;
    this.color = color;
}
var car = new Car('red','jjj')
可以把共有的东西放到原型里，可以继承
Car.prototype = {
    height = ;
    lang = ;
    carName = ;
}
这样写原型也是可以的

原型的增删改查：
    Person.prototype.lastName = "Deng";
    function Person(name) {
        this.name = name;
    }
    var person = new Person('xuming');
    想要修改lastName必须通过原型来修改，Person.prototype.lastName = ""来修改
    如果直接在构造函数Person.lastName来修改，只是在构造函数中增加一个lastName属性
    通过对象来修改原型属性是不可能的

    删除：原型不能删除,但是在控制台是可以执行删除的，它会在构造函数的对象中找

constructor：
constructor是系统自带的属性
    function Car() {

    }
    var car = new Car();
    当car想查找自己被那个构造函数构造出来的时候可以使用
    car.constructor
    系统返回值：function Car() {

    }
    
    car.constructor可以手动更改
        function Person() {

        }
        car.prototype = {
            constructor = Person;
        }
        function Car() {

        }
        var car = new Car();
    在查看car.constructor时系统显示
    function Person() {
        
    }

隐式属性__proto__：里面放原型
    Person.prototype.name = 'abc';
    function Person() {
        //var this = {
        //  __proto__:Person.prototype
        //}
    }
    var obj = {
        name : 'sunny'
    }
    var person = new Person();
    每个对象都有一个proto属性指向原型，可以被修改
        person.__proto__ = obj;

原型链

原型链：
    如何构造原型链
    原型链上属性的增删改查
    绝大多数对象的最终都会继承自Object.prototype
    Object.create(原型)

Grand.prototype.lastName = "Deng"
function Grand() {

}
var grand = new Grand();
Fater.prototype = grand;
function Fater() {
    this.name = 'xuming';
}
var father = new Fater();
Son.prototype = father;
function Son() {
    this.hobbit = 'smoke';
}
var son = new Son();
查找Son中的属性时，会依次向上查找，这就是原型链
增删改查：都是只有本人可以增删改查，子原型无法更改

Object.create也可以创建对象
    //var obj = Object.create(原型)
    var obj = {name:'a'};
    var obj1 = Object.create(obj);

判断：所有的对象都会最终继承自Object,prototype
错，不是所有的对象都是继承与它，比如Object.create
利用Object.create（）构造出的对象没有原型

JavaScript会存在精度不准的情况，小数*整数=会存在精度不准
    0.14*100=14.0000000002
可正常计算的范围：小数点前16位到小数点后16位

Math.ceil():向上取整
Math.floor():向下取整
    Math.ceil(123.123)  -->124
    Math.floor(123.999) -->123
Math.random():取随机数

call/apply
    作用，改变this指向
    区别，后面传的参数形式不同
任何一个方法都可以.call
    function test(){}
    //test() == test.call

    function Person(name,age) {
        //this == obj
        this.name = name;
        this.age = age;
    }
    var person = new Person('deng',100)
    var obj = {

    }
    Person.call(obj,'cheng',300);
call(),第一个参数会改变this指向，后面的参数以实参的形式传入,但后面传入的参数会以第一个参数代替this

call实际应用：
一：
    function Person(name,age,sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    function Student(name,age,sex,tel,grade) {
        //var this = {name:"",age:"",sex:""}
        Person.call(this,name,age,sex);
        this.tel = tel;
        this.grade = grade;
    }
    var student = new Student('sunny',123,'male',139,2020);

二：
    function Wheel(wheelSize,style) {
        this.style = style;
        this.wheelSize = wheelSize;
    }
    function Sit(c,sitColor) {
        this.c = c;
        this.sitColor = sitColor;
    }
    function Model(height,width,len) {
        this.height = height;
        this.width = width;
        this.len = len;
    }
    function Car(wheelSize,style,c,sitColor,height,width,len) {
        Wheel.call(this,wheelSize,style);
        Sit.call(this,c,sitColor);
        Model.call(this,height,width,len);
    }
    var car = new Car(100,'sdf,'真皮','red',1800,1900,4900);

apply:跟call作用基本一样，区别：传参列表不一样，apply后只能传一个数组
call需要把实参按照形参的个数传进去
apply需要传一个arguments
    function Wheel(wheelSize,style) {
        this.style = style;
        this.wheelSize = wheelSize;
    }
    function Sit(c,sitColor) {
        this.c = c;
        this.sitColor = sitColor;
    }
    function Model(height,width,len) {
        this.height = height;
        this.width = width;
        this.len = len;
    }
    function Car(wheelSize,style,c,sitColor,height,width,len) {
        Wheel.apply(this,[wheelSize,style]);
        Sit.apply(this,[c,sitColor]);
        Model.apply(this,[height,width,len]);
    }
    var car = new Car(100,'sdf,'真皮','red',1800,1900,4900);

eg:
    1.JavaScript的call和apply方法是做什么的，两者有什么区别?
    改变this指向，传参类型不同