day18（JavaScript）

一、函数

JavaScript解决函数的重载问题：arguments，arguments是类数组对象，根据传入的不同参数，输出不同的结果。

function test1(names){
    switch(arguments.length){
        case 1:
            console.log("朱朝阳的暑假");
        case 2:
            console.log("张东升的奥数班");    
    }
    console.log(arguments); -->[Arguments] { '0': '朱朝阳', '1': '张东升' }
}
test1('朱朝阳','张东升');   -->张东升的奥数班

类数组对象 vs 数组

相同点：

1、都有下标
2、都能调用.length方法求出数组的长度
3、都能遍历

不同点：

类数组对象是Object类型，数组是Array类型类数组对象不能调用数组的对应的方法。

1、闭包

1. 找受保护的的变量，确定外层函数调用后，受保护变量的最终
2. 找操作受保护的变量的内层函数对象

var add = (function () {
      var counter = 0;      
      return function () {return counter += 1;} 
})();
add();      // counter=1;
add();      // counter=2;
add();      // counter=3;

上述语句的执行过程
1、匿名函数的自调用,初始化了变量counter,并将匿名函数整体结构返回给了add 此时add就相当于 add --> function () {return counter += 1;} 
2、当执行add()函数的时候，实际上执行的是返回的匿名函数执行过后返回的结果，
而且此时匿名函数内部的counter和外部的counter存在指向关系，因此执行完毕的匿名函数并不会销毁变量counter。
3、当再次执行add()后，里面的counter还是上一次执行完毕的值。

二、对象

1、内置对象

2、自定义对象

1）使用内置构造函数创建对象

var obj = new Object();//创建一个空的内置对象
obj.name = "朱朝阳"; 添加属性
obj.age = 10;

2）使用自定义构造函数创建对象

function person(name,age){
    this.name = name;
    this.age = age;
    this.sayHello=function(){
        console.log(this.name);
    }
}
var person1=new Person("lili",24,"teacher")
var person2=new Person("leilei",20,"student")
person1.sayHello()
person2.sayHello()
console.log(person1.sayHello == person2.sayHello) -- false 

缺点：每个方法都要在每个实例上重新创建一遍。只有调用sayHello时才会给person实例创建一个新的sayHello对象，并将其作为属性添加到person实例中

3）工厂模式

function Person(name,age,job){
      var obj=new Object();
      obj.name=name;
      obj.age=age;
      obj.job=job;
      obj.sayName=function(){
          console.log(this.name)
          return obj;
      }
}
var person1=new Person('ll','22')
var person2=new Person('ss','33')
person1.sayName()
person2.sayName()
console.log(person1.sayName()==person2.sayName()) -->true

使用这种方法虽然可以解决function的不断创建，但是无法知道这个实例具体是由那个对象创建的。也就是实例与实例之间的关系很模糊。