javascript数组操作
今天针对javascript的数组的一些常见操作进行一些讲解，希望对给为开发者有帮助。 先看下面常见的三种循环。
for循环
var arr =[1, 3, 8, 4] for (var i = 0,j = arr.length; i < j; i++) { console.log(arr[i], i) } // Prints: // [0] is 1 0 // [1] is 3 1 // [2] is 8 2 // [3] is 4 3
for in 循环
var arr =[1, 3, 8, 4] var map ={a: 1,b: 2,c: 3} Array.prototype.text =5 for (var i in arr) { console.log(arr[i], i) } for (var i in map) { console.log(map[i], i) } // Prints arr: // [0] is 1 "0" // [1] is 3 "1" // [2] is 8 "2" // [3] is 4 "3" // [4] is 5 "text" //prints map: // [0] is 1 "a" // [1] is 2 "b" // [2] is 3 "c"
for of循环
var arr =[1, 3, 8, 4] for (var i of arr) { console.log(i) } // Prints: // [0] is 1 // [1] is 2 // [2] is 3 // [3] is 8 // [4] is 4
可以看到， for循环和 for of循环都是遍历数组本身，但是区别是 i的值，前者是索引，后者是数组值。 for in循环不仅遍历数组本身，还遍历了原型遍历，同时可以遍历对象。这里指的注意的是 i的值是 string类型的 "0,1,2,3" 总结：for循环能满足我们的大多数情况，但是是最麻烦的，拿到的是索引，不如for of那样直接拿到数组值。for in循环功能是最强的，能遍历对象，但是缺点第遍历了原型对象，有时候可能对我们的遍历产生影响。 上面的3个循环都能通过 break跳出循环。
forEach循环
var arr =[1, 3, 8, 4] arr.forEach((row, index, test) = >{ console.log(row, index, test) }) // Prints: // [0] is 1 0 arr // [1] is 2 1 arr // [2] is 3 2 arr // [3] is 8 3 arr // [4] is 4 4 arr
可以看到 forEach循环和 for in循环是很像的，区别是 forEach是以回调函数的形式来遍历的，参数分别是数组值，索引和数组本身，遍历期间可以通过 row对数组本身进行处理，会改变数组本身。 forEach对于需要中断遍历就没那么友好，不能通过break来结束循环。大多数情况下 forEach很容易满足我们的遍历，但是forEach循环存在上下文变量的问题（如果不能用箭头函数的情况下，这里通过箭头函数避免了该问题）。
map遍历
var arr =[1, 3, 8, 4] var newArr = arr.map((row, index, test) = >{ return row }) arr.push(5) console.log(arr, newArr) // Prints: //[1,3,8,4,5],[1,3,8,4]
map遍历和forEach遍历参数是一样的，同样是通过回调函数来遍历整个数组，不同是 map遍历通过return给我们返回一个全新的数组。
filter操作
var arr =[1, 3, 8, 4] var newArr = arr.filter((row, index, test) = >{ return row >= 5 }) console.log(newArr) // Prints: //[8]
filter操作是用来数组过滤的，找出符合条件的值并返回一个新的数组，回调函数的参数跟forEach一样，通过返回true false来判断是否符合新数组的条件。
concat操作
var arr =[1, 3, 8, 4] var arr2 =[4, 5] var newArr = arr.concat(arr2) var newArr1 = arr.concat() console.log(newArr, arr2) // Prints: //[1, 3, 8, 4, 4, 5] //[1, 3, 8, 4]
concat操作是用来合并数组的，并返回一个新的数组。这里有个骚操作是 arr.concat()只需要一行代码就能轻松实现数组的拷贝。
sort排序
var arr =[1, 3, 8, 4] arr.sort((a, b) = >a > b) console.log(arr) // Prints: // [1, 3, 4, 8]
sort对数组进行排序，接受一个回调函数，函数的参数是连续的数组2项，上面的代码类似实现了一个冒泡排序，通过返回 true false来判断是否需要调换位置，这些操作直接作用在原数组上。
一些其他操作
//shift:删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined //unshift:将参数添加到原数组开头，并返回数组的长度 //pop:删除原数组最后一项，并返回删除元素的值；如果数组为空则返回undefined //push:将参数添加到原数组末尾，并返回数组的长度 //reverse:将数组反序 //splice(start,deleteCount,val1,val2,...):从start位置开始删除deleteCount项，并从该位置起插入val1,val2,... //slice(start,end):返回从原数组中指定开始下标到结束下标之间的项组成的新数组 //join(separator):将数组的元素组起一个字符串，以separator为分隔符，省略的话则用默认用逗号为分隔符 //some(),every()判断数组中是否存在满足条件的值，前者有一个为true则返回true，后者所有未true才返回true，有点像&&和||。 //这里写一个数组比较的问题 []==[] //prints:false var a1 =[1, 2, 3] var a2 =[1, 2, 3] a1.toString() == a2.toString() //prints:true //上面的方式巧妙的避开了大量代码来判断数组是否相同
对象操作
var map1 ={name: 'jack',age: 21,sex: '0'} var map2 ={phone: '123456'} var map3 =Object.assign(map1, map2) var arr =Object.keys(map1) console.log(arr) console.log(map3) //prints: //["name", "age", "sex"] //{name: "jack", age: 21, sex: "0", phone: "123456"}
可以看到 Object.keys方法可以将对象的key组成一个数组，得到数组时候我们就可以使用forEach等一些方法来遍历这个对象了。 Object.assign能合并n个对象的属性，后面的属性会覆盖前面的属性，最终得到一个新的对象。这2个es6的方式是很实用的。
Java 枚举(enum)
Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。
Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。
例如定义一个颜色的枚举类。
enum Color { RED, GREEN, BLUE; }
以上枚举类 Color 颜色常量有 RED, GREEN, BLUE，分别表示红色，绿色，蓝色。
使用实例：
实例
enum Color
{
RED, GREEN, BLUE;
}
public class Test
{
// 执行输出结果
public static void main(String[] args)
{
Color c1 = Color.RED;
System.out.println(c1);
}
}
执行以上代码输出结果为：
RED
内部类中使用枚举
枚举类也可以声明在内部类中：
实例
public class Test
{
enum Color
{
RED, GREEN, BLUE;
}
// 执行输出结果
public static void main(String[] args)
{
Color c1 = Color.RED;
System.out.println(c1);
}
}
执行以上代码输出结果为：
RED
每个枚举都是通过 Class 在内部实现的，且所有的枚举值都是 public static final 的。
以上的枚举类 Color 转化在内部类实现：
class Color { public static final Color RED = new Color(); public static final Color BLUE = new Color(); public static final Color GREEN = new Color(); }
迭代枚举元素
可以使用 for 语句来迭代枚举元素：
实例
enum Color
{
RED, GREEN, BLUE;
}
public class MyClass {
public static void main(String[] args) {
for (Color myVar : Color.values()) {
System.out.println(myVar);
}
}
}
执行以上代码输出结果为：
RED
GREEN
BLUE
在 switch 中使用枚举类
枚举类常应用于 switch 语句中：
实例
enum Color
{
RED, GREEN, BLUE;
}
public class MyClass {
public static void main(String[] args) {
Color myVar = Color.BLUE;
switch(myVar) {
case RED:
System.out.println("红色");
break;
case GREEN:
System.out.println("绿色");
break;
case BLUE:
System.out.println("蓝色");
break;
}
}
}
执行以上代码输出结果为：
蓝色
values(), ordinal() 和 valueOf() 方法
enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Serializable 和 java.lang.Comparable 两个接口。
values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中：
values() 返回枚举类中所有的值。
ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。
valueOf()方法返回指定字符串值的枚举常量。
实例
enum Color
{
RED, GREEN, BLUE;
}
public class Test
{
public static void main(String[] args)
{
// 调用 values()
Color[] arr = Color.values();
// 迭代枚举
for (Color col : arr)
{
// 查看索引
System.out.println(col + " at index " + col.ordinal());
}
// 使用 valueOf() 返回枚举常量，不存在的会报错 IllegalArgumentException
System.out.println(Color.valueOf("RED"));
// System.out.println(Color.valueOf("WHITE"));
}
}
执行以上代码输出结果为：
RED at index 0 GREEN at index 1 BLUE at index 2 RED
枚举类成员
枚举跟普通类一样可以用自己的变量、方法和构造函数，构造函数只能使用 private 访问修饰符，所以外部无法调用。
枚举既可以包含具体方法，也可以包含抽象方法。 如果枚举类具有抽象方法，则枚举类的每个实例都必须实现它。
实例
enum Color
{
RED, GREEN, BLUE;
// 构造函数
private Color()
{
System.out.println("Constructor called for : " + this.toString());
}
public void colorInfo()
{
System.out.println("Universal Color");
}
}
public class Test
{
// 输出
public static void main(String[] args)
{
Color c1 = Color.RED;
System.out.println(c1);
c1.colorInfo();
}
}
执行以上代码输出结果为：
Constructor called for : RED Constructor called for : GREEN Constructor called for : BLUE RED Universal Color
总结
数组是javascript常见的数组类型，操作很多，选择适当的方式能提高程序性能和代码可读性。部分函数是es6才有的这里不做说明，具体各种操作性能也不做对比。
