js数组操作方法大全

作者: puxiaotaoc | 来源:发表于2018-09-13 22:16 被阅读61次

1）concat方法：不会改变原数组，会返回一个拼接后的新数组

  var arr1 = [1,2,3];
  var arr2 = [3,4];
  arr1.concat(arr2);
  console.log(arr1.length); // 3
  console.log(arr1); // [1, 2, 3]
  console.log(arr2); // [3, 4]
  console.log(arr1.concat(arr2)) // [1, 2, 3, 3, 4]

2）slice方法：不会改变原数组，会返回一个截取后的新数组

  var arr = [1,2,3,4,5,6];
  arr.slice(1,4);
  console.log(arr); // (6) [1, 2, 3, 4, 5, 6]
  console.log(arr.length); // 6
  console.log(arr.slice(1,4)); // (3) [2, 3, 4]

// slice方法的手动实现，不绑定到原型链上
  function my_slice(start, end) {
    var start = start || 0;
    var end = end || this.length; //this指向调用的对象，当用了call后，能够改变this的指向，也就是指向传进来的对象，这是关键
    var result = [];
    for (var i = start; i < end; i++) {
      result.push(this[i]);
    }
    return result;
  }
  arr = [1, 2, 3, 4, 5, 6];
  console.log(my_slice.call(arr)); // [1, 2, 3, 4, 5, 6]
  console.log(my_slice.call(arr, 1, 4)); // [2, 3, 4]
  console.log(my_slice.call(arr, 1, 6)); // [2, 3, 4, 5, 6]

// // slice方法的手动实现，绑定到原型链上
  Array.prototype.my_slice = function(start, end) {
    var result = [];
    var start = start || 0;
    var end = end || this.length;
    for (var i = start; i < end; i++) {
      result.push(this[i]);
    }
    return result;
  }

  var arr = [1,2,3,4,5,6];
  console.log(arr.my_slice()); // [1, 2, 3, 4, 5, 6]
  console.log(arr.my_slice(1,4)); // [2, 3, 4]
  console.log(arr.my_slice(1,6)); // [2, 3, 4, 5, 6]

3）join方法：不会改变原数组，会返回一个字符串

  var arr = [1,2,3,4,5];
  arr.join('-');
  console.log(arr); // [1, 2, 3, 4, 5]
  console.log(arr.length); // 5
  console.log(arr.join('-')); // '1-2-3-4-5'

4）push/pop方法：会改变原数组

  var arr = [1, 2, 3, 4, 5];
  arr.push(6);
  console.log(arr); // (6) [1, 2, 3, 4, 5, 6]
  console.log(arr.push(7)); // 7
  console.log(arr); // (7) [1, 2, 3, 4, 5, 6, 7]
  arr.pop();
  console.log(arr); // (6) [1, 2, 3, 4, 5, 6]
  console.log(arr.pop()); // 6

5）shift/unshift方法：会改变数组

  var arr = [1,2,3,4,5];
  arr.shift();
  console.log(arr); // (4) [2, 3, 4, 5]
  console.log(arr.length); // 4
  arr.unshift(6);
  console.log(arr); // (5) [6, 2, 3, 4, 5]
  console.log(arr.length); // 5

6）sort方法：会改变数组

  var arr = [21, 1, 3, 45, 2];
  arr.sort();
  console.log(arr); // (5) [1, 2, 21, 3, 45]
  arr.sort(function(a, b) {
    if (a < b) {
      return -1;
    } else if (a > b) {
      return 1;
    } else {
      return 0;
    }
  })
  console.log(arr); // (5) [1, 2, 3, 21, 45]

7）reverse方法：会改变数组

  var arr = [21, 1, 3, 45, 2];
  arr.reverse();
  console.log(arr); // (5) [2, 45, 3, 1, 21]

8）splice方法：会改变数组，并以数组形式返回被删除的部分，插入时返回空数组

  var arr = [1, 2, 3, 4, 5];
  console.log(arr.splice(1,3)); // (3) [2, 3, 4] 返回被删除的数
  console.log(arr); // (2) [1, 5]
  var arr1 = [1,2,3,4,5];
  console.log(arr1.splice(1,0,7,8)); // [] 插入时返回空数组
  console.log(arr1); // (7) [1, 7, 8, 2, 3, 4, 5]
  var arr2 = [1,2,3,4,5];
  console.log(arr2.splice(1,1,7,8)); // [2] 返回被替换掉的数
  console.log(arr2); // (6) [1, 7, 8, 3, 4, 5]

9）indexOf/lastIndexOf方法：不会改变数组，返回指定数值的数组下标

  var arr = [1, 2, 3, 2, 5];
  console.log(arr.indexOf(2)); // 1 返回值为2的数组的下标
  console.log(arr.indexOf(2,2)); // 3 第一个参数表示要查找的数，第二个参数表示查找起点位置的索引
  console.log(arr.indexOf(6)); // -1
  console.log(arr.lastIndexOf(2)); // 3 从数组的末尾开始向前查找，返回正序下标
  console.log(arr.lastIndexOf(2,2)); // 1 从数组的末尾开始向前查找，返回正序下标

10）forEach方法：不会改变数组且方法没有返回值

  var arr = [1, 2, 3, 2, 5];
  arr.forEach(function(a, index, array) { // 循环遍历,对每一项运行给定函数,这个方法没有返回值
  console.log(a, index, array === arr); // 参数分别为：遍历的数组内容,内容对应的数组索引,数组本身
    // 1 0 true
    // 2 1 true
    // 3 2 true
    // 2 3 true
    // 5 4 true
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.forEach(function(a) { // forEach方法没有返回值
    return a * 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // undefined

11）map方法：不会改变原数组且返回一个新数组

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.map(function(a) { // 对每一项运行给定函数，返回每次函数调用的结果组成的数组
    return a * 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // (5) [2, 4, 6, 4, 10]

12）filter方法：不会改变原数组，且返回一个新数组

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.filter(function(a) { // 返回满足过滤条件组成的数组
    return a > 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // (2) [3, 5]

13）every方法：不会改变原数组，且返回一个布尔值

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.every(function(a) { // 判断数组中每一项都是否满足条件，所有项都满足条件才会返回true
    return a > 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // false

14）some方法：不会改变原数组，且返回一个布尔值

  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.some(function(a) { // 判断数组中每一项都是否满足条件，只要有一项满足条件就会返回true
    return a > 2;
  })
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(arr1); // true

15）reduce方法：不会改变原数组，迭代数组的所有项，然后构建一个最终返回的值，从数组的第一项开始，逐个遍历到最后

  var arr = [1, 2, 3, 2, 5];
  // reduce方法有两个参数：在每一项上调用的函数和（可选的）作为归并基础的初始值
  // reduce方法的函数接收 4 个参数：前一个值、当前值、项的索引和数组对象
  // 这个函数返回的任何值都会作为第一个参数自动传给下一项
  // 第一次迭代发生在数组的第二项上，因此第一个参数是数组的第一项，第二个参数是数组的第二项
  var sum = arr.reduce(function(pre, cur, index, array) { 
    return pre + cur;
  }, 10)
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(sum); // 23

16）reduceRight：不会改变原数组，迭代数组的所有项，从数组的最后一项开始，向前遍历到第一项

  var arr = [1, 2, 3, 2, 5];
  var sum = arr.reduceRight(function(pre, cur, index, array) { 
    return pre + cur;
  }, 10)
  console.log(arr); // (5) [1, 2, 3, 2, 5]
  console.log(sum); // 23

17）fill：会改变原数组，元素填充

// arr.fill(value, start, end)
  var arr = [1, 2, 3, 2, 5];
  arr.fill(1,2,4); // 用1填充数组中从起始索引到终止索引内的全部元素
  console.log(arr); // (5) [1, 2, 1, 1, 5]

18）find：不会改变原数组，返回数组中满足提供的测试函数的第一个元素的值

  function big(element) {
    return element >= 2;
  }
  var arr = [1, 2, 3, 2, 5];
  var arr1 = arr.find(big); // 返回数组中满足提供的测试函数的第一个元素的值
  console.log(arr1); // 2 
  console.log(arr); // (5) [1, 2, 3, 2, 5]

19）includes方法：用来判断一个数组是否包含一个指定的值，返回 true或 false

  var arr = [1, 2, 3, 2, 5];
  console.log(arr.includes(2)); // true
  console.log(arr.includes(6)); // false

20）toLocaleString：不会改变原数组，返回一个字符串表示数组中的元素，数组中的元素将使用各自的 toLocaleString 方法转成字符串，这些字符串将使用一个特定语言环境的字符串（例如一个逗号 “,”）隔开

  var arr = [11111111, 2222222];
  console.log(arr.toLocaleString()); // 11,111,111,2,222,222
  console.log(arr); // (2) [11111111, 2222222]

21）toString：不会改变原数组，返回一个字符串，表示指定的数组及其元素

  var arr = [1,2,3];
  arr.toString();
  console.log(arr.toString()); // '1,2,3'
  console.log(arr); // (3) [1, 2, 3]

22）Array.from：将伪数组或可迭代对象(包括arguments Array,Map,Set,String…)转换成数组对象

// arrayLike：想要转换成数组的伪数组对象或可迭代对象
// mapFn (可选参数)：如果指定了该参数，新数组中的每个元素会执行该回调函数
// thisArg (可选参数)：可选参数，执行回调函数 mapFn 时 this 对象
// 返回值：一个新的数组实例
Array.from(arrayLike, mapFn, thisArg)

toString()方法与toLocalString()方法区别：

1）toLocalString()是调用每个数组元素的 toLocaleString() 方法，然后使用地区特定的分隔符把生成的字符串连接起来，形成一个字符串；

2）toString()方法获取的是String(传统字符串),而toLocaleString()方法获取的是LocaleString(本地环境字符串)；

3）如果你开发的脚本在世界范围都有人使用，那么将对象转换成字符串时请使用toString()方法来完成；

4）LocaleString()会根据你机器的本地环境来返回字符串，它和toString()返回的值在不同的本地环境下使用的符号会有微妙的变化；

5）使用toString()是保险的，返回唯一值的方法,它不会因为本地环境的改变而发生变化；如果是为了返回时间类型的数据，推荐使用LocaleString()；若是在后台处理字符串，请务必使用toString()；

###toString()、toLocaleString()、valueOf()方法的区别
// JS Array
  var arr = [12421,22232,3333];
  console.log(arr.valueOf()); // (3) [12421, 22232, 3333] 返回数组本身
  console.log(arr.toString()); // '12421,22232,3333' 把数组转换为字符串，并返回结果，每一项以逗号分割
  console.log(arr.toLocaleString()); // '12,421,22,232,3,333' 把数组转换为本地数组，并返回结果

// JS Boolean
  var boolean = new Boolean();
  console.log(boolean.valueOf()); // false 返回 Boolean 对象的原始值
  // 根据原始布尔值或者 booleanObject 对象的值返回字符串 "true" 或 "false",默认为"false"
  console.log(boolean.toString()); // 'false'
  // Boolean对象没有toLocalString()方法,但是在Boolean对象上使用这个方法也不会报错

// JS Math
console.log(Math.PI.valueOf()); // 3.141592653589793

// JS Number
  var num = new Number(11337);
  console.log(num.valueOf()); // 11337
  console.log(num.toString()); // '11337'
  console.log(num.toLocaleString()); // '11,337'

// JS String
  var str = 'fsflgs';
  console.log(str.valueOf()); // 'fsflgs'
  console.log(str.toString()); // 'fsflgs'
  console.log(str.toLocaleString()); // 'fsflgs'

// JS Date
  var date = new Date();
  console.log(date); // Thu Sep 13 2018 21:51:58 GMT+0800 (中国标准时间)
  console.log(date.toLocaleString()); // 2018/9/13 下午9:51:58

会改变原数组的方法

pop、push、shift、unshift、fill、sort、reverse、splice

参考链接：
js数组方法大全
 Javascript toString()、toLocaleString()、valueOf()三个方法的区别

网友评论

本文标题：js数组操作方法大全

本文链接：https://www.haomeiwen.com/subject/dhtggftx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

js数组操作方法大全

会改变原数组的方法

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

前端面试基础必备

JS学习笔记

JavaScript相关文章