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
