js学习

1、js中5个基本类型：Null,Undefined,Number,String,Boolean
2、js中String是值类型不是引用类型，with语句的性能低
3、只能给引用类型（对象）添加属性，不能给基本类型添加属性，比如说

var obj = new Object();
obj.value = 1;
alert(obj.value); //1

var a = "hello";
a.value = 1;
alert(a.value); //undefined

4、ES中所有函数的参数传递都是值传递，包括引用类型，不过引用类型复制的是内存中的地址，所以这个局部变量的变化会反映在函数的外部。

5、JS中的解除引用：将不需要的变量设为null，确保占用最少的内存，适用于大多数全局变量和全局对象的属性。使其脱离执行环境，以便垃圾收集器下次运行时使其回收。

6、JS创建对象的两个方法：

var obj = new Object();
obj.name = "name";
obj.age = 19;

var obj1 = {
    name:"name",
    "age":19
}

7、JS中创建Array的方法：

var array1 = new Array();
var array2 = new Array(20);
var array3 = new Array("red","blue",20);
var array4 = ["red","blue"];    
var array6 = [];

8、数组的toString()函数返回string,而valueOf返回的仍是数组对象。
Array对象中，使用push()和pop()模拟栈，先入先出；使用push和shift()模拟队列，先入后出，shift()获得前端的值，同时，ES也使用unshift()方法来是的在数组前端添加项。unshift()方法返回数组当前的长度，等同于length，数组的reverse方法会反转数组项的顺序。

var array = new Array();
array.push("red","blue");   //给数组添加两项
alert(array.length);        //2
var item = array.pop();     
alert(item.toString());     //blue
array.push("green");        
var item = array.shift();
alert(item.toString());     //red
array.unshift("black","white");     //数组前端添加两项
alert(array[0]+" "+array[1]);   //black white

Array的方法
1、sort()方法：会比较toString()之后的字符串大小，即使是数字比较的也是字符串。可以后面加函数。其中compare函数返回>0代表交换两个数的值

function compare(value1, value2) {
            if (value1 < value2) {
                return -1;
            } else if (value1 > value2) {
                return 1;
            } else {
                return 0;
            }
        }
        var value = [0, 1, 15, 10];
        value.sort(compare);
        alert(value);   //0,1,10,15

2、 concat()方法：复制数组，带参数的话则将参数后面的加入结果数组的末尾，相当于把这些数组项push进去
3、 slice()方法，能够基于当前数组的一或多个项创建一个新数组。

    var array = [0,1,2,3];
    var array1 = array.slice(1); //1,2,3
    var array2 = array.slice(1,2); //1  

4、splice方法，用于向数组中部插入项，此方法返回值是一个从删除项组成的数组，有三种用法：
4、1 删除：两个参数。要删除的第一项的位置和要删除的项数。splice(0，2)会删除从数组的前两项。
4、2 插入：向指定位置插入任意数的项，至少三个参数，起始位置，0（要删除的项数），要插入的项（可以有多项）。
4、3 替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，至少三个参数，起始位置，要删除的项数，要插入的项。
5、 index方法和lastIndexOf方法：两个参数，要查找的项和（可选）查找起点位置的索引。indexOf()从数组开头开始查找，lastIndexOf()从数组结尾开始查找。
6、 5个迭代方法：every(),some(),filter(),map(),forEach();都有两个参数，一个是要对每项执行的函数，一个是（可选参数）运行该函数的作用域对象，执行后原数组均不改变
6、1 every()，对每一项运行函数，所有项对该函数都返回true,则返回true;
6、2 some()，对每一项运行函数，至少有一项返回true，则返回true;
6、3 filter()，返回对函数返回ture的项
6、4 map()，返回每次函数调用之后的结果组成的数组
6、5 forEach()，没有返回值。

var numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];
        var everyResult = numbers.every(function(item, index, array) {
            return item > 2;
        });
        alert(everyResult);  //false
        var someResult = numbers.some(function(item, index, array) {
            return item > 4;
        });
        alert(someResult);   // true
        var filterResult = numbers.filter(function(item, index, array) {
            return item > 2;
        });
        alert(filterResult);   //3,4,5,4,3
        var foreachResult = numbers.forEach(function(item, index, array) {
            item = item + 1;
        });
        alert(numbers);  //1,2,3,4,5,4,3,2,1
        var mapResult = numbers.map(function(item, index, array) {
            return item + 5;
        });
        alert(mapResult);  //6,7,8,9,10,9,8,7,6

7、两个缩小数组的迭代方法：reduce()和reduceRight();reduce()从数组首项开始执行，reduceRight()从数组末尾开始执行。两个参数，一个在每一项上调用的函数（4个参数，前一个值，当前值，项的索引和数组对象）以及（可选）作为缩小基础的初始值。

var numbers = [1,2,3,4,5];
var reduceResult = numbers.reduce(function(pre,cur,index,array){
    return pre + cur;
});
alert(reduceResult);    //15

8、ES中的date函数：
Date.now();返回当前时间的毫秒数
new Date();返回当前时间
new Date(Date.parse(“May 25,2004”));
new Date(Date.UTC(“2005,2,15,10,10,10”); //GMT时间 2005/3/15 10:10:10
new Date(“2005,2,15,10,10,10”); //本地时间 2005/3/15 10:10:10

9、ES中的正则
g：表示全局模式，而非在发现第一个匹配项时立即停止。
i：表示不区分大小写；
m：表示多行模式，在到达行末的时候还会继续查找下一行。
1、var pattern1 = /cat/g;
2、var pattern2 = new RegExp(“cat”,”g”);
使用：pattern.test(str);
这样使用正则，会找出其中符合条件的子字符串。如果想要判断一个字符串是不是匹配，需要使用^和$来匹配字符串的开头和结尾。如/^cat$/就是判断一个字符串是不是就是cat。

10、ES的函数
10、1 函数实际上就是对象！每个函数都是Function类型的实例。因为函数名是指针，所以ES中函数没有重载。两个同名函数，调用后声明的那个。（因为函数名指向了后面那个函数）
10、2 对于函数声明，有函数声明提升过程，读取并将函数声明添加到执行环境中。下例会成功执行。

alert(sum(10,10));
function sum(num1,num2){
    return num1+num2;
}

而下例使用函数表达式会报错

alert(sum(10,10));
var sum = function (num1,num2){
    return num1+num2;
}

10、3 函数内部属性。arguments和this，以及caller。arguments是类数组对象，有length,同时arguments还有一个叫callee的属性，指向拥有这个arguments对象的函数。所以阶乘可以这样写：

function factorial(num){
    if(num <= 1){
        return 1;
    }else{
        return num * arguments.callee(num-1);
    }
}

至于this:this指代当前执行环境。

        window.color = "red";
        var obj = new Object();
        obj.color = "blue";

        function sayColor() {
            return this.color;
        }
        alert(sayColor()); //red
        obj.sayColor = sayColor;
        alert(obj.sayColor()); //blue

至于caller，保存着调用当前函数的函数的引用。如果是在全局作用域中调用当前函数，返回null。

function outer() {
            inner();
        }

        function inner() {
            alert(inner.caller);
            // alert(arguments.callee.caller);
        }

        outer();

由于outer()调用了inner()，所以此代码输出outer()的源代码。

10、4 函数既然是对象，也有属性和方法。每个函数包含两个属性：length和 prototype。length表示函数希望接收的命名参数的个数。每个函数都包含两个非继承而来的方法：apply()和call()。ES5添加了bind()函数。
apply()和call()的用法：扩充函数运行的作用域。
bind()用法：

function color(){
    return this.color;
}
window.color = "red";
var o = {color:"blue"};
var objectColor = color.bind(o);    //将color函数绑定到o对象上，这样objectColor()函数中的this都是o
alert(objectColor());    //blue

11、 JS中的包装类型：String、Number、Boolean。自动创建的基本包装类型的对象，生存周期只存在一行代码执行的瞬间，然后马上销毁。使用基本包装类型和转型函数不同。

var a = Number(25);
alert(typeof a);    //number

var b = new Number(25);
alert(typeof b);    //object

12、ES中的String提供的函数：
charAt():获得参数指示位置字符。使用 str.charAt(2);
concat():拼接字符。 str = str.concat(“world”); str = str.concat(“word1”,”word2”,”word3”);但更多时候拼接字符还是使用+号；

13、对象：JS中用工厂模式来创建对象：用函数来封装以特定接口创建对象的细节。

function createPerson(name,age,job){
    var person = new Object();
    person.name = name;
    person.age = age;
    person.job = job;
    person.sayName = function(){
        alert(this.name);
    }
    return person;
}

var person1 = createPerson("Nic",18,"software");

构造函数模式：

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function(){
    alert(this.name);
    }
}

var person = new Person("Nic",15,"software");   //重点是这个new，才会产生对象
//如果只是普通函数那样调用，会将这个对象（也就是这个this）添加到window
//但是这样创建会导致产生多个函数实例

原型（prototype）模型：
原型（prototype）属性：指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的方法。

组合使用构造函数模式和原型模式：

function Person(name, age, job) {
            this.name = name;
            this.age = age;
            this.job = job;
        }

        Person.prototype= {
            constructor:Person,
            sayName:function(){
                alert(this.name);
            }
        }

        var person1 = new Person("Nic", 18, "a");
        var person2 = new Person("Nic1", 18, "a1");
        person1.sayName(); //Nic
        person2.sayName();  //Nic1
        alert(person1.sayName === person2.sayName); //true

14、获得对象实例和实例原型的属性和方法：使用for-in
仅获得对象实例的属性和方法：使用Object.keys(object);
要获得包含了不可枚举的对象实例的属性和方法：使用Object.getOwnPropertyNames(object);

15、稳妥构造函数模式
特点：一不使用this,二不使用new创建对象

function Person(name,age,job){
    var o = new Object();
    o.sayName = function(){
        alert(name);
    }
    return o;  //只有sayName()才能访问name，没有别的方法
}

16、ES通过原型链来实现继承

function SuperObj(){
    this.name = "super";
}

SuperObj.prototype.getSuper = function(){
    return this.name;
}

function SubObj(){
    this.name1 = "sub";
}

SubObj.prototype = new SubObj();
SubOjb.prototype.getSub = function(){
    return this.name1;
}
var obj = new SubObj();
alert(obj.getSub());    //sub
alert(obj.getSuper());  //super
//原理是通过原型链，将sub对象的原型对象指向一个Super实例（重写原型对象），当查找Sub属性或者方法时，先查找实例中是否存在，然后再去原型（也就是Super实例中）查找属性或方法是否存在，然后再去Super的原型中查找。