JavaScript数组操作示例及对象操作技巧

比眉伴天荒 2023-10-12 21:51 56阅读 0赞

**目录**

javascript数组操作

for循环

for in 循环

for of循环

forEach循环

map遍历

filter操作

concat操作

sort排序

一些其他操作

对象操作

Java 枚举(enum)

实例

内部类中使用枚举

实例

迭代枚举元素

实例

在 switch 中使用枚举类

实例

values(), ordinal() 和 valueOf() 方法

实例

枚举类成员

实例

总结

--------------------

## 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 _enum] #

Java 枚举是一个特殊的类，一般表示一组常量，比如一年的 4 个季节，一个年的 12 个月份，一个星期的 7 天，方向有东南西北等。

Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 , 来分割。

例如定义一个颜色的枚举类。

enum Color 
    { 
        RED, GREEN, BLUE; 
    }

以上枚举类 Color 颜色常量有 RED, GREEN, BLUE，分别表示红色，绿色，蓝色。

使用实例：

## [实例][Link 1] ##

enum Color  
\{  
RED, GREEN, BLUE;  
\}

public class Test  
\{  
// 执行输出结果  
public static void main(String\[\] args)  
\{  
Color c1 = Color.RED;  
System.out.println(c1);  
\}  
\}

执行以上代码输出结果为：

RED

### [内部类中使用枚举][Link 2] ###

枚举类也可以声明在内部类中：

## [实例][Link 3] ##

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();
    }

### [迭代枚举元素][Link 4] ###

可以使用 for 语句来迭代枚举元素：

## [实例][Link 5] ##

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] ###

枚举类常应用于 switch 语句中：

## [实例][Link 6] ##

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() 方法][values_ ordinal_ _ valueOf_] ###

enum 定义的枚举类默认继承了 java.lang.Enum 类，并实现了 java.lang.Serializable 和 java.lang.Comparable 两个接口。

values(), ordinal() 和 valueOf() 方法位于 java.lang.Enum 类中：

*  values() 返回枚举类中所有的值。
 *  ordinal()方法可以找到每个枚举常量的索引，就像数组索引一样。
 *  valueOf()方法返回指定字符串值的枚举常量。

## [实例][Link 7] ##

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

### [枚举类成员][Link 8] ###

枚举跟普通类一样可以用自己的变量、方法和构造函数，构造函数只能使用 private 访问修饰符，所以外部无法调用。

枚举既可以包含具体方法，也可以包含抽象方法。 如果枚举类具有抽象方法，则枚举类的每个实例都必须实现它。

## [实例][Link 9] ##

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才有的这里不做说明，具体各种操作性能也不做对比。

[Java _enum]: http://kxdang.com/topic/java/java-enum.html#java-%E6%9E%9A%E4%B8%BEenum
[Link 1]: http://kxdang.com/topic/java/java-enum.html#%E5%AE%9E%E4%BE%8B
[Link 2]: http://kxdang.com/topic/java/java-enum.html#%E5%86%85%E9%83%A8%E7%B1%BB%E4%B8%AD%E4%BD%BF%E7%94%A8%E6%9E%9A%E4%B8%BE
[Link 3]: http://kxdang.com/topic/java/java-enum.html#%E5%AE%9E%E4%BE%8B-1
[Link 4]: http://kxdang.com/topic/java/java-enum.html#%E8%BF%AD%E4%BB%A3%E6%9E%9A%E4%B8%BE%E5%85%83%E7%B4%A0
[Link 5]: http://kxdang.com/topic/java/java-enum.html#%E5%AE%9E%E4%BE%8B-2
[switch]: http://kxdang.com/topic/java/java-enum.html#%E5%9C%A8-switch-%E4%B8%AD%E4%BD%BF%E7%94%A8%E6%9E%9A%E4%B8%BE%E7%B1%BB
[Link 6]: http://kxdang.com/topic/java/java-enum.html#%E5%AE%9E%E4%BE%8B-3
[values_ ordinal_ _ valueOf_]: http://kxdang.com/topic/java/java-enum.html#values-ordinal-%E5%92%8C-valueof-%E6%96%B9%E6%B3%95
[Link 7]: http://kxdang.com/topic/java/java-enum.html#%E5%AE%9E%E4%BE%8B-4
[Link 8]: http://kxdang.com/topic/java/java-enum.html#%E6%9E%9A%E4%B8%BE%E7%B1%BB%E6%88%90%E5%91%98
[Link 9]: http://kxdang.com/topic/java/java-enum.html#%E5%AE%9E%E4%BE%8B-5