关于面向对象

一、构造函数--扩展
           // function Person() {
        //     this.name="zs"
        //     this.say=function(){
        //         alert("I am"+this.name)
        //     }
        // }
        // var p1=new Person()
        // p1.say()

2.  // function Person() {
        //     this.name=name
        //     this.say=function(){
        //         alert("I am"+this.name)
        //     }
        // }
        // var p1=new Person("ls")
        // p1.say()
3.构造函数与普通函数区别
[1]构造函数的名字最好是大写字母开头
[2]构造函数没有return语句
***[3]构造函数创建实例必须用new
4.constructor
p1\p2是person对象的不同实例
每个实例都有constructor属性,这个属性指向对象本身 
  var p1=new Person("ls",22)
  console.log(p1.constructor);
  var p2=new Person("ww",22)
  console.log(p2.constructor);
5.构造函数的问题
构造函数中的每一个方法都要在每一个实例上重新创建一遍,浪费内存空间
console.log(p1.say==p2.say); //false

二.原型方式创建 --扩建

1.每个函数都有一个prototype（原型属性），
  该属性是一个指针指向一个对象，
  对象中可包含所有实例共享的属性和方法                      
    function Person(){
            Person.Prototype.name="张三"
            Person.Prototype.say=function(){
                alert("I am "+this.name)
            }
    }
    //创建实例

    var p1=new Person()
    var p2=new Person()
    // console.log(p1.name)
    // p1.say()
    // console.log(p1.say==p2.say) //true

    console.log(p1.name); //张三
    console.log(p2.name); //张三
    p2.name="李四"
    console.log(p1.name); //张三  name来自于原型的属性
    console.log(p2.name); //李四  name来自于实例的属性

2.hasOwnProperty():原型方法 检测一个属性是在实例中还是原型中
                    实例中返回true
                    原型中返回false
    console.log(p1.hasOwnProperty("name")) //false
    console.log(p2.hasOwnProperty("name")) //true

3. in 操作符: 只要通过对象能够访问到的属性,就返回true
    console.log("name" in p1) //true
    console.log("name" in p2) //true

    创建函数:判断是否为原型属性
    hasPrototypeProperty(p1,"name") --false

4.p2.name="ls"
  delete p2.name
  p2.name   //zs

5.Object.keys()  :返回对象定义的属性和方法
                  官方:列举出所有可枚举(可用for in遍历)
                  的属性和方法

  Object.getOwnPropertyNames():无论是否为可枚举类型都会列出

  Object.keys(Person.Prototype)
  Object.getOwnPropertyNames(Person.Prototype)

6.优化原型写法
   function Person(){
            Person.Prototype.name="张三"
            Person.Prototype.say=function(){
                alert("I am "+this.name)
            }
    }
    优化
    
function Person() {}
    Person.Prototype.name="张三"
            Person.Prototype.say=function(){
                alert("I am "+this.name)
}
优化

function Person() {}
    Person.Prototype={
        name:"张三",
        say:function(){
                alert("I am "+this.name)
    }
}

7.原型的问题
(1)原型模式省略了构造函数传递参数的环节
  所以所有的实列默认情况下都会区的相同的属性值
function Person() {}
    Person.Prototype={
        name:"张三",
        say:function(){
                alert("I am "+this.name)
    }
}
var p1=new Person()
 p1.name
 p1.say()
 var p2=new Person()
 p2.name
 p2.say()

(2)原型属性被实列共享,如对引用类型属性修改
   所有事列都会看到,可能会出现问题
   function Person(){}
    Person.prototype={
            constructor:Person,   //默认指向object，我需要重新指向
            name:"zs",
            friends:["lkf","ly","lyg"],
            say:function(){
            alert("I am "+this.name)
            }
    }
    var p1=new Person()
    p1.friends.push("wee")
    console.log(p1.friends)
    var p2=new Person()
    console.log(p2.friends)

三、组合构造函数模式与原型模式