js对象的创建方法

一.利用new来创建对象

new运算符可以创建一个用户定义的对象类型的实例或内置对象的实例，并将其绑定为构造函数的this。

var obj = new Object();
obj.name = 'jojo';//向obj里添加一个name属性,name属性值为'jojo'
obj.gender = '男';
obj.age = 20;

二.利用字面量来创建对象

对象字面量：就是花括号{}里面包含了表达这个具体事物（对象）的属性和方法

var obj = {}；//创建一个空对象
var obj2 = {
      name: "猪八戒",
      age: 28,
      gender: "男",
      sayHi: function () {
        console.log('hi~');
      }
    }

对象内的属性或方法以键值对的形式存在

(键 : 值)对应 (属性名 : 属性值)

多个键值对中间用逗号隔开

方法冒号后跟的是一个匿名函数 function(){}

读取对象

调用对象的属性 

对象名.属性名
 对象名['属性名']

调用对象方法

对象名.方法名

//读取对象属性
  console.log(obj2.name);
  console.log(obj2['age']);
  //读取对象方法
  obj.sayHi()

三.使用工厂方法创建对象

通过该方法可以批量创建对象

 function person (name,age,gender) {
            var obj =new Object();
            obj.name = name;
            obj.age = age;
            obj.gender = gender;
            obj.eat = function () {
                console.log(`${this.name}吃饭`);
            }
            return obj;//返回对象obj
        }
        var person1 = person('张三',18,'男');
        console.log(person1);
        person1.eat();
        var person2 = person('李四,20,男');
        console.log(person2);
        person1.eat();

问题：
 使用工厂方法创建的对象，使用的构造函数都是Object
 所以创建的对象都是Object这个类型
 就导致我们无法区分多种不同类型的对象

四.利用构造函数创建对象

构造函数：是一种特殊的函数，主要用来初始化对象，即为对象成员变量赋值初始值，它综合new运算符一起使用。我们可以把对象中一些公共属性和方法抽取出来，然后封装到这个函数里面.

结构:

function 构造函数名(){
this.属性=值；
this.方法=function(){}
}
new 构造函数名();

function Person(name,age,gender){
            this.name = name;
            this.age = age;
            this.gender = gender;
            this.eat = function () {
                console.log(`${this.name}吃饭`);
            }
        }
        var p1 = new Person('张三',18,'男');
        var p2 = new Person('李四',28,'女');
        console.log(p1);
        console.log(p2);
        p1.eat();
        p2.eat();

注意：
● 构造函数就是一个普通的函数，创建方式和普通函数没有区别，不同的是构造函数习惯上首字母大写
● 构造函数和普通函数的区别就是调用方式的不同 ，普通函数是直接调用，构造函数需要使用new关键字来调用
● 构造函数创建属性和方法，必须结合this使用，此时的this就是新创建的那个对象；

这样的构造函数每次执行时都会重新创建一个新的eat方法,既浪费空间也没必要,可以将方法创建到

全局作用域

function Person(name,age,gender){
            this.name = name;
            this.age = age;
            this.gender = gender;
            this.eat = eat;
        }
        //将方法放在外面创建
        var eat = function () {
                console.log(`${this.name}吃饭`);
            }
        var p1 = new Person('张三',18,'男');
        var p2 = new Person('李四',28,'女');
        console.log(p1);
        console.log(p2);
        //p1,p2都由Person创建,所以同属一个类
        p1.eat();
        p2.eat();

注意：

以上优化也有一定的问题，如将函数定义在全局作用域，污染了全局作用域的命名空间
 而且定义在全局作用域中也很不安全

原型对象

我们所创建的每一个函数，解析器都会向函数中添加一个属性prototype,这个属性对应着一个对象，这个对象就是我们所谓的原型对象(prototype是属性名，它的值是一个对象，这个对象叫原型对象),默认情况下，它是一个空对象

当函数以构造函数的形式调用时，它所创建的对象都会有一个隐含的属性，指向该构造函数的原型对象，我们通过__proto__来访问该属性

原型对象的作用

原型对象就相当于一个公共的区域，所有同一个类的实例(由同一个构造函数创建)都可以访问到这个原型对象，我们可以将对象中共有的内容，统一设置到原型对象中，当我们访问对象的一个属性或方法时，它会先在对象自身中寻找，如果有就直接使用，如果没有就去原型对象中寻找，然后使用。
 以后我们创建构造函数时，可以将这些对象共有的属性和方法，统一添加到构造函数中，这样就不用分别给每一个对象添加，也不会影响到全局作用域，就可以使每个对象，都具有这样的属性和方法了.

 function MyClass() {}
      //向MyClass的原型对象中添加属性a
      MyClass.prototype.a = 123;
      //向MyClass中添加一个方法
      MyClass.prototype.sayHello = function () {
        alert("hello");
      };
      console.log(MyClass.prototype);

      //添加实例
      var mc = new MyClass(); //隐含属性__proto__
      var mc2 = new MyClass();

      console.log(MyClass.prototype,"MyClass.prototype");//object
      console.log(mc.__proto__,'mc.__proto__');//object
      console.log(MyClass.prototype==mc.__proto__);//true
       mc.sayHello();
   

检查对象中是否含有某个属性

a:使用in检查对象中是否含有某个属性时，如果对象中没有，原型中有，也会返回true
b:可以使用对象的hasOwnproperty()来检查对象自身中是否含有该属性,使用该方法只有当对象自身中含有属性时，才会返回true

      /* 创建一个构造函数 */
      function MyClass() {}
      //向MyClass的原型中添加一个name属性
      MyClass.prototype.name = "我是原型中的name";
      var mc = new MyClass();
      mc.age = 18;
      console.log(mc.name);
      console.log("name" in mc); //true
      console.log(mc.hasOwnProperty("name")); //false

原型链

型对象也是对象，所以它也有原型
当我们使用一个对象的属性或方法时，会先在自身中寻找 ，自身中如果有，则直接使用，如果没有，则去原型对象中寻找，如果原型对象中有，则使用，如果没有，则去原型对象的原型中寻找，直到找到Object对象的原型，Object对象的原型没有原型，如果在Object中依然没有找到，则返回undefined 

五.class创建对象

JavaScript 语言中，生成实例对象的传统方法是通过构造函数，

ES6 提供了更接近传统语言的写法，引入了 Class（类）这个概念，作为对象的模板。通过class关键字，可以定义类。

// es6实现  class方法实现
      class PersonN {
        //构造方法  constructor名字不能修改
        // 当我们new实例对象的时候，这个方法自动执行
        constructor(username, password) {
          this.username = username;
          this.password = password;
        }
        //方法必须使用该语法, 不能使用 ES5 的对象完整形式
        getstr() {
          console.log("用户名：" + this.username + "，密码：" + this.password);
        }
        //ES5 的对象完整形式  报错
        // getstr:function () {}
      }
      const pn1 = new PersonN("123456", "789012");
      pn1.getstr();