四种创建对象方式的优缺点

直接创建对象：

模板：

var 对象名 = {                    例：        var student = {
    属性名: 属性值,                               Id: 123456,
    属性名: 属性值,                               Name: "张三",
    ……                                           ……
};                                               };

优点： 简单且直观的创建对象方式

缺点： 创建多个对象时，过程繁琐，无法量产                                   

---

封装函数创建对象：

模板：

function 函数名(形参1,形参2,形参3,...){
    var 对象名 = {}
    对象名.属性值1 = 形参1
    对象名.属性值2 = 形参2
    对象名.属性值3 = 形参3
    ...
    return 对象名
}

优点：这种方式也叫做“工厂模式”，通过调用封装函数可以快速的进行对象的量产

缺点：无法判断对象属于哪一类

 注：（数组属于特殊对象

            万物皆对象）

function createObject(name,age){
	var obj=new Object;
	obj.name=name;
	obj.age=age;
	obj.run=function(){
		return this.name+this.age;
	}
	return obj;//返回得到的对象引用,因为是普通函数需要调用,将得到的对象作为返回值
}
//调用：
// typeof() 返回对应变量的数据类型
// instanceof  检测变量的数据类型  ，变量必须为原型创建出来的
// js分为两类变量类型：简单类型 ：数值、字符串  引用类型
// 变量 instanceof Object 返回布尔值
var a=new createObject('苏',22);
var b=new createObject('王',22);
console.log(a instanceof Object);  //true
console.log(a instanceof createObject);  //false

---

构造函数创建对象：

模板：

//类(class)一类的总称  通过类创建对应的对象
function 类名(形参,形参){    // 创建一个学生类（构造函数）
    this.属性名 = 形参;      // js没有类，利用构造函数来模拟类,核心思想 改变this的指向性
    this.属性名 = 形参;
    this.方法名 = function(){
        console.log(this.属性名);
    };
}
var 对象名1 = new 类名(实参,实参); // 利用new 来创建对象
var 对象名2 = new 类名(实参,实参);

优点：在快速量产的同时，可以检测对应的类型

function Car(color,brand){
    this.color = color;
    this.brand = brand;
    this.showInfo = function(){
        console.log(this.color);
    };
}
var car1 = new Car('red','Jeep');
var car2 = new Car('black','Audi');
car1.showInfo();  //red
car2.showInfo();  //black
console.log(car1 instanceof Car); // ture

 注：   new的意义？

           1.创建一个空对象 {}

           2.执行后方函数 让函数内部 this指向 空对象{}

           3.将创建出来的对象 返回    

缺点：每创建一个对象都开辟一个存储showInfo的空间，造成内存的消耗

---

原型创建对象：

模板：

function 类名(形参,形参){    
    this.属性名 = 形参;      
    this.属性名 = 形参;
}
类名.prototype.showInfo=function(){
	console.log(this.形参)
}
var 对象名1 = new 类名(实参,实参)
var 对象名2 = new 类名(实参,实参)

优点：将构造函数中的方法定义到原型中，可量产，判断类型，节约内存

function Car(color,brand){
    this.color=color,   //私有的放入构造函数里
    this.brand=brand
}
Car.prototype.showInfo=function(){
    console.log(this.color)   //公用的放在原型中
}
var car1 = new Car('red','Jeep')
var car2 = new Car('black','Audi')
car1.showInfo()//red
car2.showInfo()//black

//构造函数的原型(prototype)==实例化对象的原型(__proto__)
car1.__proto__.showInfo=function(){
	console.log(this.brand)
}
car1.showInfo()//Jeep
car2.showInfo()//Audi

//获取对象原型__proto__
console.log(car1.__proto__==car2.__proto__)//ture

注： 每一个实例化的对象 都存在一个 [[Prototype]]属性 原型

        通过相同构造函数创建出来的对象 原型相同