js 你不知道的 Array

一、在类数组对象上复用通用的数组要领

类数组有:arguments, NodeList, 字符串

什么是类数组? 两个前提

  1. 具有 length 属性

  2. length 属性大于该对象的最大索引

比方:

  var arrayLike = { 0: "a", 1: "b", 2: "c", length: 3};
  var result = Array.prototype.map.call(arrayLike, function(s) {
    return s.toUpperCase();
  });//["A", "B", "C"]

险些一切的数组要领都是通用的(forEach,slice,map …) 除了 concat。

由于 concat 在衔接时,会搜检其参数的 [[Class]] 属性。

一些要领,比方 join,仅仅读取他们被挪用的对象的长度和数值属性。 别的,像 reverse 一样,请求对象的数值属性和长度属性是可变的;因而,这些要领不能在像 String 如许的对象上被挪用,String不允许它的长度属性和synthesized的数值属性被设置。

  function namesColumn() {
    return ['Names'].concat(arguments);
  }
  namesColumn("alice", "arale");//["Names", {0: "alice", 1: "arale"}]

  //解决办法:应先运用 slice 将 arguments 转为数组
  function namesColumn() {
    return ['Names'].concat([].slice.call(arguments));
  }

二、数组优先运用 for 轮回,而不是 for in 轮回。

for in 更多的是用于 遍历对象,然则 它也会去搜检 对象的原型。

假如浏览器支撑 for of (ES6)的话,最好是运用它,它不会去遍历原型。

三、迭代优于轮回

一个原因是,迭代能够消弭没必要的 停止前提任何数组索引

比方:

  for (var i = 0; n = players.length; i < n; i++) {
    players[i].score++;
  }

  //运用迭代
  players.forEach(function(p){
    p.score++;
  });

例1: 对数组每个元素操纵后天生一个新的数组

  //取得一切输入框去除过剩空格后的值
  var trimmed = input.map(function(s) {
    return s.trim()
  })

例2: 猎取价钱在特定区间的列表

  listings.filter(function(listing) {
    return listing.price >= min && listing.price <= max
  })

固然这都是 ES5 的要领,我们也能够本身写一个。

  function takeWhile(a, pred) {
    var result = []
    for (var i = 0; n = a.length; i < n; i++) {
      if (!pred(a[i], i)) {
       break
      }
      result[i] = a[i]
    }
    return result
  }

  var prefix = takeWhile([1, 2, 4, 8, 16, 32], function(n) {
    return n < 10
  }) // [1, 2, 4, 8]

把它加在 Array 上

  Array.prototype.takeWhile = function(pred) {
    var result = []
    for (var i = 0; n = this.length; i < n; i++) {
      if (!pred(this[i], i)) {
        break
      }
      result[i] = this[i]
    }
    return result
  }

  [1, 2, 4, 8, 16, 32].takeWhile(function(n) {
    return n < 10
  }) // [1, 2, 4, 8]

轮回仅一点优于迭代: 掌握流操纵 如 break 和 continue

ES5 中 只要 some 和 every 能够提早停止轮回, 但设想他们的本意不是用来提早停止轮回。

// some 一旦回调发生了一个真值,则马上返回,不会实行其他的元素
[1, 10, 100].some(function(x) { return x > 5 }) //true
[1, 10, 100].some(function(x) { return x < 0 }) //false
// every 相反, 一旦发生假值,则马上返回,不会实行其他元素
[1, 2, 3, 4, 5].every(function(x) { return x > 0 }) //true
[1, 2, 3, 4, 5].every(function(x) { return x < 3 }) //false

这类行动能够用来完成 forEach 提早停止轮回的变种时派上用场

  function takeWhile(a, pred) {
    var result = [];
    a.every(function(x, i) {
      if (!pred(x)) {
        return false //break
      }
      result[i] = x;
      return true; //continue
    })
    return result
  }

四、数组要领分类

1. Mutator 要领

这些要领能够转变数组本身

  • pop : 移除数组的末了一个元素,返回值是被删除的元素。

  • push : 在数组的末端增加一个或许多个元素,返回值是新的数组的长度。

  • reverse : 倒置数组中元素的递次,本来第一个元素如今变成末了一个,一样本来的末了一个元素变成了如今的第一个,也就是数组的索引发生了变化。

  • shift : 删除数组的第一个元素,返回值是删除的元素

  • sort : 对数组中的元素举行排序

  • splice : 增加或删除数组中的一个或多个元素。

  • unshift : (将烧毁)增加一个或许多个元素在数组的开首,返回值是新的数组的长度。

2. Accessor 要领

这些要领不转变数组本身

  • concat : 返回一个包括此数组和其他数组和/或值的连系的新数组

  • indexOf : 返回第一个与给定参数相称的数组元素的索引,没有找到则返回-1

  • join : 将一切的数组元素衔接成一个字符串

  • lastIndexOf : 返回在数组中搜刮到的与给定参数相称的元素的末了(最大)索引

  • slice : 返回数组中的一段。

  • toString : 返回代表该数组及其元素的字符,重写Object.toString 历程.

  • valueOf : 重写Object.valueOf历程。

3. 轮回(迭代) 要领
  • filter : 对数组中的每个元素挪用参数中指定的过滤函数,并将关于过滤函数返回值为true的那些数组元素集合为新的数组返回。

  • forEach : 对数组的每个元素顺次挪用参数中指定的函数。

  • every : 假如数组中每个元素都满足参数中供应的测试函数,则返回真

  • map : 建立一个新数组,新数组中含有,离别关于本来数组的每个元素挪用一个给定函数的效果

  • some : 假如数组中至少有一个元素满足参数函数的测试,则返回true。

    原文作者:honger05
    原文地址: https://segmentfault.com/a/1190000003738483
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞