JS中对数组元素进行增、删、改、查的方法,以及其他方法

前言

昨天联调一个页面,看着就一个页面,接口倒是不少。

热点问题配置测试联调完成(同步异步接口共11个)
1.配置新增
2.配置编辑
3.配置删除
4.热点问题新增
5.热点问题编辑
6.热点问题删除
7.热点问题上移
8.热点问题下移
9.热点问题保存
10.热点问题校验
11.热点问题列表

下图这一块是最麻烦的,调用的其他部分的组件,为了能复用,联调了很久。

之前封装的组件每一个动作是调接口的异步行为,此时改成同步的,最后保存一起提交。

那么在同步处理的时候,用到了很多数组的增删改,index索引值的变更。

JS中对数组元素进行增、删、改、查的方法,以及其他方法

下面,我首先总结一下数组处理的所有方法,再把在此处会用到的方法贴出来。


一.增加元素

1.push():push可接收任意数量的参数,把它们逐个添加至数组末尾,并且可以返回修改后数组的长度。

var sports = ['soccer', 'baseball'];
var total = sports.push('football', 'swimming'); console.log(sports); // ['soccer', 'baseball', 'football', 'swimming']
console.log(total); // 4

2.unshift() :与push()类似,也可接收任意数量的参数,只不过是将参数逐个添加至数组最前面而已,同样返回新数组长度。

const array1 = [1, 2, 3];

console.log(array1.unshift(4, 5));
// expected output: 5

console.log(array1);
// expected output: Array [4, 5, 1, 2, 3]

3.concat() :该方法与push()方法有点类似,同样是将元素添加至数组末尾,只不过这个数组已经不是原来的那个数组了,而是其副本,所以concat()操作数组后会返回一个新的数组。

特性:

    1. 不传参数,返回当前数组副本
    2. 传递非数组参数,这些参数就会被直接添加到结果数组的末尾
    3. 传递数组参数,将数组每一个元素,添加新的数组中
const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f']; console.log(array1.concat(array2));
// expected output: Array ["a", "b", "c", "d", "e", "f"]

4.splice(): 功能很强大,划重点

前面的三个方法都具有很大局限性,因为不是添加到数组前就是数组后,而splice()它非常灵活,它可以添加元素到数组的任意位置。

它除了可以添加元素之外还具有删除和替换元素的功能。

splice()可以向数组指定位置添加任意数量的元素。

需要传入至少3个参数:splice(a, b, c, d, ......)

    • 1、a 起始元素的位置
    • 2、b 要删除的元素个数,从起始元素开始算
    • 3、c后面的是要插入的元素,可以是数组

总结一下,原理就是,在规定的起始位置a,删除b个,如果后面需要塞进去新元素就加到cd...的位置,如果不加就是删除了,splice实质上是通过删除元素来实现插入、删除、替换的

4.1  splice 删除

写法

array.splice(index,n);

参数含义

index:数组中需要删除数据的起始位置;

n:需要删除的元素,数据的个数;

4.2   splice 插入

写法

array.splice(index,0,data1,data2,....);

参数

index:数组中需要插入数据的起始位置;

0:删除的个数为0;

data1,data2:需要插入的元素,用逗号隔开

4.3   splice 替换

写法

array.splice(index,n,data1,data2,......);

参数

index:需要替换的元素的起始位置;

n:需要替换的元素的个数,实质是删除;

data1,data2:需要插入元素,用逗号隔开;

二、删除元素

1.pop() :与push()方法配合使用可以构成后进先出的栈,该方法可从数组末尾删除最后一项并返回该项

const plants = ['broccoli', 'cauliflower', 'cabbage', 'kale', 'tomato'];

console.log(plants.pop());
// expected output: "tomato" console.log(plants);
// expected output: Array ["broccoli", "cauliflower", "cabbage", "kale"] plants.pop(); console.log(plants);
// expected output: Array ["broccoli", "cauliflower", "cabbage"]

  2.shift(): 与push()方法配合使用可以构成先进先出的队列,该方法可删除数组第一项并返回该项。

const array1 = [1, 2, 3];

const firstElement = array1.shift();

console.log(array1);
// expected output: Array [2, 3] console.log(firstElement);
// expected output: 1

  3.slice(): 该方法同concat()一样是返回一个新数组,不会影响原数组,只不过slice()是用来裁剪数组的,返回裁剪下来的数组。

slice()方法可以接受一或两个参数,

1、一个参数,返回从该参数指定位置开始到当前数组末尾的所有项。

2、两个参数,返回起始和结束位置之间的项,但不包括结束位置的项。

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"] console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"] console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

   4、splice(): 它除了可以添加元素之外还具有删除和替换元素的功能。 详细看以上例子

三、查找元素

indexOf() 和 lastIndexOf()

这两个方法都接收两个参数:

1、要查找的项

2、表示查找起点位置的索引。(可选的)

indexOf() 从数组的开头(位置0)开始向后查找。

lastIndexOf() 从数组的末尾开始向前查找。

两个方法,当找不到该元素时,都返回 -1

var arr = [1,2,3,4,5,2];

var index = arr.indexOf(2);

console.log(index);  //

index = arr.indexOf(2, 0);
console.log(index);  // index = arr.indexOf(2, 2);
console.log(index);  // index = arr.indexOf(6);
console.log(index);  // -1

其它方法:

1.join():该方法用来将数组转换为字符串,不改变原数组,返回转换后的字符串

const elements = ['Fire', 'Air', 'Water'];

console.log(elements.join());
// expected output: "Fire,Air,Water" console.log(elements.join(''));
// expected output: "FireAirWater" console.log(elements.join('-'));
// expected output: "Fire-Air-Water"

2.sort(): 按ascii码排序,改变原数组,返回排序后的数组

const months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);
// expected output: Array ["Dec", "Feb", "Jan", "March"] const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);
// expected output: Array [1, 100000, 21, 30, 4]

3.reverse() :用于颠倒数组中元素的顺序。返回的是颠倒后的数组,会改变原数组。

const array1 = ['one', 'two', 'three'];
console.log('array1:', array1);
// expected output: "array1:" Array ["one", "two", "three"] const reversed = array1.reverse();
console.log('reversed:', reversed);
// expected output: "reversed:" Array ["three", "two", "one"] /* Careful: reverse is destructive. It also changes
the original array */
console.log('array1:', array1);
// expected output: "array1:" Array ["three", "two", "one"]

4.filter():返回数组中满足条件的元素组成的新数组,原数组不变(筛选,过滤)

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

5.map() :map() 方法来根据需求格式化原数组,返回格式化后的数组。原数组不变。可以传入三个值,分别是(当前元素,索引index,map的原数组)

var arr = [1,2,3,4,5,2];
var arr2 = arr.map(function(current, index, array){
console.log("当前元素current="+current + "索引index="+index +"数组array="+array)
return "$"+current
})
console.log(arr) //[1, 2, 3, 4, 5, 2]
console.log(arr2) //["$1", "$2", "$3", "$4", "$5", "$2"]

6.every() :对数组的每一项都运行给定的函数,若每一项都返回 ture,则返回 true($$)

const isBelowThreshold = (currentValue) => currentValue < 40;

const array1 = [1, 30, 39, 29, 10, 13];

console.log(array1.every(isBelowThreshold));
// expected output: true

7.some():对数组的每一项都运行给定的函数,若存在一项或多项返回 ture,否则返回 false(||)

const array = [1, 2, 3, 4, 5];

// checks whether an element is even
const even = (element) => element % 2 === 0; console.log(array.some(even));
// expected output: true

8.forEach() :遍历整个数组,不中断,可以传入三个值,分别是(当前元素,索引index,原数组)

const array1 = ['a', 'b', 'c'];

array1.forEach(element => console.log(element));

// expected output: "a"
// expected output: "b"
// expected output: "c"

forEach和map很相似,很多地方用两个其中一种都行

相同点:

  1. 都是只能遍历数组
  2. 都有三个返回值(当前元素,索引index,原数组)
  3. 都是循环遍历数组每一项

区别是:

map,有返回值,可以return出来

forEach,没有返回值。forEach()返回值是undefined,不可以链式调用。

      没有办法终止或者跳出forEach()循环,除非抛出异常,所以想执行一个数组是否满足什么条件,返回布尔值,可以用一般的for循环实现,或者用Array.every()或者Array.some();

关于以上区别的笔试题

["1", "2", "3"].map(parseInt);  //结果  [1, NaN, NaN] 

如果想得到[1, 2,3]应该这么做
function returnInt(element){
return parseInt(element,10);
} ["1", "2", "3"].map(returnInt); 

这主要是因为 parseInt()默认有两个参数,第二个参数是进制数。当parsrInt没有传入参数的时候,而map()中的回调函数时候,会给它传三个参数,第二个参数就是索引,明显不正确,所以返回NaN了。

另,写map需要注意的点:

Arr
(Arr || []).map(item=>{})   这样写就会尽量避免报“Cannot read property 'map' of undefined”这个错误
 
定义object的时候尽量这样定义,避免后面报错
object
Const {a,b,c} = object || {}
Const {b,d} = a || {}

写到这里,发现这篇文章好长啊,已经写了一个小时了。不知道为什么博客园不能只用一种代码引入样式,两种弄的眼花缭乱,你们将就看吧。

下面贴一下实现最上面项目功能的store代码(技术栈react+mobx)

// 新增一个空的热点问题
@action addHotItem = (obj) => {
const { handledHotTopicContext } = this.currentItem;
const { list } = handledHotTopicContext
this.currentItem = {
...this.currentItem,
handledHotTopicContext: { ...handledHotTopicContext, list: [...list, obj], selectedItem: null }
};
} // 保存一个热点问题(新增或修改)
@action saveHotItem = (param, index) => {
const { id } = param;
const { handledHotTopicContext } = this.currentItem;
const { list } = handledHotTopicContext
// 编辑
if (id !== undefined) {
list.splice(id, 1, param);
this.currentItem = {
...this.currentItem,
handledHotTopicContext: { ...handledHotTopicContext, list: [...list], selectedItem: null }
};
      // 新增
} else {
const leg = list.length - 1
const { name } = param
const addObj = { id: leg, name: name }
list.splice(leg, 1, addObj);
// list.push(addObj)
this.currentItem = {
...this.currentItem,
handledHotTopicContext: { ...handledHotTopicContext, list: [...list], selectedItem: null }
};
}
} // 删除一个热点问题
@action delHotItem = (param) => {
const { id } = param;
const { handledHotTopicContext } = this.currentItem;
const { list } = handledHotTopicContext
list.splice(id, 1);
this.currentItem = {
...this.currentItem,
handledHotTopicContext: { ...handledHotTopicContext, list: [...list], selectedItem: null }
};
} // 上移下移一个热点问题
@action moveHotItem = (item, key) => {
let temp = null;
const { id } = item;
let index = 0;
const { handledHotTopicContext } = this.currentItem;
const { list } = handledHotTopicContext
index = list.findIndex(ele => ele.id === item.id); if (key === 'up') {
temp = { ...list[index - 1] };
list[index - 1] = { ...list[index] };
list[index] = temp;
this.currentItem = {
...this.currentItem,
handledHotTopicContext: { ...handledHotTopicContext, list: [...list], selectedItem: null }
}; } else {
temp = { ...list[index + 1] };
list[index + 1] = { ...list[index] };
list[index] = temp;
this.currentItem = {
...this.currentItem,
handledHotTopicContext: { ...handledHotTopicContext, list: [...list], selectedItem: null }
};
}
}

  

上一篇:php字符串递增


下一篇:C#构造函数、操作符重载以及自定义类型转换