//直接創(chuàng)建
     //JS創(chuàng)建對象
     //1：創(chuàng)建空對象
         var person1 = new Object();
     //2:將該對象所需要的屬性、方法加進去
         person1.name ="ailer" ;
         console .log(person1.name);
         person1.gender = "male";
     //3:該對象添加的方法|(函數)
         person1. manager= function (){
           console .log("Ailer is my English name" );
        }
     //4:調用對象方法：對象.方法名();
         person1.manager();

     //函數|方法？函數屬于對象時，該函數屬于這個對象下的方法；通過方法名來調用該函數；
     //變量|屬性 ？當變量屬于某一個對象時候， 該變量就是這個對象下的方法。通過屬性名來調用變量。

      //增
         person1.age ="6" ;
      //改
         person1.name ="lemon" ;
      //查
         console .log(person1.name);
     //刪
         delete person1.age;
         console .log(person1.age);==> undefined

      //引用類型，存儲的是地址
      //基本類型：存儲的是值 標志位

     /*  var arr1 = [1,2,3,4]
        var arr2 = [5, 6, 7,9];
        var arr2 = arr1;//
        arr2[0]=10;//更改arr2里面的值，arr1也更改
        alert(arr1[0]);//====>10 引用類型*/

        var per2 = new Object();
        per2.name = "Relia";
        per2.age = "18";
        per2.gender = "femal";
        per2.hobby = "lemons";

         //1:通過.(點語法)訪問屬性
         //2:通過[](方括號)訪問對象的屬性;方括號中必須是屬性字符串或保存屬性字符串的變量|遍歷屬性的時候才使用方括號
         var n = "name"
         //console.log(per2["name"]);//雙引號

         console .log(per2[n]);
         for ( var property in per2) {
//          console.log(per2[property]);
         }

//定義構造函數      
 function createPerson ( name, age) {
//創(chuàng)建一個新的空對象
           var person = new Object;
//添加屬性|方法
           person.name = name;
           person.age = age;
           person. manager = function() {
              console .log("ai" );
           }
//返回
           return person;
        }

         var per1 = createPerson( "ailer", 12 );
         console .log(per1.name);

        var per2 = createPerson( "lemon", 23 );
        console .log(per2.age);
        console.log(per2 instanceof Object);//true
        console.log(per2 instanceof createPerson);//false//無法區(qū)分該對象類型
        console.log(per2.manager==per1.manager);//false 可得出per1和per2各自開閉空間

//字面量創(chuàng)建的對象使用constructor屬性不會指向實例，而是指向object
 //使用字面量創(chuàng)建
       var per1 = {
        name:"Ailer",
         constructor:per1,
        age:12,
        gender:"female",
        hobby:"play",
        eat:function(){
          console.log(this.name);
        }
       }
       per1.eat();//ailer
       per1.name="lemon";
       per1.eat();//lemon
       console.log(typeof per1);//Object
       console.log(per1.constructor==Object);//true

//構造函數創(chuàng)建對象，其子對象用instanceof不識別，所有采用new+obj創(chuàng)建
        //對象識別了，但是仍然浪費一些代碼區(qū)；==>產生原型創(chuàng)建
        //創(chuàng)建js對象 new+構造函數
        //1：創(chuàng)建構造函數 |通常首字母大寫
        function CreatePerson( name , age){
          //2：把對象的屬性|方法掛靠在this指針身上， 當調用該函數創(chuàng)建對象時，this指針就指向這個新對象；
          //這個this就添加給這個對象
          this.name = name;
          this.age = age;
          /*this.speak = function(){
            //此處this也指向創(chuàng)建對象
            console.log(this.name+" hello");
          }
        }

      /* CreatePerson.prototype.gender = "20";
       CreatePerson.prototype. ea = function(){
          console .log(this.name+ "sfd" );
       }*/

//      __proto__:是：實例對象中的原型屬性， 指向對應構造函數對應的原型對象
//      [[prototype]]
        //調用
        var per1 = new CreatePerson( "ailer", "20" );
        var per2 = new CreatePerson( "relia", "18" );
        console .log(per1 instanceof CreatePerson); //==true
        console .log(per2 instanceof CreatePerson); //==>true
        console .log(per1.speak== per2.speak); //==false說明系統(tǒng)開辟了兩個不同的代碼區(qū)，造成了內存浪費.

      function CreateAnimal(name, age) {
        //1.2：把外部參數綁定實例屬性
        this.name = name;
        this.age = age;
      }
      //1.3把相同的屬性，綁定在原型上(原型屬性，原型方法)
      CreateAnimal.prototype.gender = "male";
      CreateAnimal.prototype.style = function() {
        console.log(this.name + " ailers");
      };
      //2：調用構造函數創(chuàng)建對象
      var cat1 = new CreateAnimal("xiaohua", "2");
      var cat2 = new CreateAnimal("xiaohua", "2");
      cat1.style();

      console.log(cat1.style==cat2.style);//方法引用地址一樣，將屬性放到原型對象中，節(jié)約地址

      //instanceof可以來判斷對象屬于哪一個【函數】
      //constructor 建造者 也可以用來判斷對象屬于哪個【構造函數】 【常】 
      //實例對象保存一個 constructor屬性指向它的構造函數
      //instanceof and constructor 區(qū)別
      console.log(cat1 instanceof CreateAnimal);//true
      console.log(cat1 instanceof Object);//true

      console.log(cat1.constructor == CreateAnimal);//true
      console.log(cat1.constructor == Object); //==false

      //構造函數的原型也有constructor屬性指會構造函數
      console.log(CreateAnimal.prototype.constructor == CreateAnimal);//true

      //in判斷該屬性是否存在這個對象中，這個屬性為實例屬性或原型 
//           alert("name" in cat1)//true
//           alert("gender" in cat1);//true

      //hasOwnProperty:來判斷某一個屬性到底是實例屬性，還是繼承自原型屬性 if 是 為true, else不存在|不是返回false;
      console.log(cat1.hasOwnProperty("aaa"));//false 不存在的屬性返回為false
      console.log(cat1.hasOwnProperty("name"));//true 實例屬性
      console.log(cat1.hasOwnProperty("style"));//false 原型屬性返回為false

      //遍歷屬性找原型屬性

      //判斷參數是否為原型屬性  工具類
      console.log(isPrototype("gender", cat1));//true
      function isPrototype(proString, obj) {
        if(proString in obj) {
          if(!obj.hasOwnProperty(proString)) {
            return true;
          } else {
            return false;
          }
        } else {
          return false;
        }
      }
      /*
function isProperty(object, property) {//判斷原型中是否存在屬性
　　 return !object.hasOwnProperty(property) && (property in object);
}*/

//構造函數中初始化原型
function per(name, age, gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        //只在初始化原型的時候執(zhí)行一次
        if(typeof this.sayName != "function") {
          Person.prototype.sayName = function() {
            alert(this.name);
          }
        }
      }