js数组常用方法大全

最新推荐文章于 2023-04-17 17:27:16 发布
最新推荐文章于 2023-04-17 17:27:16 发布
阅读量462 收藏 2
点赞数
分类专栏： Array javascript 文章标签： javascript es6
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43340929/article/details/105575510
版权

javascript Array常用方法

这里小编总结一下Array中的一些常用数组方法，方便总览。
1.删除添加常用方法 push | pop | shift | unshift

定义：
pop(): 该方法用于删除数组的最后一个元素，并返回被删除的元素。官方语法：arrayObject.pop()
shift(): 该方法用于删除数组的第一个元素，并返回被删除的元素。官方语法：arrayObject.shift()
push(): 该方法用于向数组末尾添加一个或者多个元素，并返回新的长度。官方语法：arrayObject.push(newelement1,newelement2,…,newelementX)
unshift(): 该方法用于向数组的开头添加一个或者多个元素，并返回新的长度。官方语法：arrayObject.unshift(newelement1,newelement2,…,newelementX)
实例： 这四个方法可以一起记忆。

const arr = [1,3,5,7]
arr.push('test') //打印 [ 1, 3, 5, 7, 'test' ]
arr.pop() //打印 [ 1, 3, 5, 7 ]
arr.shift() //打印 [ 3, 5, 7 ]
arr.unshift(1, '10') //打印 [ 1, '10', 3, 5, 7 ]

实现原理： 主要采用的是数据结构中的栈和队列的原理，push()方法是向数组末尾添加一个或者多个元素，并返回新的长度。pop()方法和push()方法相反。pop()方法删除数组的最后一个元素，把数组的长度减1，并且返回它被删除元素的值，如果数组变为空，则该方法不改变数组，返回undefine值。

2.数组排序方法 sort()

定义： sort() 方法用于对数组的元素进行排序。语法arrayObject.sort()

具体实现： sort() 方法用于对数组的元素进行排序，并返回数组。默认排序顺序是根据字符串UniCode码。因为排序是按照字符串UniCode码的顺序进行排序的，所以首先应该把数组元素都转化成字符串（如有必要），以便进行比较。
如果要得到自己想要的结果，不管是升序还是降序，就需要提供比较函数了。该函数比较两个值的大小，然后返回一个用于说明这两个值的相对顺序的数字。

注意： 比较函数应该具有两个参数 a 和 b，其返回值如下：
若 a 小于 b，即 a - b 小于零，则返回一个小于零的值，数组将按照升序排列。
若 a 等于 b，则返回 0。
若 a 大于 b, 即 a - b 大于零，则返回一个大于零的值，数组将按照降序排列。

实例： 比如要让一个数组进行排序

var arr1 = [10, 55, 432, 678, 32, 98];
var arr2 = ["George", "John", "Thomas", "James", "Adrew", "Martin"];
var arr3 = [{
  name: '张三',
  age: 10
}, {
  name: '李四',
  age: 50
}, {
  name: '王二',
  age: 30
}]
//数组排序
function arrSort(a, b) { //定义排序方法
  return a - b; //设置排序规则
}
//直接修改
arr1.sort((a, b) => a - b)

//对象数组排序-对某个属性值排序
function objArrSort(attr) {  
  return function (a,b) {  
    let val1 = a[attr]
    let val2 = b[attr]
    return val1 - val2//排序规则同上
  }
}
console.log(arr1.sort(arrSort))//数字排序需要函数,如果要从大排到小,就return b-a;
console.log(arr2.sort())//字母不需要,按照字符串UniCode码来排序
console.log(arr3.sort(objArrSort('age')))
// [Running] node "c:\Users\admin\Desktop\test\learn.js" [10, 32, 55, 98, 432, 678]
//   ['Adrew', 'George', 'James', 'John', 'Martin', 'Thomas']
//   [{
//       name: '张三',
//       age: 10
//     },
//     {
//       name: '王二',
//       age: 30
//     },
//     {
//       name: '李四',
//       age: 50
//     }
//   ]
// [Done] exited with code = 0 in 0.215 seconds

根本原理： sort方法接受一个比较器，这个比较器比较传入的两个参数：a和b。a>b则返回正数，a<b返回负数，a==b返回0。然后sort调用内部实现的比较算法，配合这个比较器，就能排序了。此算法时间复杂度为O(nlogn)。

3. splice| slice | delete

定义：
splice： 主要用作删除、插入、替换。语法：arrayObject.splice(index,howmany,item1,…,itemX),返回值是一个数组。这种方法会改变原始数组，index参数必需。规定从何处添加/删除元素。该参数是开始插入和（或）删除的数组元素的下标，必须是数字。howmany参数可选。规定应该删除多少元素。必须是数字，但可以是 “0”。如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。item1, …, itemX可选择，表示要添加到数组的新元素。
slice： 用作截取，语法：arrayObject.slice(start,end)。start:开始位置的索引，end:结束位置的索引(但不包含该索引位置的元素)。
delete： 可以删除数组或者对象的值，但是不会直接删除，会将原来位置的数变为undefined，并且保留索引值。并且无法直接删除变量和原型中属性的值。

实例：
1:删除功能splice(index,count)：index:开始位置的索引count:要删除元素的个数

arr = [1,2,5,7,'test']
let newArr = arr.splice(1, 2); //会把2,5两个元素给删除掉
console.log(arr); //剩下[ 1, 7, 'test' ]
console.log(newArr); //删除[ 2, 5 ]

2: 插入功能splice(index,0,插入的项)：index:插入元素的索引值，第二个参数位置参数位0表示插入。

arr = [1,2,5,7,'test']
var newArr = arr.splice(2, 0, '张三')
console.log(arr) //输出=[‘a’,’b’,’张三’,’c’,’d’]

3:替换功能splice(index,num,value)：index:开始的索引位置，num:删除项的数(如果num为0，就是插入功能)，value:插入的值。

arr = [1,2,5,7,'test']
var newArr = arr.splice(2, 2, '李四',5)
console.log(arr) //输出[ 1, 2, '李四', 5, 'test' ]
console.log(newArr) //[ 5, 7 ]

4:slice(start,end)方法：start:开始位置的索引，end:结束位置的索引(但不包含该索引位置的元素)。并且不改变原数组。

arr = [1,2,5,7,'test']
var newArr = arr.slice(0, 3); //不包含索引值为3对应的元素
console.log(arr);
console.log(newArr); //输出的是[‘a’,’b’,’c’,’]
var newArr2 = arr.slice(0); //如果没有第二个参数，截取到的是最后一个元素
console.log(newArr2); //输出的是[‘a’,’b’,’c’,’d’]

5:delete value：此处value可以是对象中的值，也可以是数组中某个位置的值。

arr = [1,2,5,7,'test']
function Fun() {
  this.test = 'test';
}
delete arr[3] //将 7 变为undefined
console.log(arr);
let age = 'test'
delete age;//删除不了
console.log(age); //test
Fun.prototype.test = 'test12'
let obj = new Fun();
delete obj.test;
console.log(obj.test) //删除不了test12
4.reverse | split | join

定义：
reverse: 用于颠倒数组中元素的顺序。语法：arrayObject.reverse()
split： 用于把一个字符串分割成字符串数组。语法：stringObject.split(separator,howmany)。separator必需。字符串或正则表达式，从该参数指定的地方分割 stringObject。*howmany *可选。该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度。
join： 用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。语法：arrayObject.join(separator)，separator可选。指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符。

实例： 一般三个函数可以配合使用

"2:3:4:5".split(":") //将返回["2", "3", "4", "5"]
"|a|b|c".split("|") //将返回["", "a", "b", "c"]
"hello".split("") //可返回 ["h", "e", "l", "l", "o"]
"hello".split("", 3) //可返回 ["h", "e", "l"]

let arr = new Array(3)
arr[0] = "George"
arr[1] = "John"
arr[2] = "Thomas"
arr.join(".") //可返回George.John.Thomas

//将str字符串倒序
str = 'I am test'
let newStr = str.split('').reverse().join('')
console.log(newStr); //tset ma I
5.数组筛选 filter | map | some | every

filter定义：filter: 创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。注意：filter() 不会对空数组进行检测。filter() 不会改变原始数组。
语法： array.filter(function(currentValue,index,arr), thisValue)，function(currentValue, index,arr) 必须，数组中的每个元素都会执行这个函数。currentValue必须，当前元素的值。index可选。当前元素的索引值arr 可选。当前元素属于的数组对象。thisValue 可选，对象作为该执行回调时使用，传递给函数，用作 “this” 的值，如果省略了 thisValue ，“this” 的值为 “undefined”
实例：

// 返回数组arr中所有大于6的元素。
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let res = arr.filter((num) => {
  return num > 6;
});
console.log(res); // [ 7, 8, 9, 10]

map定义：map: 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。map() 方法按照原始数组元素顺序依次处理元素。map() 不会对空数组进行检测。 map() 不会改变原始数组。
语法： array.map(function(currentValue,index,arr), thisValue)，参数意义同上filter
实例：

let num = [1, 2, 3];
let newNum = num.map((ele, index) => {
  return ele + 3
})
console.log(newNum); // 4,5,6

**some 、every **：every()与some()方法都是JS中数组的迭代方法。every()是对数组中每一项运行给定函数，如果该函数对每一项返回true,则返回true。some()是对数组中每一项运行给定函数，如果该函数对任一项返回true，则返回true。some一直在找符合条件的值，一旦找到，则不会继续迭代下去。every从迭代开始，一旦有一个不符合条件，则不会继续迭代下去。
语法： array.some(function(currentValue,index,arr), thisValue)，array.some(function(currentValue,index,arr), thisValue)，参数意义同上filter

实例：

var arr = [1, 2, 3, 4, 5, 6];
let test1 =  arr.some(function (item, index) {
  console.log('item=' + item + ',index=' + index );
  return item > 3;//符合才结束
})
console.log(test1);

let test2 = arr.every(function (item, index) {
  console.log('item=' + item + ',index=' + index);
  return item > 3;//不符合立刻结束
})
console.log(test2);
6.数组遍历 forEach | for…of | for…in | entries | keys| values

1.forEach: 用于调用数组的每个元素，并将元素传递给回调函数。语法参数：同上filter，forEach和map用法类似，都可以遍历到数组的每个元素，而且参数一致。不同点： forEach() 方法对数组的每个元素执行一次提供的函数。总是返回undefined；map() 方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。返回值是一个新的数组。

var arr = [1, 2, 3, 4, 5];
var x = arr.forEach(function (value, index) {
  console.log(value); //可遍历到所有数组元素
  return value + 10
});
console.log(x); //undefined    无论怎样，总返回undefined
var y = arr.map(function (value, index) {
  console.log(value); //可遍历到所有数组元素
  return value + 10
});
console.log(y); //[11, 12, 13, 14, 15]   返回一个新的数组

2.for…of 、for…in: for…in 语句以任意顺序遍历一个对象的除Symbol以外的可枚举属性。因为迭代的顺序是依赖于执行环境的，所以数组遍历不一定按次序访问元素。因此当迭代访问顺序很重要的数组时，最好用整数索引去进行for循环（或者使用 Array.prototype.forEach() 或 for…of 循环）。 for…of语句在可迭代对象（包括 Array，Map，Set，String,TypedArray,arguments 对象等等）上创建一个迭代循环，调用自定义迭代钩子，并为每个不同属性的值执行语句

//for...in
var obj = {a:1, b:2, c:3};
for (var prop in obj) {
  console.log("obj." + prop + " = " + obj[prop]);
}

//for...of
const array1 = ['a', 'b', 'c'];
for (const element of array1) {
  console.log(element);
}
// expected output: "a"
// expected output: "b"
// expected output: "c"

for…of与for…in的区别:
无论是for…in还是for…of语句都是迭代一些东西。它们之间的主要区别在于它们的迭代方式。
for…in 语句以任意顺序迭代对象的可枚举属性。
for…of 语句遍历可迭代对象，定义要迭代的数据。
以下示例显示了与Array一起使用时，for…of循环和for…in循环之间的区别。

//给原型绑定方法
Object.prototype.objCustom = function () {};
Array.prototype.arrCustom = function () {};
let iterable = [3, 5, 7];
iterable.foo = 'hello';//给对象添加属性和值

//因为数组也是对象，所以由于继承和原型链，对象iterable继承属性objCustom和arrCustom。
//并且遍历所有可枚举属性（包括它的原型链上的可枚举属性）
for (let i in iterable) {
  console.log(i); // logs 0, 1, 2, "foo", "arrCustom", "objCustom"
}

//hasOwnProperty()的用法：继承的属性不显示。是指不去遍历继承的可枚举属性
for (let i in iterable) {
  if (iterable.hasOwnProperty(i)) {
    console.log(i); // logs 0, 1, 2, "foo"
  }
}

//该循环迭代并记录iterable作为可迭代对象定义的迭代值，这些是数组元素 3, 5, 7，而不是任何对象的属性。
for (let i of iterable) {
  console.log(i); // logs 3, 5, 7
}

3.entries 、keys、values
定义：
ES6 提供三个新的方法——entries()，keys()和values()——用于遍历数组。它们都返回一个遍历器对象，可以用for…of循环进行遍历，唯一的区别是keys()是对键名的遍历、values()是对键值的遍历，entries()是对键值对的遍历。

for (let index of ['a', 'b'].keys()) {
  console.log(index);//0，1
}

for (let elem of ['a', 'b'].values()) {
  console.log(elem); // 'a'，'b'
}

for (let [index, elem] of ['a', 'b'].entries()) {
  console.log(index, elem); //0 "a"，1 "b"
}
7.Array.from | Array.of | fill | copyWithin

1.Array.from: 方法用于将两类对象转为真正的数组：类似数组的对象（array-like object）和可遍历（iterable）的对象（包括 ES6 新增的数据结构 Set 和 Map）。

let arrayLike = {
    '0': 'a',
    '1': 'b',
    '2': 'c',
    length: 3
};

// ES5的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c']

// ES6的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

Array.from其他用法：

//只要是部署了 Iterator 接口的数据结构，Array.from都能将其转为数组。
Array.from('hello')
// ['h', 'e', 'l', 'l', 'o']
let namesSet = new Set(['a', 'b'])
Array.from(namesSet) // ['a', 'b']

//使用 扩展运算符（...）
function foo() {  
  const args = Array.from([...arguments]);
  console.log(args);
}

//Array.from还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组。
Array.from(arrayLike, x => x * x);
// 等同于
Array.from(arrayLike).map(x => x * x);

Array.from([1, 2, 3], (x) => x * x)
// [1, 4, 9]

//Array.from创建二维数组
let n = 5 ,m = 6
let arr = Array.from({length:n+1} , x=> Array.from( {length:m+1}, x=> 0 ))

2.Array.of：用于将一组值，转换为数组。它负责把一堆文本或者变量转换成数组。在开发中我们经常拿到了一个类似数组的字符串，需要使用eval来进行转换，eval的效率是很低的，它会拖慢我们的程序。这时候我们就可以使用Array.of方法。

Array.of(3, 11, 8) // [3,11,8]
Array.of(3) // [3]
Array.of(3).length // 1

//Array.of基本上可以用来替代Array()或new Array()，并且不存在由于参数不同而导致的重载。它的行为非常统一。
Array.of(undefined) // [undefined]
Array.of(1) // [1]
Array.of(1, 2) // [1, 2]

3.copyWithin： 数组实例的copyWithin()方法，在当前数组内部，将指定位置的成员复制到其他位置（会覆盖原有成员），然后返回当前数组。也就是说，使用这个方法，会修改当前数组。它接受三个参数。

  • target（必需）：从该位置开始替换数据。如果为负值，表示倒数。
  • start（可选）：从该位置开始读取数据，默认为 0。如果为负值，表示从末尾开始计算。
  • end（可选）：到该位置前停止读取数据，默认等于数组长度。如果为负值，表示从末尾开始计算。

这三个参数都应该是数值，如果不是，会自动转为数值。此方法类似于String的replace

//上面代码表示将从 3 号位直到数组结束的成员（4 和 5），复制到从 0 号位开始的位置，结果覆盖了原来的 1 和 2。
[1, 2, 3, 4, 5].copyWithin(0, 3)
// [4, 5, 3, 4, 5]

// 将3号位复制到0号位
[1, 2, 3, 4, 5].copyWithin(0, 3, 4)
// [4, 2, 3, 4, 5]

// -2相当于3号位，-1相当于4号位
[1, 2, 3, 4, 5].copyWithin(0, -2, -1)
// [4, 2, 3, 4, 5]

4.fill： 此方法用于填充一个数组。第一个参数是填充值，fill方法还可以接受第二个和第三个参数，用于指定填充的起始位置和结束位置。

['a', 'b', 'c'].fill(7)
// [7, 7, 7]

new Array(3).fill(7)
// [7, 7, 7]

['a', 'b', 'c'].fill(7, 1, 2)
// ['a', 7, 'c']
7.find | findIndex | includes

1.find： 数组实例的find方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。

[1, 4, -5, 10].find((n) => n < 0)
// -5

//find方法的回调函数可以接受三个参数，依次为当前的值、当前的位置和原数组。
[1, 5, 10, 15].find(function(value, index, arr) {
  return value > 9;
}) // 10

2.findIndex ： 数组实例的findIndex方法的用法与find方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。

[1, 5, 10, 15].findIndex(function(value, index, arr) {
  return value > 9;
}) // 2

//findIndex和find方法都可以接受第二个参数，用来绑定回调函数的this对象。
function f(v){
  return v > this.age;
}
let person = {name: 'John', age: 20};
[10, 12, 26, 15].find(f, person);    // 26

//另外，这两个方法都可以发现NaN，弥补了数组的indexOf方法的不足。
[NaN].indexOf(NaN) // -1

indexOf方法无法识别数组的NaN成员，但是findIndex方法可以借助Object.is方法做到。
[NaN].findIndex(y => Object.is(NaN, y)) // 0

3.includes： includes方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。第一个参数位查找的值，第二个参数（可选）表示搜索的起始位置，默认为0。如果第二个参数为负数，则表示倒数的位置，如果这时它大于数组长度（比如第二个参数为-4，但数组长度为3），则会重置为从0开始。

[1, 2, 3].includes(4)     // false
[1, 2, NaN].includes(NaN) // true
[1, 2, 3].includes(3, -1); // true

//没有该方法之前，我们通常使用数组的indexOf方法，检查是否包含某个值。indexOf方法有两个缺点，一是不够语义化，它的含义是找到参数值的第一个出现位置，所以要去比较是否不等于-1，表达起来不够直观。二是，它内部使用严格相等运算符（===）进行判断，这会导致对NaN的误判。
[NaN].indexOf(NaN)// -1
[NaN].includes(NaN)// true
8.数组新增操作

1.完成数组的二维转一维。

const arr = [[1,2,3,4],[2,3,5,1],[2,1,3,5]]
console.log(arr.flat())
//打印
[
  1, 2, 3, 4, 2, 3,
  5, 1, 2, 1, 3, 5,
]

2.数组对象去重

function deteleObject(obj) {
  var uniques = [];
  var stringify = {};
  for (var i = 0; i < obj.length; i++) {
    var keys = Object.keys(obj[i]);
    keys.sort(function (a, b) {
      return (Number(a) - Number(b));
    });
    var str = '';
    for (var j = 0; j < keys.length; j++) {
      str += JSON.stringify(keys[j]);
      str += JSON.stringify(obj[i][keys[j]]);
    }
    if (!stringify.hasOwnProperty(str)) {
      uniques.push(obj[i]);
      stringify[str] = true;
    }
  }
  uniques = uniques;
  return uniques;
}
总结：以上就是Array常用的方法，可以配合这方法解决大多数代码中的逻辑问题，并且帮助A算法题，js提供的接口有很多类似于C++。希望以上可以帮助到大家！
我不止喜欢前端
关注
专栏目录
JS将数字转换为带有单位的中文表示
weixin_30510153的博客
07-24 1602
调用方法 addChineseUnit ， 其他两个方法在addChineseUnit中有调用 /** * 为数字加上单位：万或亿 * * 例如： * 1000.01 => 1000.01 * 10000 => 1万 * 99000 => 9.9万 * 566000 => 56.6万 * 5660000 ...
js中常用数组的方法
weixin_45411620的博客
11-30 377
js中常用数组的方法 一、数组常用方法： 1、push（ ）向数组中添加数据； 语法：数组.push(要添加的数据)；加粗样式 var arr=["你好"]； var res=arr.push("世界")； console.log(arr); // "你好" "世界" console.log(res); //2 直接改变原数组； 添加的数据是放在数组的最后一位； 返回值：添加...
头歌-JavaScript基础
somewon的博客
04-17 5300
第2关：JavaScript 数据类型转换。第1关：JavaScript 数据类型介绍。JavaScript 学习手册五：JS数组。JavaScript 学习手册八：JS函数。第1关：数组的创建、读写和长度。第3关：数组的遍历和多维数组。第5关：数组的应用——内排序。第1关：用函数语句定义函数。第2关：用表达式定义函数。第2关：数组元素的增减。第4关：数组的常用方法。第3关：JSON字符串。第4关：未定义的实参。第6关：对象作为参数。第2关：JSON数组。第1关：JSON对象。
JavaScript中最重要的数组方法
weixin_26717681的博客
08-14 361
Array is a very special concept in any programming language. All the major programming languages support the array data structure. Before going into the technicalities of the array from a programming ...
JavaScript数组方法的使用与详解
ct5211314的博客
12-09 958
本文章，通过数组方法与代码输出结果来进行JavaScript中数组的方法的使用。闲时不学习，项目空流泪呀。 一、数组中的主要方法 下面整理了一下数组的主要方法，也会根据数组的方法顺序进行相关的介绍： join() push()和pop() shift() 和 unshift() sort() reverse() concat() slice() splice() indexOf()和 lastIndexOf() （ES5新增） forEach() （ES5新增） map...
第11节 JavaScript数组常用方法及应用.rar
最新发布
03-02
第11节 JavaScript数组常用方法及应用.rar第11节 JavaScript数组常用方法及应用.rar第11节 JavaScript数组常用方法及应用.rar第11节 JavaScript数组常用方法及应用.rar第11节 JavaScript数组常用方法及应用.rar第11...
JS数组常用方法.md
03-22
常见的JS数组的使用方法 数组对象用来在单独的变量名中存储一系列的值。 我们使用关键词 new 来创建数组对象。下面的代码定义了一个名为 myArray 的数组对象： var myArray=new Array() 有两种向数组赋值的方法...
js中数组常用方法总结（推荐）
10-17
在JavaScript中，数组是一种常见的数据结构，它提供了一系列的方法来处理数组中的元素。...以上就是JavaScript中数组的一些常用方法的介绍和示例代码。掌握了这些方法，就能在开发过程中更加高效地处理数组相关的问题。
JavaScript数组常用方法
10-24
以上介绍了JavaScript数组常用的一些方法，每个方法都有着不同的用途和特点。掌握这些方法对于进行高效的数组操作是十分重要的，无论是在前端开发还是在后端开发中，都能大大提高开发效率。对于初学者来说，理解这些...
谈谈JavaScript数组常用方法总结
10-20
本文将深入探讨JavaScript数组的一些常用方法，帮助开发者更好地理解和应用这些方法。 1. **增加数据** - `push()` 方法用于向数组末尾添加一个或多个元素，并返回新的数组长度。例如： ```javascript var arr =...
es6 求两个数组的差集
qq_38468358的博客
12-15 2513
let arr = [1, 2, 3, 4, 5]; let arr01 = [1, 2, 3, 4, 5, 6, 7, 8, 9]; let arr02 = [...arr01].filter(x => [...arr].every(y => y !== x)); console.log(arr02);
JavaScript中数组常用的19种方法总结
m0_59092234的博客
02-23 1957
1、length 获取数组长度 var arr = [1,2,3,4,5]; arr.length;//5 2、toString() 返回由数组中每个值的字符串形式拼接成的一个以逗号分隔的字符串 var arr = [1,2,3,4,5]; arr.toString();//"1,2,3,4,5" 3、valueOf() 返回数组对象本身 var arr = [1,2,3,4,5]; arr.valueOf();//[1,2,3,4,5] 4、join() 将数组中所有元素组成字符串，并可以规定分隔符
js编写程序 移除数组中与2相等的元素 并生成一个新数组
m0_61726249的博客
10-12 3445
移除数组arr([1,2,3,4,2,5,6,2,7,2])中与2相等的元素 并生成一个新数组，不改变原数组 <script> var arr = [1,2,3,4,2,5,6,2,7,2]; var newArr = []; //遍历数组 for(var i = 0;i<arr.length;i++){ //找出不等于2的元素 if(arr[i]!==2){ newArr(newArr.length) = arr[i] } } //输出生成的新数组
js数组方法
qq_41088147的博客
06-17 189
1.在数组中添加元素 ①array.push() array.push()在原数组尾部添加元素，返回的结果是新数组的长度。 ②array.unshift() array.unshift()在原数组的头部添加元素，返回的结果是新数组的长度。 2.删除数组元素 ①array.pop() array.pop()删除数组的最后一个元素，返回的结果是删除的那个元素。 ②array.shift() array.shift()删除数组的开头的第一个元素，返回的结果是删除的那个元素。 3.查找数组元素的索引号 ①array
详解js数组扁平化
07-27 555
1.项中最多一层深度的扁平化 1.1concat() + apply Array.prototype.concat.apply([],arr) 例子： Array.prototype.concat.apply([],[1,2,3,4,5,[6,7]]) // 这样写相当于在一个空的数组上调用concat然后给他穿进去的参数不是一个数组，而是这个数组里的项。这是利用了apply的特性，因为apply第二个参数接受一个数组，然后数组里面的内容就是参数。等同于下面的样子： [].concat(1,...
JavaScript编程题：移除数组中的元素
TheJormangund的博客
06-19 244
问题 题目地址：移除数组元素 题目描述 移除数组 arr 中的所有值与 item 相等的元素，直接在给定的 arr 数组上进行操作，并将结果返回 示例： 输入: [1, 2, 2, 3, 4, 2, 2], 2 输出: [1, 3, 4] 实现 function removeWithoutCopy(arr, item) { while (1) { if (arr.includes(item)) { arr.splice(arr.indexOf(item
js能力测评——移除数组中的元素
weixin_30664539的博客
09-05 95
移除数组中的元素 题目描述 : 移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr，结果返回新的数组 示例1 输入 [1, 2, 3, 4, 2], 2 输出 [1, 3, 4] 参考答案 注意到题目中说的不要修改原数组，这里有两个思路（一是通过深拷贝得到相同的数组，然后就不需要考虑splice,push等会不会影响原数组；二是利用数组的slice和concat...
JavaScript 数组操作方法小结
weixin_34122604的博客
10-23 125
ECMAScript为操作已经包含在数组中的项提供了很多方法。这里本人总结一下自己对这些方法的理解，如此之多的方法中，我首先已是否会改变原数组做为分类标准，逐个解释一下每一个方法。 一、不会改变原数组 1. concat() 使用方法：array.concat(array2,array3,...,arrayX)返回值： 返回一个新的数组 ...
超全的数组去重12种方法
热门推荐
m0_64564920的博客
04-15 2万+
前言 数组去重，可以说是一个比较常见的面试题，今天来盘点一下都有哪些方法可以实现数组去重。 方法1、双重for循环 这是一个最笨的方法，双重循环。 var arr = [1, 2, 3,4 ,5,6, 4, 3, 8, 1] // 数组去重： // 方法1： 双重for 循环 function newArrFn (arr) { // 创建一个新的空数组 let newArr = [] for(let i = 0;i<arr.length;i+
JavaScript数组操作详解：常用方法与实例
本文档深入探讨了JavaScript数组的常用方法，这对于任何开发人员来说都是极其重要的基础知识。首先，了解如何判断一个对象是否是数组至关重要。JavaScript提供了两种方法来实现这一目标：`instanceof Array` 和 `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值