资讯专栏INFORMATION COLUMN

js数组常用的一些方法

wendux / 1345人阅读

摘要:如果被引用的对象发生改变,则改变将反应到新的和原来的数组中对于字符串和数字来说不是和对象,会拷贝字符串和数字到新的数组里。在一个数组里修改这些字符串或数字,不会影响另一个数组。

(1) arr.length => 返回一个数组中的元素个数(数组属性

var numbers = [1,2,3,4,5];
numbers.length; // 5

(2) arr.indexOf(searchElement[, fromIndex = 0]) => 返回给定元素在数组中的第一个索引值,否则返回-1

var array = [2, 5, 9];
array.indexOf(5);     // 1
array.indexOf(9, 2);  // 2
array.indexOf(2, -3); // 0

(3) arr.lastIndexOf(searchElement[, fromIndex = arr.length - 1]) => 返回指定元素在数组中最后出现位置的索引值,从 fromIndex 位置向前开始查找,如果不存在,则返回 -1

var arr = [2, 5, 9, 2];
arr.lastIndexOf(2);     // 3
arr.lastIndexOf(7);     // -1
arr.lastIndexOf(2, 3);  // 3
arr.lastIndexOf(2, 2);  // 0
arr.lastIndexOf(2, -2); //0

(4) arr.push(element1, ..., elementN) => 在数组的末尾添加一个或多个元素,并返回数组新的 length 值

var sports = ["soccer", "baseball"];
var total = sports.push("football", "swimming");

console.log(sports); // ["soccer", "baseball", "football", "swimming"]
console.log(total);  // 4

(5) arr. unshift(element1, ..., elementN) => 在数组的开头添加一个或者多个元素,并返回数组新的 length 值

var sports = ["soccer", "baseball"];
var total = sports.unshift("football", "swimming");

console.log(sports); // ["football", "swimming", "soccer", "baseball"]
console.log(total);  // 4

(6) arr.pop() => 删除数组中的最后的一个元素,并且返回这个元素

var myFish = ["angel", "clown", "mandarin", "surgeon"];
var popped = myFish.pop();

console.log(myFish); // ["angel", "clown", "mandarin"]
console.log(popped); // "surgeon"

(7) arr.shift() => 删除数组中的第一个元素,并且返回这个元素

var myFish = ["angel", "clown", "mandarin", "surgeon"];
var shifted = myFish.shift();

console.log(myFish); // ["clown", "mandarin", "surgeon"]
console.log(shifted); // "angel"

(8) arr.concat(value1, value2, ..., valueN) => 将传入的数组或值与原数组合并,组成一个新的数组并返回

var alpha = ["a", "b", "c"];
var numeric = [1, 2, 3];
var alphaNumeric = alpha.concat(numeric);        // 组成新数组 ["a", "b", "c", 1, 2, 3]; 原数组 alpha 和 numeric 未被修改
var alphaNumeric2 = alpha.concat(1,[2,3,[4,5]]); // 组成新数组 ["a", "b", "c", 1, 2, 3, [4,5]]

(9) arr.reverse() => 颠倒数组中元素的位置,并返回该数组的引用

var myArray = ["one", "two", "three"];
myArray.reverse(); 
console.log(myArray); // ["three", "two", "one"]

(10) array.splice(start, deleteCount[, item1[, item2[, ...]]]) => 用新元素替换旧元素,修改数组的内容;返回由被删除的元素组成的数组

// start 从数组对哪一位开始修改内容
// deleteCount 整数,表示要移除的数组元素的个数
// itemN 要添加进数组的元素
var myFish = ["angel", "clown", "mandarin", "surgeon"];
myFish.splice(2, 0, "drum"); // []  "增"
console.log(myFish); // ["angel", "clown", "drum", "mandarin", "surgeon"]

myFish.splice(1,2); // ["clown", "drum"]   "删"
console.log(myFish); // ["angel", "mandarin", "surgeon"]

myFish.splice(0, 2, "parrot", "anemone", "blue"); // ["angel", "mandarin"]   "改"
console.log(myFish); // ["parrot", "anemone", "blue", "surgeon"]

(11) arr.slice([begin[, end]]) => 把数组中的一部分浅拷贝,存入到一个新的数组中,并返回这个新数组

// 原数组的元素按照下述规则拷贝:
// 1.如果该元素是个对象引用(不是实际的对象),slice会拷贝这个对象引用到新的数组
//   里。两个对象都引用了同一个对象。如果被引用的对象发生改变,则改变将反应到新的和
//   原来的数组中;
// 2.对于字符串和数字来说(不是String和Number对象),slice会拷贝字符串和数字到
//   新的数组里。在一个数组里修改这些字符串或数字,不会影响另一个数组。
// 如果向两个数组任一中添加了新元素,则另一个不会受到影响

var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
fruits.slice(1,3); // ["Orange", "Lemon"]
console.log(fruits); // ["Banana", "Orange", "Lemon", "Apple", "Mango"]

// slice 方法可以用来将一个类数组(Array-like)对象/集合转换成一个数组
function list() {
  return Array.prototype.slice.call(arguments);
  // 或者 return [].prototype.slice.call(arguments);
}
var list1 = list(1, 2, 3); // [1, 2, 3]

(12) arr.join([separator = ","]) => 将数组中的所有元素连接成一个字符串

var a = ["Wind", "Rain", "Fire"];
var myVar1 = a.join();      // myVar1的值变为"Wind,Rain,Fire"
var myVar2 = a.join(", ");  // myVar2的值变为"Wind, Rain, Fire"
var myVar3 = a.join(" + "); // myVar3的值变为"Wind + Rain + Fire"
var myVar4 = a.join("");    // myVar4的值变为"WindRainFire"

(13) arr.sort([compareFunction]) => 对数组的元素排序,并返回这个数组;默认按照字符串的Unicode码位点(code point)排序

var fruit = ["cherries", "apples", "bananas"];
fruit.sort(); // ["apples", "bananas", "cherries"]

var scores = [1, 10, 2, 21]; 
scores.sort(); // [1, 10, 2, 21]

//对数字进行升序排序
function compareNumbers(a, b) {
  return a - b;
}
var numbers = [4, 20, 5, 12, 3];
numbers.sort(compareNumbers); // [3, 4, 5, 12, 20]

(14) array.forEach(callback[, thisArg]) => 让数组的每一项都执行一次 callback 函数;thisArg 是可选参数,用来当作callback 函数内this值的对象。注:没有办法中止或者跳出forEach循环,除了抛出一个异常

//callback 函数传三个参数:数组当前项的值、数组当前项的索引、数组对象本身
function logArrayElements(item, index, array) {
    console.log("a[" + index + "] = " + item);
}
[2, 5, 9].forEach(logArrayElements);
// a[0] = 2
// a[1] = 5
// a[2] = 9

(15) array.map(callback[, thisArg]) => 返回一个由原数组中的每个元素调用一个指定方法后的返回值组成的新数组

var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
console.log(numbers); // [1, 4, 9]
console.log(roots); // [1, 2, 3]

(16) arr.reduce(callback,[initialValue]) => 接收一个callback函数作为累加器(accumulator),数组中的每个值(从左到右)开始合并,最终为一个值

// callback 函数传四个参数:
//   @param previousValue 上一次调用回调返回的值,或者是提供的初始值(initialValue)
//   @param currentValue 数组中当前被处理的元素
//   @param index 当前元素在数组中的索引
//   @param array 调用 reduce 的数组

function accAdd(previousValue, currentValue, index, array){
  return previousValue + currentValue;
};
[0,1,2,3,4].reduce(accAdd); // 10 第一次调用时,previousValue = 0,currentValue = 1
[0,1,2,3,4].reduce(accAdd,10); // 20 第一次调用时,previousValue = 10,currentValue = 0

//eg.将数组所有项相加
var total = [0, 1, 2, 3].reduce(function(a, b) {
    return a + b;
});
console.log(total); // 6

//eg.数组扁平化
var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) {
    return a.concat(b);
});
console.log(flattened); // [0, 1, 2, 3, 4, 5]

(17) arr.every(callback[, thisArg]) => 测试数组的所有元素是否都通过了指定函数的测试

// callback 被调用时传入三个参数:元素的值,元素的索引,被遍历的数组
function isBigEnough(element, index, array) {
  return (element >= 10);
}
[12, 5, 8, 130, 44].every(isBigEnough);   // false
[12, 54, 18, 130, 44].every(isBigEnough); // true

(18) arr.some(callback[, thisArg]) => 测试数组中的某些元素是否通过了指定函数的测试

// callback 被调用时传入三个参数:元素的值,元素的索引,被遍历的数组
function isBigEnough(element, index, array) {
  return (element >= 10);
}
[2, 5, 8, 5, 4].some(isBigEnough);   // false
[2, 3, 4, 5, 11].some(isBigEnough); // true

(19) arr.filter(callback[, thisArg]) => 使用指定的函数测试所有元素,并创建一个包含所有通过测试的元素的新数组

function isBigEnough(element, index, array) {
  return element >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44]

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/86324.html

相关文章

  • JS内置对象-Array数组对象一些常用方法区分

    摘要:语法添加删除项目的位置要删除的项目数量要添加的第一个元素第二个第三个返回值被删除的项目,如果有的话其中,第二个参数如果设置为,则不会删除任何项目。 第一篇篇幅太长了,自己回顾都觉得有点伤神。。以后尽量多篇少字~ 首先简单介绍Array数组对象 什么是数组: 用单独的变量名存储一系列的值 如何创建数组:(有3种方法) 1、常规方式: var gyt=new Array(); gyt[0...

    zorro 评论0 收藏0
  • js数组一些常用方法

    摘要:数组取差循环数组取交集利用方法取交集循环判断数组里的元素在里面有没有,有的话就放入新建立的数组中数组去重去除数组的重复成员二维数组转一维数组二维数组转为一维数组 1、数组取差 //es6 arryMinus (arry1,arry2){ let a = new Set(arry1); let b = new Set(arry2); ...

    aervon 评论0 收藏0
  • js封装一些常用方法

    摘要:整理自己常用的一些封装方法数组按照指定长度拆分数组按指定长度拆分删除数组中指定元素删除数组中指定元素将小数指定到精确位置将小数字符串精确到指定位数字符串类型的小数精确到小数点第几位根据微妙时间戳获取年月日时分秒根据微妙时间戳获取年月日时分秒 整理自己常用的一些封装方法 1.数组按照指定长度拆分 // 数组按指定长度拆分 export function chunk (data, coun...

    senntyou 评论0 收藏0
  • js数组常用方法总结

    摘要:在为的位置,删除个元素,插入删了为的元素,替换为删了为的元素数组的增删改都可以用完成返回从原数组中指定开始下标到结束下标之间的项组成的新数组该方法不会改变原始数组。不传值表示克隆了除了正常用法,经常用来将对象转换为。 js 中数组的常用方法总结 arr.fill(a);//所有子元素 都改为 a; [{a: 1},{b: 2}, ...Array(8).fill({}, 0)] //...

    luckyw 评论0 收藏0
  • 深入了解JS数组常用方法

    摘要:数组作为一种重要的数据类型,除了基础的几个方法外,还有很多实用的方法也是我们的必备技能。原数组不会改变。详细语法请参考让每个人都干点啥方法对数组的每个元素执行一次提供的函数,该方法没有返回值。 数组作为一种重要的数据类型,除了基础的 pop、push、shift、unshift 几个方法外,还有很多实用的方法也是我们的必备技能。 假设我们有一队人,如下图:showImg(https:/...

    ningwang 评论0 收藏0
  • 工作中常用es6+特性

    摘要:结合工作中使用情况,简单对进行一些复习总结,包括常用的语法,等,以及短时间内要上手需要重点学习的知识点不同工作环境可能有一些差别,主要参考链接是阮一峰的博客以及外文博客阮老师大部分文章是直接翻译的这个博客简介先说一下,是一个标准化组织,他们 结合工作中使用情况,简单对es6进行一些复习总结,包括常用的语法,api等,以及短时间内要上手需要重点学习的知识点(不同工作环境可能有一些差别),...

    xcold 评论0 收藏0

发表评论

0条评论

wendux

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<