第4天 Java基础语法

今日内容介绍

	流程控制语句（switch）

	数组

第1章	流程控制语句

1.1	选择结构switch
switch 条件语句也是一种很常用的选择语句，它和if条件语句不同，它只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。例如，在程序中使用数字1~7来表示星期一到星期天，如果想根据某个输入的数字来输出对应中文格式的星期值，可以通过下面的一段伪代码来描述：

用于表示星期的数字

如果等于1，则输出星期一

如果等于2，则输出星期二

如果等于3，则输出星期三

如果等于4，则输出星期四

如果等于5，则输出星期五

如果等于6，则输出星期六

如果等于7，则输出星期天

对于上面一段伪代码的描述，大家可能会立刻想到用刚学过得if…else if…else语句来实现，但是由于判断条件比较多，实现起来代码过长，不便于阅读。Java中提供了一种switch语句来实现这种需求，在switch语句中使用switch关键字来描述一个表达式，使用case关键字来描述和表达式结果比较的目标值，当表达式的值和某个目标值匹配时，会执行对应case下的语句。具体实现代码如下：
switch(用于表示星期的数字) {
    case 1 :
        输出星期一;
        break;
    case 2 :
        输出星期二;
        break;
    case 3 :
        输出星期三
        break;
    case 4 :
        输出星期四;
        break;
    case 5 :
        输出星期五;
        break;
    case 6:
        输出星期六;
        break;
    case 7:
        输出星期天;
        break;
}

	上面改写后的伪代码便描述了switch语句的基本语法格式，具体如下：
switch (表达式){
	case 目标值1:
		执行语句1
		break;
	case 目标值2:
		执行语句2
		break;
	．．．．．．
	case 目标值n:
		执行语句n
		break;
	default:
		执行语句n+1
		break;
}

在上面的格式中，switch语句将表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，会执行对应case后的语句，如果没找到任何匹配的值，就会执行default后的语句。switch语句中的break关键字将在后面的做具体介绍，此处，我们只需要知道break的作用是跳出switch语句即可。

需要注意的是，在switch语句中的表达式只能是byte、short、char、int类型的值，如果传入其它类型的值，程序会报错。但上述说法并不严谨，实际上在JDK5.0中引入的新特性enum枚举也可以作为switch语句表达式的值，在JDK7.0中也引入了新特性，switch语句可以接收一个String类型的值。
1.2	选择结构switch练习
接下来通过一个案例演示根据数字来输出中文格式的星期，如下所示。SwitchDemo01.java
public class SwitchDemo01 {
	public static void main(String[] args) {
		int week = 5;
		switch (week) {
		case 1:
			System.out.println("星期一");
			break;
		case 2:
			System.out.println("星期二");
			break;
		case 3:
			System.out.println("星期三");
			break;
		case 4:
			System.out.println("星期四");
			break;
		case 5:
			System.out.println("星期五");
			break;
		case 6:
			System.out.println("星期六");
			break;
		case 7:
			System.out.println("星期天");
			break;
		default:
			System.out.println("输入的数字不正确...");
			break;
		}
	}
}

运行结果如图所示。

 图1-1	运行结果

上述代码中，由于变量week的值为5，整个switch语句判断的结果满足第17行的条件，因此打印“星期五”，例程中的default语句用于处理和前面的case都不匹配的值，将第3行代码替换为int week = 8，再次运行程序，输出结果如下图所示。

 图1-2	运行结果

在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式。例如，要判断一周中的某一天是否为工作日，同样使用数字1~7来表示星期一到星期天，当输入的数字为1、2、3、4、5时就视为工作日，否则就视为休息日。接下来通过一个案例来实现上面描述的情况，如下所示。SwitchDemo02.java
public class SwitchDemo02 {
	public static void main(String[] args) {
		int week = 2;
		switch (week) {
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			// 当 week 满足值 1、2、3、4、5 中任意一个时，处理方式相同
			System.out.println("今天是工作日");
			break;
		case 6:
		case 7:
			// 当 week 满足值 6、7 中任意一个时，处理方式相同
			System.out.println("今天是休息日");
			break;
		}
	}
}

运行结果如下图所示。



图1-3	运行结果

上述代码中，当变量week值为1、2、3、4、5中任意一个值时，处理方式相同，都会打印“今天是工作日”。同理，当变量week值为6、7中任意一个值时，打印“今天是休息日”。

第2章	数组
在生活中，我们可能会碰到如下的场景。

现在需要统计某公司员工的工资情况，例如计算平均工资、最高工资等。假设该公司有50名员工，用前面所学的知识完成，那么程序首先需要声明50个变量来分别记住每位员工的工资，这样做会显得很麻烦。

其实在Java中，我们可以使用一个数组来记住这50名员工的工资。数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。
2.1	数组的定义
在Java中，可以使用以下格式来定义一个数组。如下

数据类型[] 数组名 = new 数据类型[元素个数或数组长度];

int[] x = new int[100];

上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。为了更好地理解数组的这种定义方式，可以将上面的一句代码分成两句来写，具体如下：

int[] x;	          // 声明一个int[]类型的变量

x = new int[100];	// 创建一个长度为100的数组

接下来，通过两张内存图来详细地说明数组在创建过程中内存的分配情况。

第一行代码 int[] x; 声明了一个变量x，该变量的类型为int[]，即一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。内存中的状态如下图所示。



图1-4	内存状态图

第二行代码 x = new int[100]; 创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x来引用数组，这时内存中的状态会发生变化，如下图所示。

 图1-5	内存状态图

在上图中描述了变量x引用数组的情况。该数组中有100个元素，初始值都为0。数组中的每个元素都有一个索引(也可称为角标)，要想访问数组中的元素可以通过“x[0]、x[1]、……、x[98]、x[99]”的形式。需要注意的是，数组中最小的索引是0，最大的索引是“数组的长度-1”。在Java中，为了方便我们获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。

接下来，通过一个案例来演示如何定义数组以及访问数组中的元素，如下所示。ArrayDemo01.java
 1	public class ArrayDemo01 {
 2		public static void main(String[] args) {
 3			int[] arr; // 声明变量
 4			arr = new int[3]; // 创建数组对象
 5			System.out.println("arr[0]=" + arr[0]); // 访问数组中的第一个元素
 6			System.out.println("arr[1]=" + arr[1]); // 访问数组中的第二个元素
 7			System.out.println("arr[2]=" + arr[2]); // 访问数组中的第三个元素
 8			System.out.println("数组的长度是：" + arr.length); // 打印数组长度
 9		}
 10	}

运行结果如下图所示。



图1-6	运行结果

在上述代码中声明了一个int[]类型变量arr，并将数组在内存中的地址赋值给它。在5~7行代码中通过角标来访问数组中的元素，在第8行代码中通过length属性访问数组中元素的个数。从打印结果可以看出，数组中的三个元素初始值都为0，这是因为当数组被成功创建后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的。具体如下表所示。

表2-1	元素默认值




数据类型
默认初始化值




byte、short、int、long
0


float、double
0.0


char
一个空字符（空格），即’\u0000’


boolean
false


引用数据类型
null，表示变量不引用任何对象


如果在使用数组时，不想使用这些默认初始值，也可以显式地为这些元素赋值。接下来通过一个程序来学习如何为数组的元素赋值，如下所示。ArrayDemo02.java
 1	public class ArrayDemo02 {
 2		public static void main(String[] args) {
 3			int[] arr = new int[4]; // 定义可以存储4个整数的数组
 4			arr[0] = 1; // 为第1个元素赋值1
 5			arr[1] = 2; // 为第2个元素赋值2
 6			// 下面的代码是打印数组中每个元素的值
 7			System.out.println("arr[0]=" + arr[0]);
 8			System.out.println("arr[1]=" + arr[1]);
 9			System.out.println("arr[2]=" + arr[2]);
 10			System.out.println("arr[3]=" + arr[3]);
 11		}
 12	}

运行结果如下图所示。



图1-7	运行结果

在上述代码中，第3行代码定义了一个数组，此时数组中每个元素都为默认初始值0。第2、3行代码通过赋值语句将数组中的元素arr[0]和arr[1]分别赋值为1和2，而元素arr[2]和arr[3]没有赋值，其值仍为0，因此打印结果中四个元素的值依次为1、2、0、0。

在定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。

在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式，具体格式如下：
1、类型[] 数组名 = new 类型[]{元素，元素，……};
2、类型[] 数组名 = {元素，元素，元素，……};	   

上面的两种方式都可以实现数组的静态初始化，但是为了简便，建议采用第二种方式。接下来通过一段代码来演示数组静态初始化的效果，如下所示。ArrayDemo03.java
 1	public class ArrayDemo03 {
 2		public static void main(String[] args) {
 3			int[] arr = { 1, 2, 3, 4 }; // 静态初始化
 4			// 下面的代码是依次访问数组中的元素
 5			System.out.println("arr[0] = " + arr[0]);
 6			System.out.println("arr[1] = " + arr[1]);
 7			System.out.println("arr[2] = " + arr[2]);
 8			System.out.println("arr[3] = " + arr[3]);
 9		}
 10	}

运行结果如下图所示。



图1-8	运行结果

上述代码中采用静态初始化的方式为数组每个元素赋予初值，分别是1、2、3、4。需要注意的是，第3行代码千万不可写成int[] arr = new int[4]{1,2,3,4};，这样写编译器会报错。原因在于编译器会认为数组限定的元素个数[4]与实际存储的元素{1,2,3,4}个数有可能不一致，存在一定的安全隐患。
2.2	数组遍历
在操作数组时，经常需要依次访问数组中的每个元素，这种操作称作数组的遍历。接下来通过一个案例来学习如何使用for循环来遍历数组，如下所示。ArrayDemo04.java
public class ArrayDemo04 {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
		// 使用for循环遍历数组的元素
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]); // 通过索引访问元素
		}
	}
}

运行结果如下图所示。



图1-9	运行结果

上述代码中，定义一个长度为5的数组arr，数组的角标为04。由于for循环中定义的变量i的值在循环过程中为04，因此可以作为索引，依次去访问数组中的元素，并将元素的值打印出来。
2.3	数组的常见问题
数组在编写程序时应用非常广泛，灵活地使用数组对实际开发很重要。接下来，本节将针对数组的常见操作进行详细地讲解，如数组的遍历、最值的获取、数组的排序等。
2.3.1	数组最值
在操作数组时，经常需要获取数组中元素的最值。接下来通过一个案例来演示如何获取数组中元素的最大值，如下所示。ArrayDemo05.java
public class ArrayDemo05 {
	public static void main(String[] args) {
		int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定义一个数组
int max = arr[0]; // 定义变量max用于记住最大数，首先假设第一个元素为最大值
		// 下面通过一个for循环遍历数组中的元素
		for (int x = 1; x < arr.length; x++) {
			if (arr[x] > max) { // 比较 arr[x]的值是否大于max
				max = arr[x]; // 条件成立，将arr[x]的值赋给max
			}
		}
		System.out.println("max=" + max); // 打印最大值
	}
}

运行结果如下图所示。



图1-10	运行结果

上述代码中，定义了一个临时变量max，用于记住数组的最大值。通过for 循环获取数组中的最大值，赋值给max变量。

首先假设数组中第一个元素arr[0]为最大值，然后使用for循环对数组进行遍历，在遍历的过程中只要遇到比max值还大的元素，就将该元素赋值给max。这样一来，变量max就能够在循环结束时记住数组中的最大值。需要注意的是，在for循环中的变量i是从1开始的，这样写的原因是程序已经假设第一个元素为最大值，for循环中只需要从第二个元素开始比较，从而提高程序的运行效率。
2.3.2	数组异常
2.3.2.1	数组越界异常

每个数组的索引都有一个范围，即0~length-1。在访问数组的元素时，索引不能超出这个范围，否则程序会报错，如下所示。ArrayDemo06.java
 1	public class ArrayDemo06 {
 2		public static void main(String[] args) {
 3			int[] arr = new int[4]; // 定义一个长度为4的数组
 4			System.out.println("arr[0]=" + arr[4]); // 通过角标4访问数组元素
 5		}
 6	}

运行结果如下图所示。



上图运行结果中所提示的错误信息是数组越界异常ArrayIndexOutOfBoundsException，出现这个异常的原因是数组的长度为4，其索引范围为0~3，而上述代码中的第4行代码使用索引4来访问元素时超出了数组的索引范围。

所谓异常指程序中出现的错误，它会报告出错的异常类型、出错的行号以及出错的原因，关于异常在后面的章节会有详细地讲解。
2.3.2.2	空指针异常

在使用变量引用一个数组时，变量必须指向一个有效的数组对象，如果该变量的值为null，则意味着没有指向任何数组，此时通过该变量访问数组的元素会出现空指针异常，接下来通过一个案例来演示这种异常，如下所示。ArrayDemo07.java
 1	public class ArrayDemo07 {
 2		public static void main(String[] args) {
 3			int[] arr = new int[3]; // 定义一个长度为3的数组
 4			arr[0] = 5; // 为数组的第一个元素赋值
 5			System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
 6			arr = null; // 将变量arr置为null
 7			System.out.println("arr[0]=" + arr[0]); // 访问数组的元素
 8		}
 9	}

运行结果如下图所示。



图1-11	运行结果

通过上图所示的运行结果可以看出，上述代码中第4、5行代码都能通过变量arr正常地操作数组。第6行代码将变量置为null，当第7行代码再次访问数组时就出现了空指针异常NullPointerException。

2.4	二维数组
在程序中可以通过一个数组来保存某个班级学生的考试成绩，试想一下，如果要统计一个学校各个班级学生的考试成绩，又该如何实现呢？这时就需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组。在程序中比较常见的就是二维数组，接下来针对二维数组进行详细地讲解。

2.4.1	二维数组的定义格式

二维数组的定义有很多方式，接下来针对几种常见的方式进行详细地讲解，具体如下：

第一种方式：

int[][] arr = new int[3][4];

上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组，接下来通过一个图来表示这种情况，如下图所示。




图1-12	二维数组

第二种方式：

int[][] arr = new int[3][];

第二种方式和第一种类似，只是数组中每个元素的长度不确定，接下来通过一个图来表示这种情况，如下图所示。



图1-13	二维数组

第三种方式：

int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};

上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}，接下来通过一个图来表示这种情况，如图2-54所示。



图1-14	二维数组

对二维数组中元素的访问也是通过角标的方式，如需访问二维数组中第一个元素数组的第二个元素，具体代码如下：

arr[0][1];

2.4.2	二维数组元素的访问

操作二维数组时，经常需要获取数组中元素的值。接下来通过一个案例来演示如何获取数组中元素值，如下所示。ArrayDemo08.java
class ArrayDemo08 {
	public static void main(String[] args){
	
		//定义二维数组的方式
		int[][] arr = new int[3][4];
	
		System.out.println( arr );
		System.out.println("二维数组的长度: " + arr.length);
		//获取二维数组的3个元素
		System.out.println( arr[0] );
		System.out.println( arr[1] );
		System.out.println( arr[2] );
		
		System.out.println("打印第一个一维数组的元素值");
		System.out.println( arr[0][0] );
		System.out.println( arr[0][1] );//访问的为二维数组中第1个一维数组的第2个元素
		System.out.println( arr[0][2] );
		System.out.println( arr[0][3] );
		
		System.out.println("打印第二个一维数组的元素值");
		System.out.println( arr[1][0] );
		System.out.println( arr[1][1] );
		System.out.println( arr[1][2] );
		System.out.println( arr[1][3] );
		
		System.out.println("打印第三个一维数组的元素值");
		System.out.println( arr[2][0] );
		System.out.println( arr[2][1] );
		System.out.println( arr[2][2] );
		System.out.println( arr[2][3] );
	}
}


运行结果如下图所示：



图1-15	运行结果

2.4.3	二维数组元素遍历与数组元素累加和
学习完了数组元素的访问，我们来学习下数组的遍历及数组的元素累加和操作。
class ArrayDemo09 {
	public static void main(String[] args){
		//一维数组的求累加和并遍历
		int[] arr = {10,20,30,40,50};
		int sum = 0; 
		for (int i=0; i<arr.length; i++) {
              //System.out.println(arr[i]);
			sum += arr[i];
		}
		System.out.println("sum= " + sum);
		System.out.println("---------------------");
		
//二维数组的求累加和并遍历
		int[][] arr2 = { {1,2},{3,4,5},{6,7,8,9,10} };
		int sum2 = 0;
		for (int i=0; i<arr2.length; i++) {
			for (int j=0; j<arr2[i].length; j++) {
                 //System.out.println(arr2[i][j])
				sum2 += arr2[i][j];
			}
		}
		System.out.println("sum2= "+ sum2);
	}
}


运行结果如下图所示：



图1-16	运行结果

2.4.4	公司销售总和练习

接下来通过一个案例来熟悉二维数组的使用。

例如要统计一个公司三个销售小组中每个小组的总销售额以及整个公司的销售额。如下所示

	第一小组销售额为{11, 12}万元

	第二小组销售额为{21, 22, 23}万元

	第三小组销售额为{31, 32, 33, 34}万元。

ArrayDemo08.java
 1	public class ArrayDemo10 {
 2		public static void main(String[] args) {
 3			int[][] arr = new int[3][]; // 定义一个长度为3的二维数组
 4			arr[0] = new int[] { 11, 12 }; // 为数组的元素赋值
 5			arr[1] = new int[] { 21, 22, 23 };
 6			arr[2] = new int[] { 31, 32, 33, 34 };
 7			
 8			int sum = 0; // 定义变量记录总销售额
 9			for (int i = 0; i < arr.length; i++) { // 遍历数组元素
 10				int groupSum = 0; // 定义变量记录小组销售总额
 11				for (int j = 0; j < arr[i].length; j++) { // 遍历小组内每个人的销售额
 12					groupSum = groupSum + arr[i][j];
 13				}
 14				sum = sum + groupSum; // 累加小组销售额
 15				System.out.println("第" + (i + 1) + "小组销售额为：" + groupSum + " 万元");
 16			}
 17			System.out.println("总销售额为: " + sum + " 万元");
 18		}
 19	}

运行结果如下图所示。



图1-17	运行结果

在上述代码中，第3行代码定义了一个长度为3的二维数组，并在4~6行代码中为数组的每个元素赋值。例程中还定义了两个变量sum和groupSum，其中sum用来记录公司的总销售额，groupSum用来记录每个销售小组的销售额。当通过嵌套for循环统计销售额时，外层循环对三个销售小组进行遍历，内层循环对每个小组员工的销售额进行遍历，内层循环每循环一次就相当于将一个小组员工的销售总额统计完毕，赋值给groupSum，然后把groupSum的值与sum的值相加赋值给sum。当外层循环结束时，三个销售小组的销售总额groupSum都累加到sum中，即统计出了整个公司的销售总额。


第3章	随机点名器案例
3.1	案例介绍

随机点名器，即在全班同学中随机的打印出一名同学名字。

要做的随机点名器，它具备以下3个内容：

	存储所有同学姓名

	总览全班同学姓名

	随机点名其中一人，打印到控制台

在编写案例前，我们先来学习下本案例中所涉及到的知识点：

	数组

3.2	案例需求分析

在全班同学中随机的打印出一名同学名字。

我们对本案例进行分析，得出如下分析结果：

1.存储全班同学名字

2.打印全班同学每一个人的名字

3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学名字

在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们可以使用数组解决多个数据的存储问题。
3.3	实现代码步骤

编写CallName.java文件，完成程序的编写。

	main方法中进行步骤1、2、3的代码实现
	public static void main(String[] args) {
		System.out.println("--------随机点名器--------");
		// 创建一个存储多个同学名字的容器（数组）
		String[] students = new String[3];
		
		//1.存储全班同学名字
		//2.打印全班同学每一个人的名字
		//3.获取随机点名到的学生姓名，并打印
	}

	1.存储所有同学姓名
	/**
	 * 1.存储全班同学名字
	 * 	创建一个存储多个同学名字的容器（数组） 
	 *  键盘输入每个同学的名字，存储到容器中（数组）
	 */
	//键盘输入多个同学名字存储到容器中
	Scanner sc = new Scanner(System.in);
	for (int i = 0; i < students.length; i++) {
		System.out.println("存储第"+i+"个名称：");
		students[i] = sc.next();
	}

	2.打印全班同学每一个人的名字
	/**
	 * 2打印全班同学每一个人的名字
	 */
	//遍历数组，得到每个同学名字
	for (int i = 0; i < students.length; i++) {
		String name = students[i];
		//打印同学名字
		System.out.println("第"+i+"个学生名称：" + name);
	}

	3.获取随机点名到的学生姓名，并打印
	/**
	 * 3.在班级总人数范围内，随机产生一个随机数
	 */
	//根据数组长度，获取随机索引
	int index = new Random().nextInt(students.length);
	//通过随机索引从数组中获取名称
	String name = students[index];
	//返回随机点到的名称
	上述代码中，通过随机数类Random产生一个从0到数组长度的随机索引。使用该索引获取students数组中对应的值，便得到了全班同学的随机姓名。


第4章	总结
4.1	知识点总结
	数组

	它是一个用来存储同一个数据类型多个元素的一个容器（数组长度是固定的，数组中存储的元素的数据类型要求一致）

	格式：

格式1：

数据类型[] 数组名 = new 数据类型[数组长度];

格式2:

数据类型[] 数组名 = new 数据类型[]{元素值1,元素值2,…};

格式3：

数据类型[] 数组名 = {元素值1,元素值2,…};

	数组操作的常见问题：

NullPointerException: 空指针异常

ArrayIndexOutOfBoundsException: 数组越界异常
	二维数组：

	它是一个包含多个一维数组的数组

	特点：二维数组中的每个元素都是一个一维数组

	格式：

格式1：

数据类型[][] 数组名 = new 数据类型[m][n];

m: 代表二维数组中一维数组的个数

n: 代表每个一维数组中元素的个数

格式2：

数据类型[][] 数组名 = new 数据类型[m][];	

m: 代表二维数组中一维数组的个数

每一个一维数组通过赋值来确定数组长度

格式3：

数据类型[][] 数组名 = {{元素值1，元素值2,…},{元素值1，元素值2,…},…};

首先给大家介绍javascript jquery中定义数组与操作的相关知识，具体内容如下所示：
1.认识数组
数组就是某类数据的集合，数据类型可以是整型、字符串、甚至是对象

Javascript不支持多维数组，但是因为数组里面可以包含对象（数组也是一个对象），所以数组可以通过相互嵌套实现类似多维数组的功能
1.1 定义数组
声明有10个元素的数组
复制代码 代码如下:


var a = new Array(10);

此时为a已经开辟了内存空间，包含10个元素，用数组名称加 [下标] 来调用，例如 a[2] 但此时元素并未初始化，调用将返回 undefined
以下代码定义了个可变数组，并进行赋值
复制代码 代码如下:


var a = new Array();

a[0] = 10;

a[1] = "aaa";

a[2] = 12.6;

上面提过了，数组里面可以放对象，例如下面代码



?

1
2
3
4
5



var 
a =  new Array();
a[0]  = true;
a[1]  = document.getElementByIdx_x("text");
a[2]  = {x:11, y:22};
a[3]  = new
Array();





数组可以实例化的时候直接赋值，例如



?

1
2



var 
a = new Array(1, 2, 3, 4, 5);
var 
b = [1, 2, 3, 4, 5];





a 和 b 都是数组，只不过b用了隐性声明，创建了另一个实例，此时如果用alert(a==b)将弹出false
1.2 多维数组
其实Javascript是不支持多维数组的，在asp里面可以用 dim a(10,3)来定义多维数组，在Javascript里面，如果用 var a = new Array(10,3) 将报错

但是之前说过，数组里面可以包含对象，所以可以把数组里面的某个元素再声明为数组，例如



?

1
2
3
4



var 
a = new Array();
a[0] = new
Array();
a[0][0] = 1;
alert(a[0][0]); 
//弹出 1





声明的时候赋值



?

1
2



var 
a = new Array([1,2,3], [4,5,6],  [7,8,9]);
var 
b = [[1,2,3], [4,5,6], [7,8,9]];





效果一样，a采用常规实例化，b是隐性声明，结果都是生成一个多维数组
1.3 Array literals
这个还真不知中文怎么叫，文字数组？

说到数组，不得不说到Array Literals，数组其实是特殊的对象，对象有特有属性和方法，通过 对象名.属性 、对象.方法() 来取值和调用，而数组是通过下标来取值，Array Literals跟数组有很多相似，都是某数据类型的集合，但是Array Literals从根本来说，是个对象，声明和调用，跟数组是有区别



?

1
2
3
4



var 
aa = new Object();
aa.x = "cat";
aa.y = "sunny";
alert(aa.x);  
//弹出cat





创建一个简单的对象，一般调用是通过aa.x，而如果当成Array literals的话，用alert(aa[“x”])一样会弹出cat



?

1
2



var 
a = {x:"cat",  y:"sunny"};
alert(a["y"]);
//弹出sunny





这是另一种创建对象的方法，结果是一样的
2.数组元素的操作
上面已经说过，可以通过 数组[下标] 来读写元素
下标的范围是 0 – (23(上标2) -1)，当下标是负数、浮点甚至布尔值的时候，数组会自动转换为对象类型，例如



?

1
2
3



var 
b  = new Array();
b[2.2]  = "XXXXX";
alert(b[2.2]); 
//-> XXXXX





此时相当于b[“2.2”] = “XXXXX”
2.1数组的循环



?

1
2
3
4



var 
a = [1,2,3,4,5,6];
for(var
i =0; i<a.length; i++){
alert(a[i]);
}





这是最常用的，历遍数组，代码将依次弹出1至6
还有一种常用的



?

1
2
3
4



var 
a = [1,2,3,4,5,6];
for(var
e in 
a){
alert(e);
}





还是依次弹出1至6，for…in是历遍对象（数组是特殊的对象）对象，用在数组上，因为数组没有属性名，所以直接输出值，这结构语句用在对象上，例如下面



?

1
2
3
4



var 
a = {x:1,y:2,z:3};
for(var
e in 
a){
alert(e  + ":"
+ a[e]);
}





此时e取到的是属性名，即 x、y、x，而要取得值，则采用 数组名[属性]，所以 a[e] 等同于 a[“x”]、a[“y”]、a[“z”]
2.2数组常用函数
concat
在现有数组后面追加数组，并返回新数组，不影响现有数组



?

1
2
3
4
5
6
7
8
9
10



var 
a = [123];
var 
b = "sunnycat";
var 
c =  ["www",21,"ido"];
var 
d = {x:3.14, y:"SK"};
var 
e = [1,2,3,4,[5,6,[7,8]]];
alert(a.concat(b));  
// -> 123,sunnycat
alert(a); //  -> 123
alert(b.concat(c, d));   
// -> sunnycatwww,21,ido[object  Object]
alert(c.concat(b));  
// -> www,21,ido,sunnycat
alert(e.concat(11,22,33).join(" #  "));   
// -> 1 # 2 # 3  # 4 # 5,6,7,8 # 11 # 22 # 33





需要注意的是只能用于数组或字符串，如果被连接（前面的a）的是数值、布尔值、对象，就会报错，字符串连接数组时，字符串会跟数组首元素拼接成新元素，而数组连接字符串则会追加新元素（这点我也不清楚原委，知情者请透露），对于数组里面包含数组、对象的，连接后保持原样
join
用指定间隔符连起来，把数组转为字符串



?

1
2
3



var 
a = ['a','b','c','d','e','f','g'];
lert(a.join(",")); 
// -> a,b,c,d,e,f,g 相当于a.toString()
alert(a.join(" x "));
// -> a x b x c x d x e x f x g





这个很容易理解，但需要注意的是只转换一维数组里面，如果数组里面还有数组，将不是采用join指定的字符串接，而是采用默认的toString()，例如



?

1
2



var 
a =  ['a','b','c','d','e','f','g',[11,22,33]];
alert(a.join(" * "));
// -> a * b * c * d * e * f * g *  11,22,33





数组里面的数组，并没用 * 连接
pop
删除数组最后一个元素，并返回该元素



?

1
2
3



var 
a =  ["aa","bb","cc"];
document.write(a.pop()); 
// -> cc
document.write(a);   
// -> aa, bb





如果数组为空，则返回undefined
push
往数组后面添加数组，并返回数组新长度



?

1
2
3
4
5



var 
a =  ["aa","bb","cc"];
document.write(a.push("dd")); 
// -> 4
document.write(a);   
// -> aa,bb,cc,dd
document.write(a.push([1,2,3]));
// -> 5
document.write(a);   
// -> aa,bb,cc,dd,1,2,3





跟concat的区别在于，concat不影响原数组，直接返回新数组，而push则直接修改原数组，返回的是数组新长度
sort
数组排序，先看个例子



?

1
2



var 
a = [11,2,3,33445,5654,654,"asd","b"];
alert(a.sort()); 
// -> 11,2,3,33445,5654,654,asd,b





结果是不是很意外，没错，排序并不是按整型大小，而是字符串对比，就是取第一个字符的ANSI码对比，小的排前面，相同的话取第二个字符再比，如果要按整型数值比较，可以这样



?

1
2
3
4
5



var 
a = [11,2,3,33445,5654,654];
a.sort(function(a,b) {
return 
a - b;
});
alert(a); //  -> 2,3,11,654,5654,33445





sort()方法有个可选参数，就是代码里的function，这是个简单的例子，不可对非数字进行排序，非数字需要多做判断，这里就不多讲
reverse
对数组进行反排序跟，sort()一样，取第一字符ASCII值进行比较



?

1
2



var 
a = [11,3,5,66,4];
alert(a.reverse()); 
// -> 4,66,5,3,11





如果数组里面还包含数组，则当为对象处理，并不会把元素解出来



?

1
2
3



>var
a = ['a','b','c','d','e','f','g',[4,11,33]];
alert(a.reverse()); 
// -> 4,11,33,g,f,e,d,c,b,a
alert(a.join(" * "));
// -> 4,11,33 * g * f * e * d * c * b * a





按理应该是11排最后面，因为这里把 4,11,33 当做完整的对象比较，所以被排在第一位。看不明白的话，用join()串起来，就明了多
shift
删除数组第一个元素，并返回该元素，跟pop差不多



?

1
2
3



var 
a =  ["aa","bb","cc"];
document.write(a.shift()); 
// -> aa
document.write(a);   
// -> bb,cc





当数组为空时，返回undefined
unshift
跟shift相反，往数组最前面添加元素，并返回数组新长度



?

1
2
3
4
5
6
7



var 
a =  ["aa","bb","cc"];
document.write(a.unshift(11)); 
// -> 4 注：IE下返回undefined
document.write(a);   
// -> 11,aa,bb,cc
document.write(a.unshift([11,22])); 
// -> 5
document.write(a);   
// -> 11,22,11,aa,bb,cc
document.write(a.unshift("cat"));
// -> 6
document.write(a);   
// -> cat,11,22,11,aa,bb,cc





注意该方法，在IE下将返回undefined，貌似微软的bug，我在firefox下则能正确发挥数组新长度
slice
返回数组片段



?

1
2
3
4
5



var 
a = ['a','b','c','d','e','f','g'];
alert(a.slice(1,2));
// -> b
alert(a.slice(2));  
// -> c,d,e,f,g
alert(a.slice(-4)); 
// -> d,e,f,g
alert(a.slice(-2,-6)); 
// -> 空





a.slice(1,2)，从下标为1开始，到下标为2之间的数，注意并不包括下标为2的元素

如果只有一个参数，则默认到数组最后

-4是表示倒数第4个元素，所以返回倒数的四个元素

最后一行，从倒数第2开始，因为是往后截取，所以显然取不到前面的元素，所以返回空数组，如果改成 a.slice(-6,-2) 则返回b,c,d,e
splice
从数组删除某片段的元素，并返回删除的元素



?

1
2
3
4
5
6
7
8
9
10
11
12
13



var 
a = [1,2,3,4,5,6,7,8,9];
document.write(a.splice(3,2)); 
// -> 4,5
document.write(a);   
// -> 1,2,3,6,7,8,9
document.write(a.splice(4));
// -> 7,8,9 注：IE下返回空
document.write(a);   
// -> 1,2,3,6
document.write(a.splice(0,1)); 
// -> 1
document.write(a);   
// -> 2,3,6
document.write(a.splice(1,1,["aa","bb","cc"])); 
// -> 3
document.write(a);   
// -> 2,aa,bb,cc,6,7,8,9
document.write(a.splice(1,2,"ee").join("#"));
// -> aa,bb,cc#6
document.write(a);   
// -> 2,ee,7,8,9
document.write(a.splice(1,2,"cc","aa","tt").join("#"));
// -> ee#7
document.write(a);   
// -> 2,cc,aa,tt,8,9





注意该方法在IE下，第二个参数是必须的，不填则默认为0，例如a.splice(4)，在IE下则返回空，效果等同于a.splice(4,0)
toString
把数组转为字符串，不只数组，所有对象均可使用该方法



?

1
2
3
4
5
6
7
8



var 
a =  [5,6,7,8,9,["A","BB"],100];
document.write(a.toString()); 
// -> 5,6,7,8,9,A,BB,100
var 
b = new Date()
document.write(b.toString()); 
// -> Sat Aug 8 17:08:32 UTC+0800  2009
var 
c = function(s){
alert(s);
}
document.write(c.toString()); 
// -> function(s){ alert(s); }





布尔值则返回true或false，对象则返回[object objectname]

相比join()方法，join()只对一维数组进行替换，而toString()则把整个数组（不管一维还是多维）完全平面化

同时该方法可用于10进制、2进制、8进制、16进制转换，例如



?

1
2
3
4



var 
a =  [5,6,7,8,9,"A","BB",100];
for(var
i=0; i<a.length; i++){
document.write(a[i].toString()  +
" 的二进制是 "  + a[i].toString(2) +
" ，八进制是 " + a[i].toString(8) +
" ，十六进制是 " + a[i].toString(16));
//  -> 4,5
}





输出结果
5 的二进制是 101 ，八进制是 5 ，十六进制是 5

6 的二进制是 110 ，八进制是 6 ，十六进制是 6

7 的二进制是 111 ，八进制是 7 ，十六进制是 7

8 的二进制是 1000 ，八进制是 10 ，十六进制是 8

9 的二进制是 1001 ，八进制是 11 ，十六进制是 9

A 的二进制是 A ，八进制是 A ，十六进制是 A

BB 的二进制是 BB ，八进制是 BB ，十六进制是 BB

100 的二进制是 1100100 ，八进制是 144 ，十六进制是 64
转换只能在元素进行，如果对整个数组进行转换，则原封不动返回该数组
toLocaleString
返回本地格式字符串，主要用在Date对象上



?

1
2
3
4



var 
a = new Date();
document.write(a.toString()); 
// -> Sat Aug 8 17:28:36 UTC+0800  2009
document.write(a.toLocaleString()); 
// -> 2009年8月8日 17:28:36
document.write(a.toLocaleDateString()); 
// -> 2009年8月8日





区别在于，toString()返回标准格式，toLocaleString()返回本地格式完整日期（在【控制面板】>>【区域和语言选项】，通过修改[时间]和[长日期]格式），toLocaleDateString()跟toLocaleString()一样，只是少了时间
valueOf
根据不同对象返回不同原始值，用于输出的话跟toString()差不多，但是toString()是返回string类型，而valueOf()是返回原对象类型



?

1
2
3
4
5
6
7
8
9
10
11
12
13
14



var 
a = [1,2,3,[4,5,6,[7,8,9]]];
var 
b = new Date();
var 
c = true;
var 
d = function(){
alert("sunnycat");
};
document.write(a.valueOf()); 
// -> 1,2,3,4,5,6,7,8,9
document.write(typeof
(a.valueOf())); // -> object
document.write(b.valueOf()); 
// -> 1249874470052
document.write(typeof(b.valueOf()));
// -> number
document.write(c.valueOf()); 
// -> true
document.write(typeof(c.valueOf()));
// -> boolean
document.write(d.valueOf()); 
// -> function () {  alert("sunnycat"); }
document.write(typeof(d.valueOf()));
// -> function





数组也是对象，所以typeof (a.valueOf())返回object，返回的依然是个多维数组



?

1
2
3



var 
a = [1,2,3,[4,5,6,[7,8,9]]];
var 
aa = a.valueOf();
document.write(aa[3][3][1]);
// -> 8





Date对象返回的是距离1970年1月1日的毫秒数，

Math和Error对象没有valueOf方法
Jquery 数组操作
在jquery中处理JSON数组的情况中遍历用到的比较多，但是用添加移除这些好像不是太多。

今天试过json[i].remove(),json.remove(i)之后都不行，看网页的DOM对象中好像JSON数据是以数组的形式出现的，查阅了下相关JS中数组的操作一试果然很爽。

记录下来。

1、数组的创建




?

1
2
3



var 
arrayObj = new Array();　//创建一个数组
var 
arrayObj = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度
var 
arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);　创建一个数组并赋值





    要说明的是，虽然第二种方法创建数组指定了长度，但实际上所有情况下数组都是变长的，也就是说即使指定了长度为5，仍然可以将元素存储在规定长度以外的，注意：这时长度会随之改变。

2、数组的元素的访问




?

1
2



var 
testGetArrValue=arrayObj[1]; //获取数组的元素值
arrayObj[1]= 
"这是新值"; //给数组元素赋予新的值





3、数组元素的添加




?

1
2
3



arrayObj. push([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组结尾，并返回数组新长度
arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度
arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);//将一个或多个新元素插入到数组的指定位置，插入位置的元素自动后移，返回""





4、数组元素的删除




?

1
2
3



arrayObj.pop(); 
//移除最后一个元素并返回该元素值
arrayObj.shift(); 
//移除最前一个元素并返回该元素值，数组中元素自动前移
arrayObj.splice(deletePos,deleteCount);
//删除从指定位置deletePos开始的指定数量deleteCount的元素，数组形式返回所移除的元素





5、数组的截取和合并




?

1
2



arrayObj.slice(start, [end]);
//以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素
arrayObj.concat([item1[, item2[, . . . [,itemN]]]]);
//将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组






6、数组的拷贝




?

1
2



arrayObj.slice(0); 
//返回数组的拷贝数组，注意是一个新的数组，不是指向
arrayObj.concat(); 
//返回数组的拷贝数组，注意是一个新的数组，不是指向





7、数组元素的排序
arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址

arrayObj.sort(); //对数组元素排序，返回数组地址

8、数组元素的字符串化

?

1
2



arrayObj.join(separator);
//返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开。
toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用



转载于：http://www.jb51.net/article/76601.htm

JavaScript中定义数组的两种主要方式（new Array()和[]方式）

new Array()
①可以用像JAVA的那种写法的方式定义，如

var arr = new Array()

这样定义了一个空数组

②可以填写一个数字作为构造时的参数，比如

var arr = new Array(5)

在控制台可以看见这个数组的内容是

[undefined × 5]

这是一个"稀疏数组"，通过直接改变数组length属性得到的元素数量少于数组的length的数组。

这种数组可以用

for(var i=0;i<arr.length;i++){

}

这种方式遍历，无法用

for(var e in arr){

}

的方式和

arr.forEach(function(e,i){

})

的方式遍历，可能会带来一些问题，应该避免稀疏数组的创建，所以不要使用

new Array(5)

这种创建方式，也不要直接改变数组的length属性。

③也可以用

var arr = new Array(1,2,3)

这种方式定义一个正常的数组


	
[]
	
构造器的方式定义数组了解了解就行，平时应该避免使用。

尽量使用中括号的方式定义数组，如

var arr=[1,2,3]

用这种方式可以得到一个正常的一个单位的数组，而不是所谓的“稀疏数组”

var arr=[1]

应该用哪种方式

多于一个初始元素时，2种方式定义的效果完全一样。

中括号方式定义有以下好处

程序更短，更易读；

初始元素为1个时也能正常定义。

所以大部分情况下应该使用中括号方式定义数组。



 

new Array(length)这种方式在某些特殊场合可以用到，比如可以很简洁的用一行得到一个0~99的范围的数组:

new Array(100).fill().map((e,i)=>i)



 

如果不用new Array(length)这种方式，程序就会更长一些。

var arr = [];

for(var i=0;i<100;i++){

arr.push(i);

}

长一些倒没什么，但更关键的是这样它就不是表达式了，而变成语句，在某些需要用表达式的场合会更不方便。

 

 

 

首先给大家介绍javascript jquery中定义数组与操作的相关知识，具体内容如下所示：
1.认识数组
数组就是某类数据的集合，数据类型可以是整型、字符串、甚至是对象

Javascript不支持多维数组，但是因为数组里面可以包含对象（数组也是一个对象），所以数组可以通过相互嵌套实现类似多维数组的功能
1.1 定义数组
声明有10个元素的数组

var a = new Array(10);


此时为a已经开辟了内存空间，包含10个元素，用数组名称加 [下标] 来调用，例如 a[2] 但此时元素并未初始化，调用将返回 undefined
以下代码定义了个可变数组，并进行赋值

var a = new Array();
 a[0] = 10;
 a[1] = "aaa";
 a[2] = 12.6;


上面提过了，数组里面可以放对象，例如下面代码

var a =  new Array();
a[0]  = true;
a[1]  = document.getElementByIdx_x("text");
a[2]  = {x:11, y:22};
a[3]  = new Array();


数组可以实例化的时候直接赋值，例如

var a = new Array(1, 2, 3, 4, 5);
var b = [1, 2, 3, 4, 5];


1.2 多维数组
其实Javascript是不支持多维数组的，在asp里面可以用 dim a(10,3)来定义多维数组，在Javascript里面，如果用 var a = new Array(10,3) 将报错

但是之前说过，数组里面可以包含对象，所以可以把数组里面的某个元素再声明为数组，例如

var a = new Array();
a[0] = new Array();
a[0][0] = 1;
alert(a[0][0]); //弹出 1


声明的时候赋值

var a = new Array([1,2,3], [4,5,6],  [7,8,9]);
var b = [[1,2,3], [4,5,6], [7,8,9]];


效果一样，a采用常规实例化，b是隐性声明，结果都是生成一个多维数组
1.3 Array literals
这个还真不知中文怎么叫，文字数组？

说到数组，不得不说到Array Literals，数组其实是特殊的对象，对象有特有属性和方法，通过 对象名.属性 、对象.方法() 来取值和调用，而数组是通过下标来取值，Array Literals跟数组有很多相似，都是某数据类型的集合，但是Array Literals从根本来说，是个对象，声明和调用，跟数组是有区别

var aa = new Object();
aa.x = "cat";
aa.y = "sunny";
alert(aa.x);  //弹出cat


创建一个简单的对象，一般调用是通过aa.x，而如果当成Array literals的话，用alert(aa[“x”])一样会弹出cat

var a = {x:"cat",  y:"sunny"};
alert(a["y"]); //弹出sunny 


这是另一种创建对象的方法，结果是一样的
2.数组元素的操作
上面已经说过，可以通过 数组[下标] 来读写元素
下标的范围是 0 – (23(上标2) -1)，当下标是负数、浮点甚至布尔值的时候，数组会自动转换为对象类型，例如

var b  = new Array();
b[2.2]  = "XXXXX";
alert(b[2.2]); //-> XXXXX


此时相当于b[“2.2”] = “XXXXX”
2.1数组的循环

var a = [1,2,3,4,5,6];
for(var i =0; i<a.length; i++){
　　alert(a[i]);
}


这是最常用的，历遍数组，代码将依次弹出1至6
还有一种常用的

var a = [1,2,3,4,5,6];
for(var e in a){
　　alert(e);
}


还是依次弹出1至6，for…in是历遍对象（数组是特殊的对象）对象，用在数组上，因为数组没有属性名，所以直接输出值，这结构语句用在对象上，例如下面

var a = {x:1,y:2,z:3};
for(var e in a){
　　alert(e  + ":" + a[e]);
}


此时e取到的是属性名，即 x、y、x，而要取得值，则采用 数组名[属性]，所以 a[e] 等同于 a[“x”]、a[“y”]、a[“z”]
2.2数组常用函数
concat
在现有数组后面追加数组，并返回新数组，不影响现有数组

var a = [123];
var b = "sunnycat";
var c =  ["www",21,"ido"];
var d = {x:3.14, y:"SK"};
var e = [1,2,3,4,[5,6,[7,8]]];
alert(a.concat(b));   // -> 123,sunnycat
alert(a); //  -> 123
alert(b.concat(c, d));    // -> sunnycatwww,21,ido[object  Object]
alert(c.concat(b));   // -> www,21,ido,sunnycat
alert(e.concat(11,22,33).join(" #  "));    // -> 1 # 2 # 3  # 4 # 5,6,7,8 # 11 # 22 # 33


需要注意的是只能用于数组或字符串，如果被连接（前面的a）的是数值、布尔值、对象，就会报错，字符串连接数组时，字符串会跟数组首元素拼接成新元素，而数组连接字符串则会追加新元素（这点我也不清楚原委，知情者请透露），对于数组里面包含数组、对象的，连接后保持原样
join
用指定间隔符连起来，把数组转为字符串

var a = ['a','b','c','d','e','f','g'];
lert(a.join(","));  // -> a,b,c,d,e,f,g 相当于a.toString()
alert(a.join(" x ")); // -> a x b x c x d x e x f x g


这个很容易理解，但需要注意的是只转换一维数组里面，如果数组里面还有数组，将不是采用join指定的字符串接，而是采用默认的toString()，例如

var a =  ['a','b','c','d','e','f','g',[11,22,33]];
alert(a.join(" * ")); // -> a * b * c * d * e * f * g *  11,22,33


数组里面的数组，并没用 * 连接
pop
删除数组最后一个元素，并返回该元素

var a =  ["aa","bb","cc"];
document.write(a.pop());  // -> cc
document.write(a);    // -> aa, bb


如果数组为空，则返回undefined
push
往数组后面添加数组，并返回数组新长度

var a =  ["aa","bb","cc"];
document.write(a.push("dd"));  // -> 4
document.write(a);    // -> aa,bb,cc,dd
document.write(a.push([1,2,3])); // -> 5
document.write(a);    // -> aa,bb,cc,dd,1,2,3


跟concat的区别在于，concat不影响原数组，直接返回新数组，而push则直接修改原数组，返回的是数组新长度
sort
数组排序，先看个例子

var a = [11,2,3,33445,5654,654,"asd","b"];
alert(a.sort()); // -> 11,2,3,33445,5654,654,asd,b


结果是不是很意外，没错，排序并不是按整型大小，而是字符串对比，就是取第一个字符的ANSI码对比，小的排前面，相同的话取第二个字符再比，如果要按整型数值比较，可以这样

var a = [11,2,3,33445,5654,654];
a.sort(function(a,b) {
　　return a - b;
});
alert(a); //  -> 2,3,11,654,5654,33445


sort()方法有个可选参数，就是代码里的function，这是个简单的例子，不可对非数字进行排序，非数字需要多做判断，这里就不多讲
reverse
 
 
 
对数组进行反排序跟，sort()一样，取第一字符ASCII值进行比较

var a = [11,3,5,66,4];
alert(a.reverse()); // -> 4,66,5,3,11


如果数组里面还包含数组，则当为对象处理，并不会把元素解出来

var a = ['a','b','c','d','e','f','g',[4,11,33]];
alert(a.reverse()); // -> 4,11,33,g,f,e,d,c,b,a
alert(a.join(" * ")); // -> 4,11,33 * g * f * e * d * c * b * a


按理应该是11排最后面，因为这里把 4,11,33 当做完整的对象比较，所以被排在第一位。看不明白的话，用join()串起来，就明了多
shift
删除数组第一个元素，并返回该元素，跟pop差不多

var a =  ["aa","bb","cc"];
document.write(a.shift());  // -> aa
document.write(a);    // -> bb,cc


当数组为空时，返回undefined
unshift
跟shift相反，往数组最前面添加元素，并返回数组新长度

var a =  ["aa","bb","cc"];
document.write(a.unshift(11));  // -> 4 注：IE下返回ndefined
document.write(a);    // -> 11,aa,bb,cc
document.write(a.unshift([11,22]));  // -> 5
document.write(a);    // -> 11,22,11,aa,bb,cc
document.write(a.unshift("cat")); // -> 6
document.write(a);    // -> cat,11,22,11,aa,bb,cc


注意该方法，在IE下将返回undefined，貌似微软的bug，我在firefox下则能正确发挥数组新长度
slice
返回数组片段

var a = ['a','b','c','d','e','f','g'];
alert(a.slice(1,2)); // -> b
alert(a.slice(2));  // -> c,d,e,f,g
alert(a.slice(-4));  // -> d,e,f,g
alert(a.slice(-2,-6));  // -> 空


a.slice(1,2)，从下标为1开始，到下标为2之间的数，注意并不包括下标为2的元素

如果只有一个参数，则默认到数组最后

-4是表示倒数第4个元素，所以返回倒数的四个元素

最后一行，从倒数第2开始，因为是往后截取，所以显然取不到前面的元素，所以返回空数组，如果改成 a.slice(-6,-2) 则返回b,c,d,e
splice
从数组删除某片段的元素，并返回删除的元素

var a = [1,2,3,4,5,6,7,8,9];
document.write(a.splice(3,2));  // -> 4,5
document.write(a);    // -> 1,2,3,6,7,8,9
document.write(a.splice(4)); // -> 7,8,9 注：IE下返回空
document.write(a);    // -> 1,2,3,6
document.write(a.splice(0,1));  // -> 1
document.write(a);    // -> 2,3,6
document.write(a.splice(1,1,["aa","bb","cc"]));  // -> 3
document.write(a);    // -> 2,aa,bb,cc,6,7,8,9
document.write(a.splice(1,2,"ee").join("#")); // -> aa,bb,cc#6
document.write(a);    // -> 2,ee,7,8,9
document.write(a.splice(1,2,"cc","aa","tt").join("#")); // -> ee#7
document.write(a);    // -> 2,cc,aa,tt,8,9


注意该方法在IE下，第二个参数是必须的，不填则默认为0，例如a.splice(4)，在IE下则返回空，效果等同于a.splice(4,0)
toString
把数组转为字符串，不只数组，所有对象均可使用该方法

var a =  [5,6,7,8,9,["A","BB"],100];
document.write(a.toString());  // -> 5,6,7,8,9,A,BB,100
var b = new Date()
document.write(b.toString());  // -> Sat Aug 8 17:08:32 UTC+0800  2009
var c = function(s){
　　alert(s);
}
document.write(c.toString());  // -> function(s){ alert(s); }


布尔值则返回true或false，对象则返回[object objectname]

相比join()方法，join()只对一维数组进行替换，而toString()则把整个数组（不管一维还是多维）完全平面化

同时该方法可用于10进制、2进制、8进制、16进制转换，例如

var a =  [5,6,7,8,9,"A","BB",100];
for(var i=0; i<a.length; i++){
　　document.write(a[i].toString()  + " 的二进制是 "  + a[i].toString(2) + " ，八进制是 " + a[i].toString(8) + " ，十六进制是 " + a[i].toString(16)); //  -> 4,5
}


输出结果
5 的二进制是 101 ，八进制是 5 ，十六进制是 5

6 的二进制是 110 ，八进制是 6 ，十六进制是 6

7 的二进制是 111 ，八进制是 7 ，十六进制是 7

8 的二进制是 1000 ，八进制是 10 ，十六进制是 8

9 的二进制是 1001 ，八进制是 11 ，十六进制是 9

A 的二进制是 A ，八进制是 A ，十六进制是 A

BB 的二进制是 BB ，八进制是 BB ，十六进制是 BB

100 的二进制是 1100100 ，八进制是 144 ，十六进制是 64
转换只能在元素进行，如果对整个数组进行转换，则原封不动返回该数组
toLocaleString
返回本地格式字符串，主要用在Date对象上

var a = new Date();
document.write(a.toString());  // -> Sat Aug 8 17:28:36 UTC+0800  2009
document.write(a.toLocaleString());  // -> 2009年8月8日 17:28:36
document.write(a.toLocaleDateString());  // -> 2009年8月8日 

区别在于，toString()返回标准格式，toLocaleString()返回本地格式完整日期（在【控制面板】>>【区域和语言选项】，通过修改[时间]和[长日期]格式），toLocaleDateString()跟toLocaleString()一样，只是少了时间
valueOf
根据不同对象返回不同原始值，用于输出的话跟toString()差不多，但是toString()是返回string类型，而valueOf()是返回原对象类型

var a = [1,2,3,[4,5,6,[7,8,9]]];
var b = new Date();
var c = true;
var d = function(){
　　alert("sunnycat");
};
document.write(a.valueOf());  // -> 1,2,3,4,5,6,7,8,9
document.write(typeof (a.valueOf())); // -> object
document.write(b.valueOf());  // -> 1249874470052
document.write(typeof(b.valueOf())); // -> number
document.write(c.valueOf());  // -> true
document.write(typeof(c.valueOf())); // -> boolean
document.write(d.valueOf());  // -> function () {  alert("sunnycat"); }
document.write(typeof(d.valueOf())); // -> function 


数组也是对象，所以typeof (a.valueOf())返回object，返回的依然是个多维数组

var a = [1,2,3,[4,5,6,[7,8,9]]];
var aa = a.valueOf();
document.write(aa[3][3][1]); // -> 8


Date对象返回的是距离1970年1月1日的毫秒数，

Math和Error对象没有valueOf方法
Jquery 数组操作
在jquery中处理JSON数组的情况中遍历用到的比较多，但是用添加移除这些好像不是太多。

今天试过json[i].remove(),json.remove(i)之后都不行，看网页的DOM对象中好像JSON数据是以数组的形式出现的，查阅了下相关JS中数组的操作一试果然很爽。

记录下来。
1、数组的创建

var arrayObj = new Array();　//创建一个数组
var arrayObj = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度
var arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);　创建一个数组并赋值

要说明的是，虽然第二种方法创建数组指定了长度，但实际上所有情况下数组都是变长的，也就是说即使指定了长度为5，仍然可以将元素存储在规定长度以外的，注意：这时长度会随之改变。
2、数组的元素的访问

var testGetArrValue=arrayObj[1]; //获取数组的元素值
arrayObj[1]= "这是新值"; //给数组元素赋予新的值


3、数组元素的添加

arrayObj. push([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组结尾，并返回数组新长度
arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度
arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);//将一个或多个新元素插入到数组的指定位置，插入位置的元素自动后移，返回"" 


4、数组元素的删除

arrayObj.pop(); //移除最后一个元素并返回该元素值
arrayObj.shift(); //移除最前一个元素并返回该元素值，数组中元素自动前移
arrayObj.splice(deletePos,deleteCount); //删除从指定位置deletePos开始的指定数量deleteCount的元素，数组形式返回所移除的元素


5、数组的截取和合并

arrayObj.slice(start, [end]); // 以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素
arrayObj.concat([item1[, item2[, . . . [,itemN]]]]); //将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组


6、数组的拷贝

arrayObj.slice(0); //返回数组的拷贝数组，注意是一个新的数组，不是指向
arrayObj.concat(); //返回数组的拷贝数组，注意是一个新的数组，不是指向

7、数组元素的排序


arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址
arrayObj.sort(); //对数组元素排序，返回数组地址

8、数组元素的字符串化

arrayObj.join(separator); //返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开。
toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用


 
 
声明的时候赋值


?

1
2



var 
a = new Array([1,2,3], [4,5,6], [7,8,9]);
var 
b = [[1,2,3], [4,5,6], [7,8,9]];




效果一样，a采用常规实例化，b是隐性声明，结果都是生成一个多维数组
1.3 Array literals
这个还真不知中文怎么叫，文字数组？

说到数组，不得不说到Array Literals，数组其实是特殊的对象，对象有特有属性和方法，通过 对象名.属性 、对象.方法() 来取值和调用，而数组是通过下标来取值，Array Literals跟数组有很多相似，都是某数据类型的集合，但是Array Literals从根本来说，是个对象，声明和调用，跟数组是有区别


?

1
2
3
4



var 
aa = new Object();
aa.x = "cat";
aa.y = "sunny";
alert(aa.x); 
//弹出cat




创建一个简单的对象，一般调用是通过aa.x，而如果当成Array literals的话，用alert(aa[“x”])一样会弹出cat


?

1
2



var 
a = {x:"cat", y:"sunny"};
alert(a["y"]);
//弹出sunny




这是另一种创建对象的方法，结果是一样的
2.数组元素的操作
上面已经说过，可以通过 数组[下标] 来读写元素
下标的范围是 0 – (23(上标2) -1)，当下标是负数、浮点甚至布尔值的时候，数组会自动转换为对象类型，例如


?

1
2
3



var 
b = new Array();
b[2.2] = "XXXXX";
alert(b[2.2]); 
//-> XXXXX




此时相当于b[“2.2”] = “XXXXX”
2.1数组的循环


?

1
2
3
4



var 
a = [1,2,3,4,5,6];
for(var
i =0; i<a.length; i++){
alert(a[i]);
}




这是最常用的，历遍数组，代码将依次弹出1至6
还有一种常用的


?

1
2
3
4



var 
a = [1,2,3,4,5,6];
for(var
e in 
a){
alert(e);
}




还是依次弹出1至6，for…in是历遍对象（数组是特殊的对象）对象，用在数组上，因为数组没有属性名，所以直接输出值，这结构语句用在对象上，例如下面


?

1
2
3
4



var 
a = {x:1,y:2,z:3};
for(var
e in 
a){
alert(e + ":"
+ a[e]);
}




此时e取到的是属性名，即 x、y、x，而要取得值，则采用 数组名[属性]，所以 a[e] 等同于 a[“x”]、a[“y”]、a[“z”]
2.2数组常用函数
concat
在现有数组后面追加数组，并返回新数组，不影响现有数组


?

1
2
3
4
5
6
7
8
9
10



var 
a = [123];
var 
b = "sunnycat";
var 
c = ["www",21,"ido"];
var 
d = {x:3.14, y:"SK"};
var 
e = [1,2,3,4,[5,6,[7,8]]];
alert(a.concat(b)); 
// -> 123,sunnycat
alert(a); // -> 123
alert(b.concat(c, d));
// -> sunnycatwww,21,ido[object Object]
alert(c.concat(b)); 
// -> www,21,ido,sunnycat
alert(e.concat(11,22,33).join(" # "));
// -> 1 # 2 # 3 # 4 # 5,6,7,8 # 11 # 22 # 33




需要注意的是只能用于数组或字符串，如果被连接（前面的a）的是数值、布尔值、对象，就会报错，字符串连接数组时，字符串会跟数组首元素拼接成新元素，而数组连接字符串则会追加新元素（这点我也不清楚原委，知情者请透露），对于数组里面包含数组、对象的，连接后保持原样
join
用指定间隔符连起来，把数组转为字符串


?

1
2
3



var 
a = ['a','b','c','d','e','f','g'];
lert(a.join(","));
// -> a,b,c,d,e,f,g 相当于a.toString()
alert(a.join(" x "));
// -> a x b x c x d x e x f x g




这个很容易理解，但需要注意的是只转换一维数组里面，如果数组里面还有数组，将不是采用join指定的字符串接，而是采用默认的toString()，例如


?

1
2



var 
a = ['a','b','c','d','e','f','g',[11,22,33]];
alert(a.join(" * "));
// -> a * b * c * d * e * f * g * 11,22,33




数组里面的数组，并没用 * 连接
pop
删除数组最后一个元素，并返回该元素


?

1
2
3



var 
a = ["aa","bb","cc"];
document.write(a.pop());
// -> cc
document.write(a); 
// -> aa, bb




如果数组为空，则返回undefined
push
往数组后面添加数组，并返回数组新长度


?

1
2
3
4
5



var 
a = ["aa","bb","cc"];
document.write(a.push("dd"));
// -> 4
document.write(a); 
// -> aa,bb,cc,dd
document.write(a.push([1,2,3]));
// -> 5
document.write(a); 
// -> aa,bb,cc,dd,1,2,3




跟concat的区别在于，concat不影响原数组，直接返回新数组，而push则直接修改原数组，返回的是数组新长度
sort
数组排序，先看个例子


?

1
2



var 
a = [11,2,3,33445,5654,654,"asd","b"];
alert(a.sort()); 
// -> 11,2,3,33445,5654,654,asd,b




结果是不是很意外，没错，排序并不是按整型大小，而是字符串对比，就是取第一个字符的ANSI码对比，小的排前面，相同的话取第二个字符再比，如果要按整型数值比较，可以这样


?

1
2
3
4
5



var 
a = [11,2,3,33445,5654,654];
a.sort(function(a,b) {
return 
a - b;
});
alert(a); // -> 2,3,11,654,5654,33445




sort()方法有个可选参数，就是代码里的function，这是个简单的例子，不可对非数字进行排序，非数字需要多做判断，这里就不多讲
reverse
对数组进行反排序跟，sort()一样，取第一字符ASCII值进行比较


?

1
2



var 
a = [11,3,5,66,4];
alert(a.reverse()); 
// -> 4,66,5,3,11




如果数组里面还包含数组，则当为对象处理，并不会把元素解出来


?

1
2
3



>var
a = ['a','b','c','d','e','f','g',[4,11,33]];
alert(a.reverse()); 
// -> 4,11,33,g,f,e,d,c,b,a
alert(a.join(" * "));
// -> 4,11,33 * g * f * e * d * c * b * a




按理应该是11排最后面，因为这里把 4,11,33 当做完整的对象比较，所以被排在第一位。看不明白的话，用join()串起来，就明了多
shift
删除数组第一个元素，并返回该元素，跟pop差不多


?

1
2
3



var 
a = ["aa","bb","cc"];
document.write(a.shift());
// -> aa
document.write(a); 
// -> bb,cc




当数组为空时，返回undefined
unshift
跟shift相反，往数组最前面添加元素，并返回数组新长度


?

1
2
3
4
5
6
7



var 
a = ["aa","bb","cc"];
document.write(a.unshift(11));
// -> 4 注：IE下返回undefined
document.write(a); 
// -> 11,aa,bb,cc
document.write(a.unshift([11,22]));
// -> 5
document.write(a); 
// -> 11,22,11,aa,bb,cc
document.write(a.unshift("cat"));
// -> 6
document.write(a); 
// -> cat,11,22,11,aa,bb,cc




注意该方法，在IE下将返回undefined，貌似微软的bug，我在firefox下则能正确发挥数组新长度
slice
返回数组片段


?

1
2
3
4
5



var 
a = ['a','b','c','d','e','f','g'];
alert(a.slice(1,2));
// -> b
alert(a.slice(2)); 
// -> c,d,e,f,g
alert(a.slice(-4)); 
// -> d,e,f,g
alert(a.slice(-2,-6));
// -> 空




a.slice(1,2)，从下标为1开始，到下标为2之间的数，注意并不包括下标为2的元素

如果只有一个参数，则默认到数组最后

-4是表示倒数第4个元素，所以返回倒数的四个元素

最后一行，从倒数第2开始，因为是往后截取，所以显然取不到前面的元素，所以返回空数组，如果改成 a.slice(-6,-2) 则返回b,c,d,e
splice
从数组删除某片段的元素，并返回删除的元素


?

1
2
3
4
5
6
7
8
9
10
11
12
13



var 
a = [1,2,3,4,5,6,7,8,9];
document.write(a.splice(3,2));
// -> 4,5
document.write(a); 
// -> 1,2,3,6,7,8,9
document.write(a.splice(4));
// -> 7,8,9 注：IE下返回空
document.write(a); 
// -> 1,2,3,6
document.write(a.splice(0,1));
// -> 1
document.write(a); 
// -> 2,3,6
document.write(a.splice(1,1,["aa","bb","cc"]));
// -> 3
document.write(a); 
// -> 2,aa,bb,cc,6,7,8,9
document.write(a.splice(1,2,"ee").join("#"));
// -> aa,bb,cc#6
document.write(a);
// -> 2,ee,7,8,9
document.write(a.splice(1,2,"cc","aa","tt").join("#"));
// -> ee#7
document.write(a);
// -> 2,cc,aa,tt,8,9




注意该方法在IE下，第二个参数是必须的，不填则默认为0，例如a.splice(4)，在IE下则返回空，效果等同于a.splice(4,0)
toString
把数组转为字符串，不只数组，所有对象均可使用该方法


?

1
2
3
4
5
6
7
8



var 
a = [5,6,7,8,9,["A","BB"],100];
document.write(a.toString());
// -> 5,6,7,8,9,A,BB,100
var 
b = new Date()
document.write(b.toString());
// -> Sat Aug 8 17:08:32 UTC+0800 2009
var 
c = function(s){
alert(s);
}
document.write(c.toString());
// -> function(s){ alert(s); }




布尔值则返回true或false，对象则返回[object objectname]

相比join()方法，join()只对一维数组进行替换，而toString()则把整个数组（不管一维还是多维）完全平面化

同时该方法可用于10进制、2进制、8进制、16进制转换，例如


?

1
2
3
4



var 
a = [5,6,7,8,9,"A","BB",100];
for(var
i=0; i<a.length; i++){
document.write(a[i].toString() +
" 的二进制是 " + a[i].toString(2) +
" ，八进制是 " + a[i].toString(8) +
" ，十六进制是 " + a[i].toString(16));
// -> 4,5
}




输出结果
5 的二进制是 101 ，八进制是 5 ，十六进制是 5

6 的二进制是 110 ，八进制是 6 ，十六进制是 6

7 的二进制是 111 ，八进制是 7 ，十六进制是 7

8 的二进制是 1000 ，八进制是 10 ，十六进制是 8

9 的二进制是 1001 ，八进制是 11 ，十六进制是 9

A 的二进制是 A ，八进制是 A ，十六进制是 A

BB 的二进制是 BB ，八进制是 BB ，十六进制是 BB

100 的二进制是 1100100 ，八进制是 144 ，十六进制是 64
转换只能在元素进行，如果对整个数组进行转换，则原封不动返回该数组
toLocaleString
返回本地格式字符串，主要用在Date对象上


?

1
2
3
4



var 
a = new Date();
document.write(a.toString());
// -> Sat Aug 8 17:28:36 UTC+0800 2009
document.write(a.toLocaleString());
// -> 2009年8月8日 17:28:36
document.write(a.toLocaleDateString());
// -> 2009年8月8日




区别在于，toString()返回标准格式，toLocaleString()返回本地格式完整日期（在【控制面板】>>【区域和语言选项】，通过修改[时间]和[长日期]格式），toLocaleDateString()跟toLocaleString()一样，只是少了时间
valueOf
根据不同对象返回不同原始值，用于输出的话跟toString()差不多，但是toString()是返回string类型，而valueOf()是返回原对象类型


?

1
2
3
4
5
6
7
8
9
10
11
12
13
14



var 
a = [1,2,3,[4,5,6,[7,8,9]]];
var 
b = new Date();
var 
c = true;
var 
d = function(){
alert("sunnycat");
};
document.write(a.valueOf());
// -> 1,2,3,4,5,6,7,8,9
document.write(typeof
(a.valueOf())); // -> object
document.write(b.valueOf());
// -> 1249874470052
document.write(typeof(b.valueOf()));
// -> number
document.write(c.valueOf());
// -> true
document.write(typeof(c.valueOf()));
// -> boolean
document.write(d.valueOf());
// -> function () { alert("sunnycat"); }
document.write(typeof(d.valueOf()));
// -> function




数组也是对象，所以typeof (a.valueOf())返回object，返回的依然是个多维数组


?

1
2
3



var 
a = [1,2,3,[4,5,6,[7,8,9]]];
var 
aa = a.valueOf();
document.write(aa[3][3][1]);
// -> 8




Date对象返回的是距离1970年1月1日的毫秒数，

Math和Error对象没有valueOf方法
Jquery 数组操作
在jquery中处理JSON数组的情况中遍历用到的比较多，但是用添加移除这些好像不是太多。

今天试过json[i].remove(),json.remove(i)之后都不行，看网页的DOM对象中好像JSON数据是以数组的形式出现的，查阅了下相关JS中数组的操作一试果然很爽。

记录下来。
1、数组的创建



?

1
2
3



var 
arrayObj = new Array();　//创建一个数组
var 
arrayObj = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度
var 
arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);　创建一个数组并赋值




要说明的是，虽然第二种方法创建数组指定了长度，但实际上所有情况下数组都是变长的，也就是说即使指定了长度为5，仍然可以将元素存储在规定长度以外的，注意：这时长度会随之改变。
2、数组的元素的访问


?

1
2



var 
testGetArrValue=arrayObj[1]; //获取数组的元素值
arrayObj[1]= 
"这是新值"; //给数组元素赋予新的值




3、数组元素的添加



?

1
2
3



arrayObj. push([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组结尾，并返回数组新长度
arrayObj.unshift([item1 [item2 [. . . [itemN ]]]]);// 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度
arrayObj.splice(insertPos,0,[item1[, item2[, . . . [,itemN]]]]);//将一个或多个新元素插入到数组的指定位置，插入位置的元素自动后移，返回""




4、数组元素的删除


?

1
2
3



arrayObj.pop(); 
//移除最后一个元素并返回该元素值
arrayObj.shift(); 
//移除最前一个元素并返回该元素值，数组中元素自动前移
arrayObj.splice(deletePos,deleteCount);
//删除从指定位置deletePos开始的指定数量deleteCount的元素，数组形式返回所移除的元素




5、数组的截取和合并



?

1
2



arrayObj.slice(start, [end]);
//以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素
arrayObj.concat([item1[, item2[, . . . [,itemN]]]]);
//将多个数组（也可以是字符串，或者是数组和字符串的混合）连接为一个数组，返回连接好的新的数组





6、数组的拷贝



?

1
2



arrayObj.slice(0); 
//返回数组的拷贝数组，注意是一个新的数组，不是指向
arrayObj.concat(); 
//返回数组的拷贝数组，注意是一个新的数组，不是指向




7、数组元素的排序
arrayObj.reverse(); //反转元素（最前的排到最后、最后的排到最前），返回数组地址

arrayObj.sort(); //对数组元素排序，返回数组地址
8、数组元素的字符串化


?

1
2



arrayObj.join(separator);
//返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开。
toLocaleString 、toString 、valueOf：可以看作是join的特殊用法，不常用