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

Person.prototype.name="hhe";//---->祖先
        function Person(){
            
        }
        var person=new Person();
        var person1=new Person();

原型增删改查
Person.prototype.sadf="asdf";增
delete Person.prototype.sadf 删
Person.prototype.sadf="lllllll"; 改
Person.prototype.name; 查
person.name;查2

function Person{
                //var this={
                //先上自己找
                //再上proto里面找
                //__proto__: person.prototype
                // }

练习2

hh.prototype.name="wo";
            function hh(){
                //var this{
                    // __proto__=prototype
                // }
            }
            var j=new hh();//我在此处用访问的是wo
            hh.prototype={
                name:"kk"
            };

原型链

Grand.prototype.name="Yan";
            function Grand(){
                
            }
            var grand=new Grand();
            Father.prototype=grand;
            function Father(){
                this.name="xuming";
            }
            var father=new Father();
            Son.prototype=father;
            function Son(){
                this.hobbit="sadfsadf";
            }
            var son=new Son();

a.sayName()
sayName里面的this指向是,谁调用这个方法,this就会至指向谁

Person.prototype={
height=100
}
function Person(){
this.eat=function(){
this.height ++;
}
}
var person= new Person();

绝大多数对象的最终都会继承自
Object.protopyte
Object.cteate(原型)

Object.prototype.toString
Number.prototype.toString
Array.prototype.toString
Boolean.prototype.toString
String.prototype.toString
var obj =Object.create(null);
obj.String = function(){
return '哈哈哈';
}
document.write(obj);

注意

向上取整
Math.ceil(123.456); //124
向下取整
Math.floor(123.9999)//123
随机数 0-1
Math.random()
小鼠
for(var i=0;i<10;i++){
                var num=Math.floor(Math.random()*100);
                console.log(num)
            }

call调用就会立即执行和方法执行差不多

//如果不new的话this指向window
            function Person(name,age){
                //this==obj
                this.name=name;
                this.age=age;
            }
            var person=new Person("我的",12);
            var obj={}
            // 参数一是更改this的指向,后面的参数是实参
            //如果不传入参数的话他和执行一样
            Person.call(obj,"他的",1111);
            //test()---->test.call();

function Person(name,age){
                this.name=name;
                this.age=age;
            }
            function Student(name,age,qq){
                Person.call(this,name,age)//不可以是student因为执行的时候student还是未定义的
                this.qq=qq;
            }
            var student=new Student("小明",19,2213123123);

apply第一位也是传入对象更改this,他和call不一样的地方是他后面传入的是数组

function Person(name,age){
                this.name=name;
                this.age=age;
            }
            function Student(name,age,qq){
                Person.apply(this,[name,age]);
                this.qq=qq;
            }
            var student=new Student("小明",19,2213123123);

总结:
call需要把实参按照形参的个数传进去
apply需要传入一个arguments

其实就是改变this指向,不同之处就是传入参数不同