JavaScript笔记：引用类型

引用类型是一种数据结构，就像java等面向对象语言中的类一样。
虽然ECMAScript从技术上说可以成为面向对象的语言，但是，它不具备类和接口等基本结构。所以，虽然引用类型很像类，但是并不是真正意义上的类。

1、Object类型

创建Object类型的实例方法：

// 方法1：new
var person = new Object();
person.name = "Nicholas";
person.age = 29;

// 方法2：对象字面量
// 这种定义方法使用时，如果在最后一个属性后加了逗号，
// 可能会在老版本的IE浏览器中引起错误。
var person = {
    name : "Nicholas",
    age : 29
};

访问对象属性的方法有两种，一种是点表示法，一种是方括号语法。

alert(person.name); //"Nicholas"
alert(person["name"]); //"Nicholas" 

使用起来，没有什么区别， 不过方括号语法的优点是可以通过变量来访问属性：

var propertyName = "name"; 
alert(person[propertyName]); //"Nicholas"

如果属性名中包含会导致错误的字符，或者属性名使用的是关键字和保留字，也可以使用方括号表示法。

person["first name"] = "Nicholas";

2、Array类型

ECMAScript中的数组和其他语言中的数组有很大的区别——它可以保存任何类型的数据组合。也就是说，数组的第一项可以是字符串，第二项却变成了数字，第三项是一个对象…
而且，ECMAScript中的数组大笑可以动态调整，可以随着数据的增长自动增加长度来容纳新的数据。

创建数组的基本方式同样有两种：

// 方法1
var colors = new Array(20);// 数组长度为20
var colors = new Array("red", "blue", "green");
var names = new Array("Greg");
// 方法2
var colors = ["red", "blue", "green"];
var names = [];
var values = [1,2,];// 不要这样写，不同浏览器的处理方式不同
var options = [,,,,,];// 不要这样写，不同浏览器的处理方式不同

在读取和设置数组的值的时候，使用方括号语法即可：

var colors = ["red", "blue", "green"]; 
alert(colors[0]);
colors[2] = "black";
colors[3] = "brown";// 新增一项，不会导致溢出错误

数组的长度保存在属性length中，通过访问该属性，可以得到数组中元素的个数。

var colors = ["red", "blue", "green"];
var names = [];
alert(colors.length); 
alert(names.length);  

并且，length还有一个特点：它不是只读的。我们可以通过设置这个属性，从数组的末尾移除或者添加新项。

var colors = ["red", "blue", "green"]; 
colors.length = 2;
alert(colors[2]);// undefined 新添加的一项，不过未定义
// 添加
var colors = ["red", "blue", "green"];
colors[colors.length] = "black";
colors[colors.length] = "brown";

检测数组：

if (value instanceof Array){
    // 对数组的某些操作   
}
if (Array.isArray(value)){ 
    // 对数组的某些操作   
}

转换方法

所有对象都具有toLocaleString()、toString()
valueOf()着三个方法。
调用数组的toString()方法，会返回数组每一项以逗号分隔拼接成的字符串。而调用valueOf方法返回的还是数组。
实际上，调用toString方法时，为了创建这个字符串，会调用每一项的toString方法。
请看下面这个栗子：

var person1 = {
    toLocaleString : function () {
        return "Nikolaos";
    },
    toString : function() {
        return "Nicholas";
} };
var person2 = {
    toLocaleString : function () {
        return "Grigorios";
    },
    toString : function() {
        return "Greg";
} };
var people = [person1, person2];
alert(people);
alert(people.toString());
alert(people.toLocaleString());
// 输出结果：
// Nicholas,Greg
// Nicholas,Greg
// Nikolaos,Grigorios

数组继承的toLocaleString() toString() valueOf()三个方法，在默认情况下，都会以逗号分隔字符串的方式返回数组项，而如果使用join方法，则可以选择自定义的分隔符。

var colors = ["red", "green", "blue"];
alert(colors.join(","));       //red,green,blue
alert(colors.join("||"));      //red||green||blue

栈方法和队列方法
数组可以表现的像栈和队列一样，即可以限制插入项和删除项的数据结构。
栈方法：

var colors = new Array();
var count = colors.push("red", "green"); 
alert(count); //2
count = colors.push("black");
alert(count);     //3
var item = colors.pop();
alert(item);      //"black"
alert(colors.length);   //2

队列方法：

var colors = new Array();
var count = colors.push("red", "green"); 
alert(count); //2
count = colors.push("black");
alert(count);     //3
var item = colors.shift();// 取得数组第一项
alert(item); //"red" 
alert(colors.length); //2

ECMAScript还为数组提供了unshift方法，其作用与shift正好相反，是从队列头部加入元素。例如：

var colors = new Array();
var count = colors.unshift("red", "green");
alert(count); //2

count = colors.unshift("black");
alert(count);   //3
var item = colors.pop();
alert(item);    //"green"
alert(colors.length); //2
// 数组中各项的顺序为："black" "red" "green"

重排序方法

reverse()和sort()是可以用来给数组排序的方法。

var values = [0, 1, 5, 10, 15];
values.sort();
alert(values);     //0,1,10,15,5

这段代码可能会让人有些困惑。明明10大于5的为什么排在了前面？
这是因为当sort函数比较数字大小时，会先调用toString方法，将其转为字符串后再做比较的。因此，直接使用sort函数并不是排序的最佳方案。

那么我们该如何写这个比较方法呢？如下：

 function compare(value1, value2){
        return value1 - value2;
}

var values = [0, 1, 5, 10, 15];
values.sort(compare);
alert(values); //0,1,5,10,15

操作方法
concat方法，拼接字符串，不改变原来的数组。

var colors = ["red", "green", "blue"];
var colors2 = colors.concat("yellow", ["black", "brown"]);
alert(colors);     //red,green,blue
alert(colors2);    //red,green,blue,yellow,black,brown

slice()方法，接受两个参数，起始下标和终止下标；当参数只有一个时，终止下标则默认为数组的最后一个数的下标length-1，即返回指定下标到数组末位的所有项。该函数同样不会改变原来的数组，使用方法如下例：

var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1);
var colors3 = colors.slice(1,4);
alert(colors2);   //green,blue,yellow,purple
alert(colors3);   //green,blue,yellow

另外，如果该函数的参数中包涵负数，则用数组长度加上该负数表示位置下标。如果结束位置小于起始位置，则返回空数组。

splice()方法，堪称最强大的数组方法。它有很多种用法，归纳如下。
删除：
接受两个参数，要删除的第一项的位置和要删除的项数。
插入：
需提供三个参数，起始位置，0（要删除的项数），要插入的项。
替换：
需提供三个参数，起始位置，要删除的项数，要插入的项。其中删除项和插入项不一定个数一样。
栗子：

var colors = ["red", "green", "blue"];
var removed = colors.splice(0,1); 
alert(colors); // green,blue 
alert(removed); // red 
removed = colors.splice(1, 0, "yellow", "orange"); 
alert(colors); // green,yellow,orange,blue 
alert(removed); // 空数组
removed = colors.splice(1, 1, "red", "purple"); 
alert(colors); // green,red,purple,orange,blue 
alert(removed); // yellow

位置方法

indexOf()和lastIndexOf()是两个位置方法，可以接受两个参数：要查找的项和开始查找的位置索引。其中，indexOf是从前往后查找，lastIndexOf是从后往前查找。
这两个方法都会返回查找后，目标在数组中的下标位置，如果没有找到，则返回-1。
在比较参数和数组中的每一项的时候，会使用全等操作符，也就是说，要求查找的项必须严格相等。（下面有例子）

var numbers = [1,2,3,4,5,4,3,2,1];
alert(numbers.indexOf(4));        //3
alert(numbers.lastIndexOf(4)); //5
alert(numbers.indexOf(4, 4));     //5
alert(numbers.lastIndexOf(4, 4)); //3

var person = { name: "Nicholas" };
var people = [{ name: "Nicholas" }];
var morePeople = [person];
alert(people.indexOf(person));     //-1
alert(morePeople.indexOf(person)); //0

迭代方法
ECMAScript为数组定义了5个迭代方法，方法可以接受一个函数作为参数。
every()：对数组的每一项运行给定的函数，如果该函数对每一项都返回true，则 every()函数返回true。

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

filter()：对数组的每一项运行给定的函数，返回该函数会返回true的项组成的数组。

var numbers = [1,2,3,4,5,4,3,2,1];
var filterResult = numbers.filter(function(item, index, array){
    return (item > 2);
 });
alert(filterResult);//[3,4,5,4,3]

forEach()：对数组的每一项运行给定的函数，无返回值。
map()：对数组的每一项运行给定的函数，返回每次调用的结果组成的数组。

var numbers = [1,2,3,4,5,4,3,2,1];
var mapResult = numbers.map(function(item, index, array){
    return item * 2;
});
alert(mapResult);  //[2,4,6,8,10,8,6,4,2]

some()：对数组的每一项运行给定的函数，如果有一项返回true，则返回true。

var numbers = [1,2,3,4,5,4,3,2,1];
var someResult = numbers.some(function(item, index, array){
    return (item > 2);
});
alert(someResult); //true

归并方法
reduce()和reduceRight()
作用是迭代数组的所有项，构建一个最终的返回值。其中reduce从数组第一项开始，而reduceRight从数组最后一项开始。它们的函数接受4个参数，意义分别为：前一个值，当前值，项的索引和数组对象。

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

Date类型

Date类型能够保存1970-1-1之前或之后的285 616 年。
创建一个日期对象：

var now = new Date();

在调用Date不传参数的前提下， 会自动返回当前的时间。如果想创建一个自定义的时间，则需要使用Date.parse()或者Date.UTC()方法。
Date.parse()方法接受一个表示时间的字符串，然后根据这个字符串返回相应日期的毫秒数。但是，接受的时间字符串的格式却可能根据地区变化而变化：

var someDate = new Date(Date.parse("May 25, 2004"));
// 简便创建方法
var someDate = new Date("May 25, 2004");

如果传入Date.parse函数的字符串不能表示日期，则函数会返回NaN

Date.UTC方法的参数分别为：年份，基于0的月份，月中的哪一天，小时，分钟和毫秒。其中，前两个参数是必须的，后面的参数若不给，则默认：天为1，其余为0：

var allFives = new Date(Date.UTC(2005, 4, 5, 17, 55, 55));
// 简便创建方法
var allFives = new Date(2005, 4, 5, 17, 55, 55);

另外ECMAScript 5还添加了Date.now() 方法，可以返回调用函数的精确时间。
除此之外，Date还有很多方法如时间格式化方法等等，很多，不再赘述。

RegExp类型

<待续>