JavaScript引用类型

JavaScript引用类型

Object类型

创建 Object 实例的方式有两种，第一种是使用 new 操作符后跟 Object 构造函数，如下所示

var person = new Object(); 
person.name = "Nicholas"; 
person.age = 29;

另一种方式是使用对象字面量表示法:

var person = { 
 name : "Nicholas", 
 age : 29 
};

使用对象字面量语法时，如果留空其花括号，则可以定义只包含默认属性和方法的对象，如下所示：

var person = {}; //与 new Object()相同
person.name = "Nicholas"; 
person.age = 29;

访问对象属性：
一般来说，访问对象属性时使用的都是点表示法，这也是很多面向对象语言中通用的语法，不过，在 JavaScript 也可以使用方括号表示法来访问对象的属性

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

一般使用点表示法，在下列情况下使用方括号表示法：

• 如果属性名中包含会导致语法错误的字符
• 属性名使用的是关键字或保留字

person["first name"] = "Nicholas"; 
由于"first name"中包含一个空格，
所以不能使用点表示法来访问它。
然而，属性名中是可以包含非字母非数字的，
这时候就可以使用方括号表示法来访问它们。

通常，除非必须使用变量来访问属性，否则我们建议使用点表示法。

Array类型

ECMAScript 数组的每一项可以保存任何类型的数据。也就是说，可以用数组的第一个位置来保存字符串，用第二位置来保存数值，用第三个位置来保存对象，以此类推。而且，ECMAScript 数组的大小是可以动态调整的，即可以随着数据的添加自动增长以容纳新增数据。
创建方式
第一种是使用Array构造函数，例如

var colors = new Array();

也可以给构造函数传递数量，创建length长度的数组。例如：

var colors = new Array(20);

也可以向数组构造函数中传递数组中包含的项，例如：

var colors = new Array("red","blue","green");

在使用Array构造函数时也可以省略new 操作符。例如：

var colors = Array();

第二种是使用数组字面量表示法。例如：

var colors = ["red","blue","green"];

在读取和设置数组的值时，要使用方括号并提供相应值的基于 0 的数字索引，如下所示：

var colors = ["red", "blue", "green"]; 
alert(colors[0]); // 显示第一项
colors[2] = "black"; // 修改第三项
colors[3] = "brown"; // 新增第四项

转换方法：

如前所述，所有对象都具有 toLocaleString()、toString()和 valueOf()方法。其中，调用数组的 toString()方法会返回由数组中每个值的字符串形式拼接而成的一个以逗号分隔的字符串。而调用 valueOf()返回的还是数组

var colors = ["red", "blue", "green"]; // 创建一个包含 3 个字符串的数组
alert(colors.toString()); // red,blue,green 
alert(colors.valueOf()); // red,blue,green 
alert(colors); // red,blue,gree

在这里，我们首先显式地调用了 toString()方法，以便返回数组的字符串表示，每个值的字符串表示拼接成了一个字符串，中间以逗号分隔。接着调用 valueOf()方法，而最后一行代码直接将数组传递给了 alert()。由于 alert()要接收字符串参数，所以它会在后台调用 toString()方法，由此会得到与直接调用 toString()方法相同的结果。

栈方法：

ECMAScript为数组专门提供了push()、pop()方法，以便实现类似栈（后进先出）的行为。
push():接收任意数量的参数，把他们逐个添加到数组末尾，并返回修改后数组的长度。
pop():则从数组末尾移除最后一项，减少数组的length值，然后返回移除的项。例如：

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

队列方法：

队列数据结构的访问规则是 FIFO（First-In-First-Out，先进先出），主要使用shift()和push()实现

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()方法。顾名思义，unshift()与 shift()的用途相反：它能在数组前端添加任意个项并返回新数组的长度。因此，同时使用 unshift()和 pop()方法，可以从相反的方向来模拟队列，即在数组的前端添加项，从数组末端移除项，如下面的例子所示:

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

重排序方法：

数组中存在两个可以直接用来可以重排序的方法：reverse()、sort()。

var values = [1, 2, 3, 4, 5]; 
values.reverse(); 
alert(values); //5,4,3,2,1

sort()方法比较的是字符串

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

操作方法：

1.concat:在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。如果传递给 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

2.slice():它能够基于当前数组中的一或多个项创建一个新数组。slice()方法可以接受一或两个参数，即要返回项的起始和结束位置

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():

• 删除：可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。
  例如，splice(0,2)会删除数组中的前两项
• 插入：可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、0（要删除的项数）和要插入的项。如果要插入多个项，可以再传入第四、第五，以至任意多个项。
  例如，splice(2,0,“red”,“green”)会从当前数组的位置 2 开始插入字符串"red"和"green"。
• 替换：可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。
  例如，splice (2,1,“red”,“green”)会删除当前数组位置 2 的项，然后再从位置 2 开始插入字符串"red"和"green"。

位置方法：

位置方法
ECMAScript5为数组实例添加了两个位置方法：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

迭代方法：

• every()：对数组中的每一项运行给定函数，如果该函数对每一项都返回 true，则返回 true。  filter()：对数组中的每一项运行给定函数，返回该函数会返回 true 的项组成的数组。
• forEach()：对数组中的每一项运行给定函数。这个方法没有返回值。
• map()：对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。
• some()：对数组中的每一项运行给定函数，如果该函数对任一项返回 true，则返回 true。
  以上方法都不会修改数组中的包含的值

Date类型：

要创建一个日期对象，使用 new 操作符和 Date 构造函数即可，如下所示。

var now = new Date();

Date.UTC()的参数分别是年份、基于 0 的月份（一月是 0，二月是 1，以此类推）、月中的哪一天（1 到 31）、小时数（0 到 23）、分钟、秒以及毫秒数。在这些参数中，只有前两个参数（年和月）是必需的。如果没有提供月中的天数，则假设天数为 1；如果省略其他参数，则统统假设为 0。以下是两个使用 Date.UTC()方法的例子：

// GMT 时间 2000 年 1 月 1 日午夜零时
var y2k = new Date(Date.UTC(2000, 0)); 
// GMT 时间 2005 年 5 月 5 日下午 5:55:55 
var allFives = new Date(Date.UTC(2005, 4, 5, 17, 55, 55));

RegExp类型：

使用下面类似 Perl 的语法，就可以创建一个正则表达式。

var expression = / pattern / flags
其中的模式（pattern）部分可以是任何简单或复杂的正则表达式，可以包含字符类、限定符、分组、向前查找以及反向引用。每个正则表达式都可带有一或多个标志（flags），用以标明正则表达式的行为。正则表达式的匹配模式支持下列 3 个标志:

• g：表示全局（global）模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即
  停止；
• i：表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写；
• m：表示多行（multiline）模式，即在到达一行文本末尾时还会继续查找下一行中是否存在与模式匹配的项。

Function类型：

每个函数都是 Function 类型的实例，而且都与其他引用类型一样具有属性和方法。由于函数是对象，因此函数名实际上也是一个指向函数对象的指针，不会与某个函数绑定
定义函数有三种方式：
方式一，使用函数声明语法定义：

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

方式二，使用函数表达式定义：

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

方式三，使用function构造函数定义，function构造函数可以接收任意数量的参数，但最后一个参数始终是函数体：

var sum = new Function("num1","num2","return num1+num2");

没有重载
ECMAScript中没有重载，当声明了两个同名函数，后面的函数会覆盖前面的函数。

作为值的函数

不仅可以像传递参数一样把一个函数传递给另一个函数，而且可以将一个函数作为另一个函数的结果返回。

function callSomeFunction(someFunction, someArgument){
    return someFunction(someArgument);
}

函数的内部属性

在函数内部，有两个特殊的对象：arguments和this。
在使用递归算法时可以用到arguments.callee。

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

上面的函数和下面函数可以划等号，但下面函数可以消除上面紧密耦合的现象
this 引用的是函数执行的环境对象。，当在网页的全局作用域中调用函数时，this对象引用的就是window，之后调用this，他指向是上一次调用this的函数。

window.color = "red";
var o = {color:"blue"};
function sayColor(){
    alert(this.color);
}
sayColor();            //"red"
o.sayColor = sayColor;
o.sayColor();           //"blue"

函数的属性和方法：

每个函数包含两个属性：length和prototype。

• length:表示函数希望接受的命名参数的个数
• apply()方法接收两个参数：一个是运行的作用域，一个是参数数组，其中第二个参数可以是Array()的实例，也可以是arguments()对象。例如：

function sum(num1, num2){
    return num1+num2;
}
function callSum1(num1,num2){
    return sum.apply(this,arguments);
}
function callSum2(num1,num2){
    return sum.apply(this,[num1,num2]);
}
alert(callSum1(10,10));                //20
alert(callSum2(10,10));                 //20

call()和apply()的区别在于接收参数的方式不同，在使用call()方法时，传递给函数的参数必须逐个列举出来。例如：

function sum(num1, num2){
    return num1+num2;
}
function callSum(num1,num2){
    return sum.call(this,num1,num2);
}
alert(callSum(10,10));                //20

基本包装类型：

1.Boolean类型

Boolean 类型是与布尔值对应的引用类型。要创建 Boolean 对象，可以像下面这样调用 Boolean构造函数并传入 true 或 false 值。

var booleanObject = new Boolean(true);

Boolean 对象在 ECMAScript 中的用处不大，因为它经常会造成人们的误解。其中最常见的问题就是在布尔表达式中使用Boolean 对象

var falseObject = new Boolean(var result = falseObject && tralert(result); //true 
var falseValue = false; 
result = falseValue && true; 
alert(result); //false

alert(typeof falseObject); //object 
alert(typeof falseValue); //boolean 
alert(falseObject instanceof Boolean); //true 
alert(falseValue instanceof Boolean); //false

2.Number类型

Number 是与数字值对应的引用类型。要创建 Number 对象，可以在调用 Number 构造函数时向其中传递相应的数值。下面是一个例子。

var numberObject = new Number(10);

3.String类型

String 类型是字符串的对象包装类型，可以像下面这样使用 String 构造函数来创建。

var stringObject = new String(“hello world”);

String 类型的每个实例都有一个 length 属性，表示字符串中包含多个字符。来看下面的例子

var stringValue = "hello world"; 
alert(stringValue.length); //"11"

两个用于访问字符串中特定字符的方法是：charAt()（返回字符）和 charCodeAt()(返回字符编码)

var stringValue = "hello world"; 
alert(stringValue.charAt(1)); //"e"

var stringValue = "hello world"; 
alert(stringValue.charCodeAt(1)); //输出"101"

ECMAScript还提供了3个基于子字符串创建新字符串的方法：slice()、substr()、substring()，这3个方法都会返回操作字符串的一个新字符串，slice()和substring()的第二个参数指定的是子字符串最后一个字符后面的位置。而 substr()的第二个参数指定的则是返回的字符个数。如果没有给这些方法传递第二个参数，则将字符串的长度作为结束位置

var string = "hello world";

alert(string.slice(3));    //"lo world"
alert(string.slice(3,7));  //"lo w"

alert(string.substring(3)); //"lo world"
alert(string.substring(3,7)); //"lo w"

alert(string.substr(3));        //"lo world"
alert(string.substr(3,7));      //"lo worl"

有两个可以从字符串中查找子字符串的方法：indexOf()和 lastIndexOf()。这两个方法都是从一个字符串中搜索给定的子字符串，然后返子字符串的位置（如果没有找到该子字符串，则返回-1）,这两个方法的区别在于：indexOf()方法从字符串的开头向后搜索子字符串，而 lastIndexOf()方法是从字符串的末尾向前搜索子字符串

var stringValue = "hello world"; 
alert(stringValue.indexOf("o")); //4 
alert(stringValue.lastIndexOf("o")); //7

trim()方法会创建一个字符串的副本，删除前置和后缀所有的空格，然后返回结果。例如：

var string = "  hello world  ";
alert(string.trim());         //"hello world"

字符串大小写转换方法
toLowerCase()和toUpperase()时两个经典的方法。例如：

var string = "hello world";
alert(string.toUpperCase());       //"HELLO WORLD"
alert(string.toLowerCase());       //"hello world"

localeCompare()方法
与操作字符串有关的最后一个方法是 localeCompare()，这个方法比较两个字符串，并返回下列值中的一个：

• 如果字符串在字母表中应该排在字符串参数之前，则返回一个负数（大多数情况下是-1，具体
  的值要视实现而定）；
• 如果字符串等于字符串参数，则返回 0；
• 如果字符串在字母表中应该排在字符串参数之后，则返回一个正数（大多数情况下是 1，具体的值同样要视实现而定）

var stringValue = "yellow"; 
alert(stringValue.localeCompare("brick")); //1 
alert(stringValue.localeCompare("yellow")); //0 
alert(stringValue.localeCompare("zoo")); //-1

fromCharCode():这个方法的任务是接收一或
多个字符编码，然后将它们转换成一个字符串

alert(String.fromCharCode(104, 101, 108, 108, 111)); //"hello"

Math对象

Math 对象包含的属性大都是数学计算中
可能会用到的一些特殊值。下表列出了这些属性

属性	方法
Math.E	自然对数的底数，即常量e的值
Math.LN10	10的自然对数
Math.LN2	2的自然对数
Math.LOG2E	以2为底e的对数
Math.LOG10E	以10为底e的对数
Math.PI	π的值
Math.SQRT1_2	1/2的平方根（即2的平方根的倒数）
Math.SQRT2	2的平方根

Math 对象还包含许多方法，用于辅助完成简单和复杂的数学计算。
其中，min()和 max()方法用于确定一组数值中的最小值和最大值。这两个方法都可以接收任意多
个数值参数，如下面的例子所示

var max = Math.max(3, 54, 32, 16); 
alert(max); //54 
var min = Math.min(3, 54, 32, 16); 
alert(min); //3