JS高程5.援用类型(6)Array类型的岗位方法,迭代方式,合并措施

作者:运维知识    发布时间:2019-12-11 14:06     浏览次数 :

[返回]

ES5中新扩张了写数组方法,如下:

 

意气风发、检验方法

  1. instanceof
  2. Array.isArray()   (ES5 新增)

    var arr = [1,2,3,4,5,6];
    
    arr instanceof Array; // true
    
    Array.isArray(arr);      // true
    

     

对数组中的每项运营给定的函数,再次回到每一次函数调用的结果组成的数组。

1 var numbers=[1,2,3,4,5,4,3,2,1];
2 var everyResult=numbers.every(function(item,index,array){
3     return(item>2);
4 })
5 var everyResult1=numbers.every(function(item,index,array){
6     return(item>0);
7 })
8 alert(everyResult);//false
9 alert(everyResult1);//true

主意总览:

  • instanceOf
  • Array.isArray()
  • toString()
  • join()
  • push()
  • pop()
  • shift()
  • unshift()
  • splice()
  • concat()
  • slice()
  • indexOf
  • lastIndexOf
  • reverse()
  • sort()
  • forEach()
  • filter()
  • map()
  • every()
  • some()
  • reduce()
  • reduceRight()

注意: every(卡塔尔 不会转移原始数组。

1 var numbers=[1,2,3,4,5,4,3,2,1];
2 var mapResult=numbers.map(function(item,index,array){
3     return(item+4);
4 })
5 var mapResult1=numbers.map(function(item,index,array){
6     return(item>5);
7 })
8 alert(mapResult);//5,6,7,8,9,10,9,8,7,6,5
9 alert(mapResult1);//false,false,false,false,false,false,false,false,false

二、调换为字符串的议程

    调换方法不转移原数组,只回去调换后的字符串

  1. toString()

    var arr1 = [1,2,3,4,6];
    var arr2 = ['a','b','c','d'];
    
    arr1.toString();    // '1,2,3,4,5,6'
    arr2.toString();    // 'a,b,c,d'
    
  2. join()

    /*
     *  join方法只接受一个参数,即用作分隔符的字符串,
     *  然后返回包含所有数组项的字符串
     */
    var arr = [1,2,3,4,5];
    
    arr.join('');  // '12345'
    arr.join('-'); // '1-2-3-4-5'
    

     

[2,4,6,8,10,8,6,4,2] 4.5、forEach()

1 var numbers=[1,2,3,4,5,4,3,2,1];
2 var forEachResult=numbers.forEach(function(item,index,array){
3     return(item+4);
4 })
5 var forEachResult1=numbers.forEach(function(item,index,array){
6     return(item>5);
7 })
8 alert(forEachResult);//undefined
9 alert(forEachResult1);//undefined

四、排序方法

     排序方法会改换原数组

  1.   reverse()

    /*
     *  Array.reverse()
     *  翻转数组项的顺序
     *
     */
     var arr = [1,2,3,4,5];
    
     arr.reverse();
     alert(arr);    // [5,4,3,2,1]
    
  2. sort()

    /*
     *  Array.sort(callback)
     *  sort为数组的排序方法,默认按数组每一项进行toString()后的结果进行
     *  升序排序
     *  sort接收一个回调函数为参数,回调函数有两个参数,代表数组的前一项和
     *  后一项,如果第一个参数应该位于第二个之前则返回一个负数,如果两个参数相等
     *  则返回 0,如果第一个参数应该位于第二个之后则返回一个正数
     */
     var arr1 = [2,1,4,3,5];
     var arr2 = [1,50,10,500,100,1000];
    
     arr1.sort();
     arr2.sort();
     alert(arr1);   // [1,2,3,4,5]
     alert(arr2);   // [1,10,100,1000,50,500]
    
     arr2.sort(function(pre,next) {
        if(pre < next) {
            return -1;
        }else if(pre === next) {
            return 0;
        }else {
            return 1;
        }
     });
     alert(arr2);   // [1,10,50,100,500,1000]
    

而reduceRight(卡塔尔(قطر‎则从数组的末段一项早先,向前遍历到第大器晚成项。那七个章程都吸收七个参数:二个在每风度翩翩项上调用的函数和作为减弱根基的初步值。

(2)some():对数组中的每少年老成项运营给定函数,即使该函数对擅高傲器晚成项重临true,则赶回true。

五、迭代艺术(ES5)

        数组的迭代方法都接到二个回调函数,这些回调函数会在数组的每黄金时代项上运维,回调函数选择七个参数:数组项的值,数组项的目录,数组对象自己。

  1. forEach():对数组中的每少年老成项运转给定函数。未有重临值。

    var arr = ['one','two','three'];
    arr.forEach(function(item,index,thisArr) {
        // 迭代的item 为arr 每一项的值
        // 迭代的index 为arr 每一项的索引
        // thisArr 为 数组arr
    });
    
  2. filter(卡塔尔国:对数组的每意气风发项运转给定函数, 重临该函数会回去 true 的项组成的数组。

    var arr = [1,2,3,4,5,6,7];
    var filterArr = arr.filter(function(item,index,thisArr) {
        return item > 4;
    });
    alert(filterArr);   // [5,6,7]
    
  3. map(卡塔尔国: 对数组中的每生龙活虎项运维给定函数,重返每趟函数调用的结果组成的数组。

    var arr = [1,2,3,4,5,6,7];
    var mapArr = arr.map(function(item,index,thisArr) {
        return item + 10;
    });
    alert(mapArr);  // [11,12,13,14,15,16,17]
    
  4. every(卡塔尔国: 对数组中的每生机勃勃项运维给定函数,尽管该函数对每风度翩翩项都回去 true,则赶回 true。

    var arr = [1,2,3,4,5,6,7];
    
    var every1 = arr.every(function(item,index,thisArr) {
        // 对数组每一项与4进行比较
        return item > 4;
    });
    alert(every1);  // false
    
    var every2 = arr.every(function(item,index,thisArr) {
        // 对数组每一项与8进行比较
        return item < 8;
    });
    alert(every2);  // true
    
  5. some(卡塔尔: 对数组中的每豆蔻梢头项运转给定函数,倘使该函数对任风华正茂项再次回到 true,则赶回 true。

    var arr = [1,2,3,4,5,6,7];
    
    var some = arr.some(function(item,index,thisArr) {
        // 对数组每一项与4进行比较,只要有一项大于4,就返回true
        return item > 4;
    });
    alert(some);    // true
    
  6. reduce(卡塔尔(قطر‎,reduceRight(卡塔尔(قطر‎: 迭代数组的具有项,然后营造八个末段回到的值, 传给 reduce(卡塔尔(英语:State of Qatar)和 reduceRight(卡塔尔(قطر‎的函数接受 4 个参数:前三个值、当前值、项的目录和数组对象。这几个函数重返的别的值都会作为第多少个参数自动传给下风流洒脱项。

    var arr = [1,2,3,4,5];
    
    // 使用reduce进行数组求和操作
    var sum = arr.reduce(function(pre,current,index,thisArr) {
        return pre + current;
    });
    
    // reduceRight 则从相反方向,即从右向左迭代,结果一致
    alert(sum);     // 15
    

陈说:给数组中的每项乘以2,重回这么些乘积组成的数组,代码如下:

1 var number=[1,2,3,4,5];
2 var sum=number.reduce(function(prev,cur,index,array){
3     return prev+cur;
4 });
5 alert(sum);//15

三、操作方法

    1. 会改造原数组的操作方法

  •  push()

    /*
     *  arr.push(arg1,arg2,arg3...)
     *  push方法接收任意数量的参数,并逐个添加到目标数组末尾,
     *  返回值为目标数组修改后的长度
     */
     var arr = [1,2,3];
     alert(arr.push(4,5));      // 5
     alert(arr);                // [1,2,3,4,5]
    
  • pop()

    /*
     *  arr.pop()
     *  pop方法为从目标数组末尾移除一项,并返回该移除项
     */
     var arr = [1,2,3,4,5];
     alert(arr.pop());      // 5
     alert(arr);            // [1,2,3,4]
    
  • shift()

     /*
      *  arr.shift()
      *  shift方法为从目标数组开头移除一项,并返回该移除项
      */
     var arr = [1,2,3,4,5];
     alert(arr.shift());    // 1
     alert(arr);            // [2,3,4,5]
    
  • unshift

     /*
      *  arr.unshift(arg1,arg2,arg3...)
      *  unshift方法接收任意数量的参数,并逐个添加到目标数组开头,
      *  返回值为目标数组修改后的长度
      */
     var arr4 = [1,2,3];
     alert(arr4.unshift(4,5));  // 5
     alert(arr4);               // [4,5,1,2,3]
    
  • splice()

    /*
     *  Array.splice(index,howmany,arg1,arg2...);
     *  splice主要用途为向数组中插入项,方法主要为两种:
     *  删除:  splice(要删除的第一项的位置,要删除的项数)
     *  插入或替换: splice(起始位置,要删除的项数,要插入的项数)
     *
     *  返回值为一个包含删除项的数组
     */
    
     // 删除
     var arr1 = ['one','two','three'];
     var remove = arr1.splice(1,1);
     alert(remove);     // ['two']
     alert(arr1);       // ['one','three']
    
     // 插入
     var arr2 = ['one','two','three'];
     var remove = arr2.splice(1,2,'four','five');
     alert(remove);     // ['two','three']
     alert(arr2);       // ['one','four','five']
    
     // 替换
     var arr3 = ['one','two','three'];
     var remove = arr3.splice(1,1,'four');
     alert(remove);     // ['two']
     alert(arr3);       // ['one','four','three']
    

    2. 不会转移原数组的法门

  •  concat()

    /*
     *  Array.concat(arg1,arg2,arg3...)
     *  concat方法为先创建当前数组一个副本,然后将接收的参数添加到副本末尾,
     *  最后返回该新数组
     */
     var arr = [1,2,3];
     var a = ['one','two'];
     var b = 'three';
     var c = { name: 'four'};
    
     var newArr = arr.concat(a,b,c);
     alert(newArr); // [1,2,3,'one','three',{name:'four'}]
    
  • slice()

    /*
     *  Array.slice(start,end)
     *  slice方法为截取数组,返回截取项组成的新数组
     *  slice 为一个参数时,截取该参数指定的开始项到数组的末尾
     *  slice 为两个参数时,截取参数指定的起始和结束项,但不包括结束项(包左不包右)
     */
     var arr = [1,2,3,4,5,6,7,8,9];
    
     var sliceArr1 = arr.slice(3);     // [4,5,6,7,8,9]
     var sliceArr2 = arr.slice(3,5); // [4,5]
     var sliceArr3 = arr.slice(3,-1);    // [4,5,6,7,8]
     var sliceArr4 = arr.slice(-3,-1);   // [7,8]
     var sliceArr5 = arr.slice(-1,-3);   // []
    
  • indexOf() 与 lastIndexOf()

    /*
     *  indexOf(value,start),lastIndexOf(value,start)
     *  两方法都为数组查找方法,查找目标项成功则返回数组该值的索引,
     *  查找失败则返回-1
     *  第一个参数为要查找的目标值,第二个参数查找的起始位置
     *  indexOf 为正序查找  
     *  lastIndexOf 为逆序查找
     */
     var arr = ['one','two','two','three','four','four','five'];
    
     var index1 = arr.indexOf('two');        // 1
     var index2 = arr.indexOf('two',2);        // 2
     var index3 = arr.lastIndexOf('four');   // 5
     var index4 = arr.lastIndexOf('four',4);  // 4
    

概念和用法:every(卡塔尔国 方法用于检查评定数组全体因素是不是都手足之情钦命条件。

三.合并方法

汇报:使用reduce(卡塔尔方法可以执行求数组中全部值之和的操作。代码如下:

 

对数组中的每意气风发项运维给定函数,再次回到该函数会回来true的项的数组。

流传这一个点子中的函数会选用多少个参数:数组项的值,该项在数组中之处和数组对象自我。

对数组中的每生机勃勃项运转给定的函数,假若该函数对任生龙活虎项都回到true,则赶回true;

eg:

4.3、filter()

  那多少个艺术都收下七个参数:二个是在每生机勃勃项上调用的函数和(可选的)作为联合基本功的初阶值。传入给reduce()和reduceRight()的函数选取多少个参数:前七个值,当前值,项的目录和数组对象。

var numbers = [1,2,3,4,5,4,3,2,1];var mapResult = numbers.map(function{//item指代数组值;index指代数组下标;array指代数组本身;return item*2;});alert;

eg:

留心: every(卡塔尔(قطر‎ 不会对空数组举行检验。

  注意:

4、迭代情势

 

var numbers = [1,2,3,4,5,4,3,2,1];var filterResult = numbers.filter(function{//item指代数组值;index指代数组下标;array指代数组本身;return ;alert;

eg:

传给reduce的函数选拔4个参数:前八个值,当前值,项的目录和数组对象。

1 var numbers=[1,2,3,4,5,4,3,2,1];
2 var someResult=numbers.some(function(item,index,array){
3     return(item>4);
4 })
5 var someResult1=numbers.some(function(item,index,array){
6     return(item>5);
7 })
8 alert(someResult);//true
9 alert(someResult1);//false

4.2、some()

  ECMAScript5为数组实例增添了多个职分:indexOf()和 lastIndexOf()。那三个方法选用七个参数:要探究的项和(可选的)表示查找源点地方的目录(如在数组[7,8,9,1,0]中,“7”在首先个职责,它的目录是0。)。在那之中,indexOf()方法从数组的发端(地方0)开首向后查找,lastIndexOf()方法从数组的结尾早先向前查找。

上一篇:没有了
下一篇:没有了