javascript常用方法 - Array

  //1.Aarry方法

  // 1.1 Array.from(arrayLike[, mapFn[, thisArg]])
  // @arrayLike 想要转换成数组的伪数组对象或可迭代对象。
  // @mapFn     如果指定了该参数,新数组中的每个元素会执行该回调函数。
  // @thisArg   可选参数,执行回调函数 mapFn 时 this 对象。
  // 浅拷贝:从一个类似数组或可迭代对象创建一个新的,浅拷贝的数组实例。
  console.log(Array.from('foo'));
  // expected output: Array ["f", "o", "o"]
  console.log(Array.from([1, 2, 3], x => x + x));
  // expected output: Array [2, 4, 6]


  // Array.isArray(obj)
  // 于确定传递的值是否是一个 Array

  // Array.of(element0[, element1[, ...[, elementN]]])
  // 创建一个具有可变数量参数的新数组实例,而不考虑参数的数量或类型。
  Array.of(7);       // [7]       Array.of(7) 创建一个具有单个元素 7 的数组
  Array.of(1, 2, 3); // [1, 2, 3]

  Array(7);          // [ , , , , , , ]
  Array(1, 2, 3);    // [1, 2, 3]


  // 2.常用方法(修改)

  // 2.1 添加
  {
    // 2.1.1 添加(右)
    // push(element1, ..., elementN)

    // 2.1.2 添加(左)
    // unshift(element1, ..., elementN)
  }

  // 2.2 删除
  {
    // 2.2.1 删除(右1):删除最后一个元素,并返回该元素的值。(此方法更改数组的长度)
    // pop()

    // 2.2.2 删除(左1):第一个元素
    // shift()
  }

  // 2.3 删除\替换\添加
  // splice(start[, deleteCount[, item1[, item2[, ...]]]])
  // @start​             指定修改的开始位置(从0计数)。如果超出了数组的长度,则从数组末尾开始添加内容.
  // @deleteCount       整数,表示要移除的数组元素的个数。
  // @item1, item2, ... 添加进数组的元素,从start 位置开始。如果不指定,则 splice() 将只删除数组元素
  // @return            由被删除的元素组成的一个数组。如果只删除了一个元素,则返回只包含一个元素的数组。如果没有删除元素,则返回空数组

  // 实例1:添加,从第 2 位开始删除 0 个元素,插入“drum”
  var myFish = ["1ab", "2cd", "3ef", "4gh"];
  var removed = myFish.splice(2, 0, "5ij");
  // 运算后的 myFish: ["1ab", "2cd", "5ij", "3ef", "4gh"]
  // 被删除的元素 removed: [], 没有元素被删除
  console.log(myFish);
  console.log(removed);

  // 实例2:替换,从第 2 位开始删除 1 个元素,插入“trumpet”
  var myFish = ["1ab", "2cd", "3ef", "4gh"];
  var removed = myFish.splice(2, 1, "5ij");
  console.log(myFish);
  console.log(removed);
  // 运算后的 myFish: ["1ab", "2cd", "5ij", "4gh"]
  // 被删除的元素 removed: ["3ef"], 没有元素被删除

  // 2.4.排序
  {
    // 2.4.1 颠倒
    // reverse()

    // 2.4.2 排序 
    // sort([compareFunction])
    // @compareFunction 一个比较函数
    // https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

    // 比较数字 
    var numbers = [4, 2, 5, 1, 3];
    numbers.sort(function (a, b) {
      return a - b;
    });
    // 可以写成 numbers.sort((a, b) => a - b); 
    console.log(numbers);  // [1, 2, 3, 4, 5]
  }

  // 3.常用方法(访问)

  // 3.1 合并 
  {
    // 3.1.1 合并成(数组)
    // var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])


    // 3.1.2 连接成一个(字符串)(自定义)
    // join([separator])
    var elements = ['Fire', 'Air', 'Water'];
    console.log(elements.join()); //"Fire,Air,Water"
    console.log(elements.join('')); //"FireAirWater"
    console.log(elements.join('-')); //"Fire-Air-Water"


    // 3.1.3  连接成一个(字符串)(用,隔开)
    // toString()
  }


  // 3.2 判断
  {
    // 3.2.1 包含一个指定的值
    // includes(valueToFind[, fromIndex])
    var array1 = [1, 2, 3];
    console.log(array1.includes(2)); //true
  }


  // 3.3 截取当前数组中的一段元素组合成一个新数组(浅拷贝)
  // slice([begin[, end]])
  // 由 begin 和 end 决定的原数组的浅拷贝(包括 begin,不包括end)
  var animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
  console.log(animals.slice(2));     // Array ["camel", "duck", "elephant"]
  console.log(animals.slice(2, 4));  // Array ["camel", "duck"]
  console.log(animals.slice(1, 5));  // Array ["bison", "camel", "duck", "elephant"]


  // 3.4 由数组元素组合而成的【本地化】后的字符串
  // toLocaleString([locales[,options]])
  // @locales 带有BCP 47语言标记的字符串或字符串数组,关于locales参数的形式与解释,请看Intl页面。
  // https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Intl
  // @options 一个可配置属性的对象,对于数字 Number.prototype.toLocaleString(),对于日期 Date.prototype.toLocaleString().
  var array1 = [1, 'a', new Date('21 Dec 1997 14:12:00 UTC')];
  var localeString = array1.toLocaleString('en', { timeZone: "UTC" });
  console.log(localeString);
  // expected output: "1,a,12/21/1997, 2:12:00 PM",
  // This assumes "en" locale and UTC timezone - your results may vary

  // 3.5 查找
  {
    // 3.5.1 查找(左)
    // indexOf(searchElement[, fromIndex])
    var array = ["1ab", "2cd", "3ef", "4gh"];
    var idx1 = array.indexOf('3ef'); //2
    var idx2 = array.indexOf('ab'); //-1

    // 3.5.2 查找(右)
    // lastIndexOf(searchElement[, fromIndex])
    var animals = ['Dodo', 'Tiger', 'Penguin', 'Dodo'];
    console.log(animals.lastIndexOf('Dodo')); //3
    console.log(animals.lastIndexOf('Tiger')); //1

    // 3.5.3 查找通过测试函数的第一个元素的(值)。否则返回 undefined。
    // find(callback[, thisArg])
    var array1 = [5, 12, 8, 130, 44];
    var found = array1.find(function (element) {
      return element > 10;
    });
    console.log(found); //  12

    // 3.5.4 查找通过测试函数的第一个元素的(索引)。否则返回 -1.
    // findIndex(callback[, thisArg])
    var found2 = array1.findIndex(function (element) {
      return element > 10;
    });
    console.log(found2); //  1
  }


  // 4.常用方法(迭代)

  // 4.1 普通循环

  // 4.1.1 循环执行一次(不能跳出循环)
  // forEach(callback(currentValue[, index[, array]])[, thisArg]);
  // @callback(currentValue[, index[, array]]) 为数组中每个元素执行的函数,该函数接收三个参数:
  //      @currentValue 数组中正在处理的当前元素。
  //      @index(可选) 数组中正在处理的当前元素的索引。
  //      @array(可选) forEach() 方法正在操作的数组。
  // @thisArg  可选参数。当执行回调函数时用作 this 的值(参考对象) 。
  function logArrayElements(element, index, array) {
    console.log('a[' + index + '] = ' + element);
  }

  // 注意索引 2 被跳过了,因为在数组的这个位置没有项
  [2, 5, , 9].forEach(logArrayElements);
  // logs:
  // a[0] = 2
  // a[1] = 5
  // a[3] = 9

  // 4.2 循环判断
  {
    // 4.2.1 判断(每个元素)都通过测试函数
    // every(callback[, thisArg])
    function isBelowThreshold(currentValue) {
      return currentValue < 40;
    }
    var array1 = [1, 30, 39, 29, 10, 13];
    console.log(array1.every(isBelowThreshold)); //true


    // 4.2.2 判断有(1个元素)通过测试函数
    // some(callback(element[, index[, array]])[, thisArg])

    // 例1:是否有能除尽2的值
    var array = [1, 2, 3, 4, 5];
    var even = function (element) {
      // checks whether an element is even
      return element % 2 === 0;
    };
    console.log(array.some(even)); //true
    console.log("---------");

    // 例2:判断数组元素中是否存在某个值
    var serr = ["EN-US", "zh-cn", "fr-fr"];
    var bool = serr.some(function name(element) {
      return element.toLowerCase() === "en-us";
    })
    console.log(bool); //true
  }

  // 4.3 创建新数组
  {
    // 4.3.1 通过测试函数过滤的所有数组组成的新数组
    // var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
    var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];
    const result = words.filter(word => word.length > 6);
    console.log(result);
    // expected output: Array ["exuberant", "destruction", "present"]


    // 4.3.2 每个元素执行一次测试函数后的返回值组成的行数组,
    // 当你不打算使用返回的新数组却使用map是违背设计初衷的,请用forEach或者for-of替代
    // var new_array = arr.map(function callback(currentValue[, index[, array]])[, thisArg])
    var array1 = [1, 4, 9, 16];
    const map1 = array1.map(x => x * 2);
    console.log(map1);
    // expected output: Array [2, 8, 18, 32]
  }

  // 4.4 累计器
  {
    // 4.4.1 从左到右为每个数组元素执行一次回调函数,并把上次回调函数的返回值放在一个暂存器中传给下次回调函数,
    //       并返回最后一次回调函数的返回值。
    // reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
    // @callback 执行数组中每个值 (如果没有提供 initialValue则第一个值除外)的函数,包含四个参数:
    //      @accumulator     累计器累计回调的返回值; 它是上一次调用回调时返回的累积值,或initialValue(见于下方)。
    //      @currentValue    数组中正在处理的元素。
    //      @index (可选)   数组中正在处理的当前元素的索引。 如果提供了initialValue,则起始索引号为0,否则从索引1起始。
    //      @array (可选)    调用reduce()的数组
    // @initialValue (可选)  作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值,则将使用数组中的第一个元素。 
    //                       在没有初始值的空数组上调用 reduce 将报错。
    // @return 函数累计处理的结果

    const array1 = [1, 2, 3, 4];
    const reducer = function (accumulator, currentValue) {
      return accumulator + currentValue;
    }
    // 1 + 2 + 3 + 4
    console.log(array1.reduce(reducer));
    // 5 + 1 + 2 + 3 + 4
    console.log(array1.reduce(reducer, 5));


    // 4.4.2 从右到左为每个数组元素执行一次回调函数,并把上次回调函数的返回值放在一个暂存器中传给下次回调函数,
    //       并返回最后一次回调函数的返回值。
    // reduceRight(callback(accumulator, currentValue[, index[, array]])[, initialValue])
  }

  // *(实验性API) 4.5 键值对
  {
    // 4.5.1 entries()
    // 返回键值对数组
    var array1 = ['a', 'b', 'c'];
    var iterator1 = array1.entries();
    console.log(iterator1.next().value);
    // expected output: Array [0, "a"]
    console.log(iterator1.next().value);
    // expected output: Array [1, "b"]


    // 4.5.2 keys()
    // 返回键数组


    // 4.5.3 values()
    //返回值数组
  }

posted @ 2019-10-30 23:27  【唐】三三  阅读(269)  评论(0编辑  收藏  举报