浅谈OOP

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：不经常使用

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 为数组，赋值的时候传的是地址，那么如果是对象呢？

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

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

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

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

当前的代码拼接 ES6

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