原型

原型

1.定义：原型是function对象的一个属性，它定义了构造函数制造出的对象的公共祖先。通过该构造函数产生的对象，可以继承该原型的属性和方法。原型也是对象。

Person.prototype --原型
Person.prototype = {} 是祖先
Person.prototype.name = "Deng";
function Person() {

}
var person = new Person();
var person1 = new Person();

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', 'prof.ji');
var car1 = new Car('green', 'laodeng');
通过后代例如car是不能改变原型的属性
car如果没有某个属性 会去祖先里找

• 写法也可以聚在一起写
  Car.prototype = {
  height : 1400,
  lang : 4900,
  carName : 'BMW'
  }

car.constructor 构造器的意思
=> function Car () {
}
如果 Car.prototype = {
constructor : person
} 那么就会改变构造器的值

Person.prototype.name = 'abc';
function  Person() {
//  var this = {
// 
// __proto__:Person.prototype
//}
var obj = {
    name:'sunny'
}
var person = new Person ();
person.__proto__ = obj;
 
proto是指向对象原型的，会去原型里找 ，但是这
里把原型改了，指向了obj.

Person.prototype.name = 'sunny';
function  Person() {
/ var this = { __proto__:Person.prototype}
}
var person = new Person();
1)如果加上这句Person.prototype.name = 'cherry'
这里只是相当于把房间里的内容改了,最后person.name='cherry'
2)如果Person.prototype = {name:'cherry'}，这里
想让于加了个房间 换了个人  所以 person.name = 'sunny' 
/以上两种情况仅限于仅限于在 new执行之后
3）
function  Person() {
/  var this = { __proto__:Person.prototype}
}
Person.prototype.name = 'sunny';
Person.prototype = {
         name : 'cherry‘
}
var person = new Person();
这种情况是new没生成之前下面的把上面覆盖了 所
以最后person.name = 'cherry'.

• 构造函数只要new执行 ，必默认生成var this = {__proto __ :函数名.prototype}
• 绝大多数对象的最终都会继承自Object.prototype

Grand.prototype.__proto__ = Object.prototype
 Object.prototype.__proto__ = null
Grand.prototype.lastName = 'Deng';
function  Grand() {
}
var   grand = new Grand();
Father.prototype = grand;
function Father() {
        this.name = 'xuming';
        this.forture = {
            card : 'visa'
        };
        this.num = 100;
}
var  father =    new Father();

Son.prototype = father;
function Son() {
          this.hobbit = "smoke";
}
var  son = new Son();
eg: son.forture = 200 father无影响
  son.forture.card1 = "master"  father 自动加上了

son.num ++(=son.num+1); return100
father.num = 100 
son.num = 101

Person.prototype = {
       name : "a",
       sayName : function () {
             console.log(this.name);
     }
}
function  Person() {
         this.name = "b"
}
var person = new Person();
sayName里面的this指向谁，谁调用的方法，this就是谁
person.sayName()   => b
Person.prototype.sayName()  =>a

var obj = {}; 相当于 系统内部自动 new Object();

- var  obj = Object.create(原型); 

var  obj = {name : "sunny", age :123}；
var   obj1 = Object.create(obj);
所以obj1的原型就是obj  obj1.name = 'sunny'

Person.prototype.name = "sunny";
function  Person() {
          
}
var person = Object.create(Person.prototype);

Object.create( );里面只能是 object or null
undefined.to string() null.to string()是报错的 不存在的

var num = 123;
//num.toString(); --> new Number (num).toString();
Number.prototype.toString = function () {
}这种方法叫重写 实现同名但不同功能的东西，number里有tostring这个功能 就不会去上级object里面去找了
//Number.prototype._proto _ = Object.prototype
// Object.prototype.toString = function(){
}

eg：
// Object.prototype.toString = function(){
// } 系统自带的方法
Person.prototype = {
toString : function () {
return 'hehe';
}
}
function Person() {

}
var person = new Person ():

Object.prototype.toString.call(123)
"[object Number]"
Object.prototype.toString.call(true)
"[object Boolean]"返回的是类型

var obj = Object.create(null);
obj.toString = function () {
    return "老邓身体好";
}
document.write(obj);
隐式的调用toString方法  如果不是人为的加上
obj.toString = function () {
    return "老邓身体好";
} 就会报错

Math.ceil(123.234) -->124
Math.floor(123.234) -->123
Math.random( ) 产生一个0~1之间的随机数

for(var i = 0; i<10; i++){
     var num = Math.floor(Math.random() * 100)
      console.log(num);
}随机一个数取0~100