创建对象的6种方式

对象是无序属性的集合
表现的方式：
{“key”:value,“key2”:value2}
: 是映射
= 是赋值
key是字符串
value是任何数据类型
且不重复

第一 new Object

// 1.new Object
var x = "age";//设置变量
var obj = new Object(); //创建对象
	obj.name = "li"; //对象中添加内容
	obj.x = 23;// 变量 = 值    . 是字符串
	console.log(obj);//输出的是添加过后的对象


	obj[x] = 23;//另一种写法  将变量写进[]里面
	console.log(obj);//输出的是添加过后的对象

第二 字面量方式

// 2. 字面量定义方式
var x = "hooby";//创建变量
var obj = {"name","静静","age",23};//直接创建对象
	//以下为添加值
	obj.sex = "男";
	obj.say = function(){};
	obj[x] = "唱歌";
	//输出obj 结果为02字面量.html:23 {name: "李路康", age: 23, sex: "男", hooby: "唱歌", say: ƒ}


//取值
var obj1 = {"name","静静","age",23};
var a = obj1["name"];
//输出a的结果为  静静
var b = obj1["age"];
//输出b的结果为  23
//先创建对象  在设置变量 = 创建的对象[这里写对象中的属性]  就可以将某一项的值取出

第三 工厂函数

/*
	创建具有相同属性名的对象
	写法：
		1.创建函数
		2.传入参数
		3.函数内创建对象
		4.returun  对象
*/

var obj = {"name": "静静", "age": 23,"say": function (){}};
function fun(name,age){
	var obj = {
	"name": name,
	"age": age ,
	"say": function(){}
	}
	return obj;
}

//依次调用  修改原对象的值  
//只能一个一个修改
var obj1 = fun("晶晶",23);
//输出obj1结果为{name: "li", age: 23, say: ƒ};

//循环调用
//可以创建数组一次修改多个
var obj2 = ["爱爱","珍珍","怜怜","贾夫人"];
var obj3 = [16,18,20,38];

for(var i = 0; i < obj2.length; i++){
	var a = fun(obj2[i],obj3[i])
	//输出a的结果为
	//{name: "gao", age: 18, say: ƒ}
	//{name: "li", age: 19, say: ƒ}
	//{name: "wang", age: 20, say: ƒ}
	//{name: "zhao", age: 21, say: ƒ}
}

//优点：返回新对象  互不影响
//缺点：代码重复（相同的方法）  没有从属关系（不知道对象从哪里来）---->instanceof  只能判断是对象  不能判断属于谁

第四 构造函数

/*
构造函数可以解决工厂模式的从属关系

构造函数的函数名首字母要大写

	构造函数写法：
		1.创建函数
		2.传入参数
		3.this.属性名 = 值
	调用方式：
		var obj = new 函数名(参数);
*/
function Fn(name,age){
	this.name = name;
	this.age = age;
	this.say = function(){}
}
var obj = new Fn("静静",23);
var a = obj instanceof Object;//判断是否属于对象
var b = obj instanceof Fn;//判断从属于谁   

第五 原型模式

//每一个函数都有一个prototype属性
//属性的值是对象  这个对象叫做原型对象
function Fn(){
	
}
Fn.prototype.name = "静静";
Fn.prototype.age = 23;

var obj = new Fn();
//输出obj结果为  空 对象
obj.__proto__.name = "晶晶";
//输出obj.__proto__.name的结果为  晶晶
//输出obj.name的结果为  晶晶
//两种输出只是换了从复杂到简单  化繁为简


 //公共/相同的属性、方法放在 构造函数.prototype   上 ---> 实现 代码不重复
 //  原型模式  一个改变另外的也改变
 var obj1 = new Fn();
 //输出 obj1 结果为  空  对象
 //输出 obj1.__proto__.name 的结果为  晶晶


//原型模式
	//优点：公共/相同  的  属性.方法 不重复
	//缺点：原型上的  属性不可变

第六 组合模式 （构造函数+原型模式）

//属性定义在构造函数内
function Fn(name,age){
	this.name = name;
	this.age = age;
}
Fn.prototype.say = function(){
	console.log("和你在一块我很开心");
}

var obj1 = new Fn("静静"，23);
var obj2 = new Fn("盈盈"，25);
//输出 obj1 的结果为{name: "静静", age: 23}
//输出 obj2 的结果为{name: "盈盈", age: 25}

//组合模式 = 构造 + 原型
//有从属关系
//原型不重复