浅谈OOP

2017-12-20

1. 对象定义的方法

方法1：直接定义

var obj1  = {
    name : "小丸子1",
    age : 18,
    active: function(){
          console.log("吃喝玩乐");
    }
}

方法2：追加定义

var obj2 = new Object();
obj2.name = "小丸子2";
obj2.age = 19,
obj2.active = function(){
    console.log("吃喝玩乐2");
}

但是当

obj2 = {
    name: "哆啦A梦"，
    age: 10,
}

此时上面定义的对象会将之前定义的覆盖掉，所以不推荐使用

方法3：不经常使用

1	var obj3 = Object.create({name:"小丸子3",age:20})

2. 传值？传址

var a = 10;
var b = a;
b = 20;
console.log(a); // a = 10

上述小demo可以知道，此时a的值为10，因为b = a 只是将a的值赋给b,除此之外a,b没有任何联系。
但是……

var a = [1, 2, 3, 4, 5];
var b = a;
b[2] = 9;
console.log(a); // a = [1, 9, 3, 4, 5]

此时将 b = a；是将a的地址传给b，a,b公用同一个地址，所以当改变b里面的值的时候对应的a也会发生改变
此时的a 为数组，赋值的时候传的是地址，那么如果是对象呢？

1
2
3

var obj4 = obj2;
obj4.name = "唐老鸭";
console.log(obj2);  // {name: "唐老鸭", age: 19, active: ƒ}

那么问题来了，如果只想单纯的想拷贝obj2里面的值这么办呢？
这时就要利用JSON.stringify 与 JSON.parse方法，前者将对象转换为字符串，后者将字符串转化为对象。

1
2
3

var obj4 = JSON.parse(JSON.stringify(obj2));
obj4.name = "唐老鸭222";
console.log(obj2); // {name: "小丸子2", age: 19, active: ƒ}

即即使我们改变obj4里面的属性值，obj2里面对应的值也不会改变。
因为在将解析后的字符串转化为对象的时候，系统会重新创建一个新的地址，将变量存储。这种方法叫做深拷贝。

3. ES5 与 ES6的区别

1. 定义变量

新增了 let 与 const，let与var差别不大，甚至可以完全取代var，当然是在不用考虑兼容的情况下，毕竟ES6刚出来，很多浏览器还不支持。
至于const,定义常量

const PI = "3.1415926";
console.log(PI); // 3.1415926
const PI = "3.14";
console.log(PI); //报错，因为常量只能定义一次，

2. 模板代码

传统的代码拼接 ES5

1
2
3

var name = "米老鼠";
var age = 18;
console.log("名字是："+name +"年龄为："+age);

当前的代码拼接 ES6

1
2
3

var name = "米老鼠";
var age = 18;
console.log(`名字是：${name} 年龄为：${age}`);

在对象中
ES5 写法

var name = "米老鼠";
var age = 18;
var obj = {
    name: name,
    age: age
}

ES6 写法

var name = "米老鼠";
var age = 18;
var obj = {
    name,
    age
}

当有函数的时候 function可以省略

var obj1 = {
    name: "tttt",
    age: 18,
    active(){
        console.log("hhhh");
    }
}

ES6 箭头函数

      var test = (str) => str;
console.log(test("hello"));
var test1 = () => {
	var str = "hhhh";
	return str;
}
console.log(test1())
var test2 = () => ({
	name: "tt",
	age: 18
})
console.log(test2())

		var obj2 = {
			name: "大瑞",
			age: 18,
//			active: function(){
//				console.log(this);
//				console.log(this.name);
//			}
			action:() => {
				console.log(this);
			}
		}
//		obj2.active();  //  指向 obj2
		obj2.action(); //  指向 window  （this穿透）

4. 传统的工厂模式

function Factory(age){
    var obj = {};
    obj.name= "QQ";
    obj.age= age;
    obj.active = function(){
        console.log("吃喝玩乐");
    }
    return obj;
}
var newFactory = new Factory(18);
console.log(newFactory.age); // 18

但是在构造函数下，传统的工厂模式不怎么使用

5. 构造函数

构造函数是由其本身与原型共同构成的，构造函数的原型 prototype
对象是由其自身与原型共同构成的，对象的原型proto
构造函数与对象的原型之间只差一个new（实例化）
但是在本质上是一样的

            function Person(name, age){
	this.name = name;
	this.age = age;
}
Person.prototype.active = function(){
	console.log("吃喝玩乐");
}
var newPerson = new Person("QQ", 18);
console.log(newPerson.__proto__ === Person.prototype); // true

在构造函数里面，this指向实例化对象（即谁调用指向谁）并且构造函数与其原型公用同一个this

              function Person2(name, age){
	this.name = name;
	this.age = age;
}
Person2.prototype.active = function(){
	console.log(this.name);
}
var newPerson2 = new Person2("海绵宝宝", 9);
newPerson2.active(); // 海绵宝宝
var newPerson3 = new Person2("派大星", 9);
newPerson3.active(); // 派大星

6. 构造函数的封装

构造函数模拟类的特性但不是类

      function Fatcher(firstName){
	//私有属性
	var firstName = firstName;
	//共有属性
	this.money = "$10000000";
	//设置共有方法，返回私有属性
	this.get = function(){
		return firstName;
	}
	//set 方法 设置私有属性
	this.set = function(firstName){
		firstName = firstName;
		console.log(firstName);
	}
}
var newFatcher = new Fatcher("shen");
console.log(newFatcher.money); // $10000000
console.log(newFatcher.firstName); // undefined
console.log(newFatcher.get()); // shen
newFatcher.set("shen"); // shen

7. 构造函数的继承

     function Dad(money){
	this.money = money;
}
function Son(money){
	Dad.call(this,money);
}
var newSon = new Son("100000");
console.log(newSon.money); // 100000