精华内容
下载资源
问答
  • 主要介绍了js数组方法扩展,实现数组统计函数,需要的朋友可以参考下
  • js 数组从头添加到数组 介绍 (Introduction) JavaScript includes several functions for working with arrays that go beyond the for loop. You may have used these functions in your own projects and wondered...

    js 数组从头添加到数组

    介绍 (Introduction)

    JavaScript includes several functions for working with arrays that go beyond the for loop. You may have used these functions in your own projects and wondered how they work and why you’d use one over another.

    JavaScript包含多个用于处理数组的函数,这些函数超出了for循环。 您可能在自己的项目中使用了这些功能,并想知道它们是如何工作的以及为什么要一一使用。

    A great way to understand how something works is to build your own version from scratch. In this article, you are going to do that by creating your own versions of map, filter, sort, and reduce from scratch. When you’re done, you’ll have a better understanding of these functions and their uses.

    理解某项工作原理的一种好方法是从头开始构建自己的版本。 在本文中,您将通过创建自己的mapfiltersortreduce的版本来做到这一点。 完成后,您将对这些功能及其用途有更好的了解。

    By combining ES6 Arrow Functions with JavaScript Array functions, you can write extremely powerful and clean code.

    通过将ES6箭头函数与JavaScript数组函数结合使用,您可以编写功能强大且简洁的代码。

    JavaScript数组方法如何工作 (How JavaScript Array Methods Work)

    Let’s start with an example. Let’s say you want to iterate through an array of numbers, increment each element by one, and return the new array. In the past, you would need to do several things to accomplish this:

    让我们从一个例子开始。 假设您要遍历数字数组,将每个元素加1,然后返回新数组。 过去,您需要做几件事来完成此任务:

    • Initialize a new empty array.

      初始化一个新的空数组。
    • Iterate through each element in the original array.

      遍历原始数组中的每个元素。
    • Alter that element and put the altered value into the new array.

      更改该元素,然后将更改后的值放入新数组中。

    The code would look like this:

    代码如下所示:

    const arr = [1, 2, 3];
    const newArray = [];
    
    for (let i = 0; i < arr.length; i++) {
        newArray[i] = arr[i] + 1;
    }
    
    return newArray;

    But with the built-in map function, you can accomplish this in a single line of code:

    但是,使用内置的map函数,您可以在一行代码中完成此操作:

    return arr.map(element => ++element);

    JavaScript Array methods heavily leverage ES6 Arrow Functions.

    JavaScript Array方法大量利用ES6箭头函数

    Each of the Array functions we will cover accept a function as a parameter. They will iterate through each element of the array and call that function to determine what to do with each element. After iterating through each element and calling the callback function, a new array or item will be returned.

    我们将介绍的每个Array函数都接受一个函数作为参数。 它们将遍历数组的每个元素,并调用该函数以确定如何处理每个元素。 遍历每个元素并调用回调函数后,将返回一个新的数组或项目。

    先决条件 (Prerequisites)

    To follow this tutorial locally, you will need an editor (such as Visual Studio Code) and a sandbox environment extension (such as Quokka.js).

    要在本地遵循本教程,您将需要一个编辑器(例如Visual Studio Code )和一个沙箱环​​境扩展(例如Quokka.js )。

    To follow the tutorial online, you can use CodePen or CodeSandbox.

    要在线阅读本教程,可以使用CodePenCodeSandbox

    第1步-实施地图 (Step 1 — Implementing Map)

    map iterates through each element, transforms it in some way, adds it to a new array, and returns the new array.

    map遍历每个元素,以某种方式对其进行转换,将其添加到新数组,然后返回新数组。

    Warning: In this article, you’re going to extend JavaScript global objects with custom functions. This is for educational purposes only, as this practice has the potential to introduce side effects in production code.

    警告 :在本文中,您将使用自定义函数扩展JavaScript全局对象。 这仅出于教育目的,因为这种做法有可能在生产代码中引入副作用。

    JavaScript array functions are part of the Array prototype, similar to functions on a class in Java, for example. To override them, you can assign a new function to Array.prototype.

    JavaScript数组函数是Array原型的一部分,类似于Java中类的函数。 要覆盖它们,可以为Array.prototype分配一个新函数。

    Let’s create a new function and assign it to Array.prototype.mapFromScratch:

    让我们创建一个新函数并将其分配给Array.prototype.mapFromScratch

    const myCustomMapFunction = function(callback) {
        console.log('My Custom Map Function!');
    }
    Array.prototype.mapFromScratch = myCustomMapFunction;
    
    const arr = [1, 2, 3];
    
    arr.mapFromScratch();

    If you run this code, you will see the log message in the console:

    如果运行此代码,您将在控制台中看到日志消息:

    
       
    Output
    My Custom Map Function!

    Now, add the for loop and print out each element. Due to the array itself calling the method, you get access to that array by referencing this:

    现在,添加for循环并打印出每个元素。 由于数组本身调用该方法,因此您可以通过引用this来访问该数组:

    const myCustomMapFunction = function(callback) {
        console.log('My Custom Map Function!');
    
        // 'this' refers to the array
        for (let i = 0; i < this.length; i++) {
            console.log(this[i]);
        }
    
    }

    Now, perform any required transformation by calling the callback function. When you do, you will pass it the current element and the current index:

    现在,通过调用回调函数执行所有必需的转换。 完成后,您将向其传递当前元素和当前索引:

    const myCustomMapFunction = function(callback) {
        console.log('My Custom Map Function!');
    
        // 'this' refers to the array
        for (let i = 0; i < this.length; i++) {
            const transformedElement = callback([this[i], i);
        }
    
    }

    Finally, add the transformed elements to a new array and return that array.

    最后,将转换后的元素添加到新数组中并返回该数组。

    const myCustomMapFunction = function(callback) {
        console.log('My Custom Map Function!');
    
        const newArray = [];
    
        // 'this' refers to the array
        for (let i = 0; i < this.length; i++) {
            newArray[i] = callback(this[i], i);
        }
    
        return newArray;
    }

    Let’s take a look of your rewritten function in action by testing it with a function that will increment each value in the array:

    让我们通过使用将增加数组中每个值的函数进行测试来看看重写后的函数的作用:

    // arr = [1, 2, 3]
    // expected = [2, 3, 4]
    
    console.log(arr.mapFromScratch((element) => ++element));

    You will receive the following output:

    您将收到以下输出:

    
       
    Output
    My Custom Map Function! [2, 3, 4]

    In this step you implemented a custom map function. Next, let’s explore implementing a filter function.

    在此步骤中,您实现了自定义map功能。 接下来,让我们探索实现filter功能。

    第2步-实施过滤器 (Step 2 — Implementing Filter)

    The filter function returns a new array of elements filtered from the original array.

    filter函数返回一个从原始数组中过滤出来的元素的新数组。

    Let’s create a new function and assign it to Array.prototype.filterFromScratch:

    让我们创建一个新函数并将其分配给Array.prototype.filterFromScratch

    const myCustomFilterFunction = function(callback) {
        console.log('My Custom Filter Function!');
    }
    Array.prototype.filterFromScratch = myCustomFilterFunction;
    
    const arr = [1, 2, 3];
    
    arr.filterFromScratch();

    Now, set up the for loop to iterate through each element:

    现在,设置for循环以遍历每个元素:

    const myCustomFilterFunction = function(callback) {
        console.log('My Custom Filter Function!');
    
        const newArray = [];
    
        for (let i = 0; i < this.length; i++) {
            console.log(this[i]);
        }
    }

    Inside of the for loop, you need to decided whether or not to add each element to the new array. This is the purpose of the callback function, so you use it to conditionally add each element. If the return value is true, push the element on to the return array:

    for循环内部,您需要确定是否将每个元素添加到新数组中。 这是回调函数的目的,因此您可以使用它有条件地添加每个元素。 如果返回值为true ,则将元素推到返回数组上:

    const myCustomFilterFunction = function(callback) {
        console.log('My Custom Filter Function!');
    
        const newArray = [];
    
        for (let i = 0; i < this.length; i++) {
            if (callback(this[i])) {
                newArray.push(this[i]);
            }
        }
    
        return newArray;
    }

    Let’s take a look at your rewritten function in action by testing it with a function that will display values that are greater than 1:

    让我们通过使用一个显示大于1值的函数来测试您重写的函数的作用:

    // arr = [1, 2, 3]
    // expected = [2, 3]
    
    console.log(arr.filterFromScratch((element) =>  element > 1));

    You will receive the following output:

    您将收到以下输出:

    
       
    Output
    My Custom Filter Function! [2, 3]

    With that, you have implemented a custom filter function. Next you will work with the sort function.

    这样,您就实现了自定义filter功能。 接下来,您将使用sort功能。

    步骤3 —实施排序 (Step 3 — Implementing Sort)

    The sort function returns a sorted array from the original array.

    sort函数从原始数组返回已排序的数组。

    Let’s create a new function and assign it to Array.prototype.sortFromScratch:

    让我们创建一个新函数并将其分配给Array.prototype.sortFromScratch

    const myCustomSortFunction = function(callback) {
        console.log('My Custom Sort Function!');
    }
    Array.prototype.sortFromScratch = myCustomSortFunction;
    
    const arr = [3, 2, 1];
    
    arr.sortFromScratch();

    We are going to be using Bubble Sort for this sort implementation. Here’s the approach we will take:

    我们将使用Bubble Sort进行这种排序。 我们将采用以下方法:

    • Repeatedly iterate through items in array.

      重复遍历数组中的项目。
    • Compare adjacent items and swap if they are not in order.

      比较相邻的项目,如果顺序不对,则交换它们。
    • After iterating through the array enough times to make each comparison, the array is sorted.

      在遍历数组足够多次以进行每个比较之后,对数组进行排序。

    With Bubble Sort, you have to iterate through the array fully once for each element in the array. This calls for a nested for loop where the inner loop iterates through stopping one short of the final element, so let’s add that now.

    使用冒泡排序,您必须对数组中的每个元素完全遍历数组一次。 这需要一个嵌套的for循环,其中,内部循环通过停止最后一个元素的间隔来进行迭代,因此现在就添加它。

    Note: This is intended for educational purposes and isn’t an efficient method for sorting.

    注意 :这是出于教育目的,不是有效的分类方法。

    const myCustomSortFunction = function(callback) {
        console.log('My Custom Sort Function!');
    
        const newArray = [];
    
        for (let i = 0; i < newArray.length; i++) {
            for (let j = 0; j < newArray.length - 1; j++) { 
            }
        }
    }

    You also don’t want to alter the original array. To avoid this, you can copy the original array into the new array using the Spread Operator.

    您也不想更改原始数组。 为避免这种情况,您可以使用Spread Operator将原始数组复制到新数组中。

    const myCustomSortFunction = function(callback) {
        console.log('My Custom Sort Function!');
    
        const newArray = [...this];
    
        for (let i = 0; i < newArray.length; i++) {
            for (let j = 0; j < newArray.length - 1; j++) { 
            }
        }
    }

    The callback function takes two parameters, the current element and the next element, and will return whether or not they are in order. In our case, if the callback function returns a number greater than 0, we want to swap the two elements.

    回调函数采用两个参数,当前元素和下一个元素,并将返回它们是否按顺序排列。 在我们的例子中,如果回调函数返回的数字大于0 ,我们想交换两个元素。

    const myCustomSortFunction = function(callback) {
        console.log('My Custom Sort Function!');
    
        const newArray = [...this];
    
        for (let i = 0; i < newArray.length; i++) {
            for (let j = 0; j < newArray.length - 1; j++) {
                if (callback(newArray[j], newArray[j + 1]) > 0) {
                    // swap the elements
                }
            }
        }
    }

    To swap the elements, you make a copy of one, replace the first one, and then replace the second one with the copy. When finished, it returns the newly sorted array.

    要交换元素,请制作一个副本,替换第一个,然后用副本替换第二个。 完成后,它将返回新排序的数组。

    const myCustomSortFunction = function(callback) {
        console.log('My Custom Sort Function!');
    
        const newArray = [...this]; 
    
        for (let i = 0; i < newArray.length; i++){
            for (let j = 0; j < newArray.length - 1; j++) {
                if (callback(newArray[j], newArray[j + 1]) > 0) {
                    const temp = newArray[j + 1];
                    newArray[j + 1] = newArray[j];
                    newArray[j] = temp;
                }
           }
        }
    
        // array is sorted
        return newArray;
    }

    Let’s take a look of your rewritten function in action by testing it with a function that quicksorts from low to high:

    通过使用从低到高快速排序的功能对其进行测试,让我们看一下重写后的功能的实际作用:

    // arr = [3, 2, 1]
    // expected = [1, 2, 3]
    
    console.log(arr.sortFromScratch((current, next) => current - next));

    You will receive the following output:

    您将收到以下输出:

    
       
    Output
    My Custom Sort Function! [1, 2, 3]

    Now that you’ve created a custom sort function, you’re ready to move on to implementing a reduce function.

    现在,您已经创建了一个自定义sort函数,您可以继续执行reduce函数了。

    第4步-实施Reduce (Step 4 — Implementing Reduce)

    The reduce function iterates through each element and returns one single value.

    reduce函数遍历每个元素并返回一个单个值。

    reduce does not return a new array like the other functions. It actually “reduces” the elements in an array to one final value: a number, a string, or an object. One of the most common reasons for using reduce is for when you want to sum up all the elements in an array of numbers.

    reduce不会像其他函数一样返回新数组。 它实际上将数组中的元素“减少”为一个最终值:数字,字符串或对象。 使用reduce的最常见原因之一是当您想对数字数组中的所有元素求和时。

    Let’s create a new function and assign it to Array.prototype.reduceFromScratch:

    让我们创建一个新函数并将其分配给Array.prototype.reduceFromScratch

    const myCustomReduceFunction = function(callback) {
        console.log('My Custom Reduce Function!');
    }
    Array.prototype.reduceFromScratch = myCustomReduceFunction;
    
    const arr = [1, 2, 3];
    
    arr.reduceFromScratch();

    For reduce to return one final value, it needs a starting value to work with. The callback function that the user passes along will determine how to update this accumulator based on each element of the array and return it at the end. The callback function must return the updated accumulator.

    为了reduce返回一个最终值,需要使用一个起始值。 用户传递的回调函数将根据数组的每个元素确定如何更新此累加器 ,并在最后将其返回。 回调函数必须返回更新的累加器。

    Add your for loop now, and make a call to the callback function. The return value becomes the new accumulator. After the loop ends, you return the accumulator.

    现在添加您的for循环,并调用回调函数。 返回值将成为新的累加器。 循环结束后,您将返回累加器。

    const myCustomReduceFunction = function(callback, accumulator) {
        console.log('My Custom Reduce Function!');
        for (let i = 0; i < this.length; i++) {
            accumulator = callback(accumulator, this[i]);
        }
        return accumulator;
    }

    Let’s take a look of your rewritten function in action by testing it with a function that sums up the contents of an array:

    让我们看一下您重写后的函数的运行情况,方法是使用一个总结数组内容的函数进行测试:

    // arr = [1, 2, 3]
    // expected = 6
    
    console.log(arr.reduceFromScratch((accumulator, element) => accumulator + element, 0));
    
       
    Output
    My Custom Reduce Function! 6

    结论 (Conclusion)

    JavaScript’s array functions are extremely useful. In this tutorial, you reimplemented the array functions to get a better understanding of how they work so you can use them more effectively.

    JavaScript的数组函数非常有用。 在本教程中,您重新实现了数组函数,以更好地了解它们的工作方式,从而可以更有效地使用它们。

    翻译自: https://www.digitalocean.com/community/tutorials/how-to-implement-javascript-array-methods-from-scratch

    js 数组从头添加到数组

    展开全文
  • js数组方法

    千次阅读 2019-05-24 20:37:26
    JavaScript中创建数组有两种方式: 使用 Array 构造函数: var arr1 = new Array(); //创建一个空数组 var arr2 = new Array(20); // 创建一个包含20项的数组 var arr3 = new Array("lily","lucy","Tom"); // 创建一...

    JavaScript中创建数组有两种方式:
    使用 Array 构造函数:

    var arr1 = new Array();   //创建一个空数组
    var arr2 = new Array(20);   // 创建一个包含20项的数组
    var arr3 = new Array("lily","lucy","Tom");   // 创建一个包含3个字符串的数组
    

    使用数组字面量表示法:

    var arr4 = [];   //创建一个空数组
    var arr5 = [20];   // 创建一个包含1项的数组
    var arr6 = ["lily","lucy","Tom"];   // 创建一个包含3个字符串的数组
    

     数组的方法有数组原型方法,也有从object对象继承来的方法,这里我们只介绍数组的原型方法,数组原型方法主要有以下这些:

    join()
    push()和pop()
    shift() 和 unshift()
    sort()
    reverse()
    concat()
    slice()
    splice()
    indexOf()和 lastIndexOf() (ES5新增)
    forEach() (ES5新增)
    map() (ES5新增)
    filter() (ES5新增)
    every() (ES5新增)
    some() (ES5新增)
    reduce()和 reduceRight() (ES5新增)
    

    下面详细介绍一下各个方法的基本功能。
    1、join()
     join(separator): 将数组的元素组起一个字符串,以separator为分隔符,省略的话则用默认用逗号为分隔符,该方法只接收一个参数:即分隔符。

    var arr = [1,2,3];
    console.log(arr.join());   // 1,2,3
    console.log(arr.join("-"));   // 1-2-3
    console.log(arr);   // [1, 2, 3](原数组不变)
    

     通过join()方法可以实现重复字符串,只需传入字符串以及重复的次数,就能返回重复后的字符串,函数如下:

    function repeatString(str, n) {
    	return new Array(n + 1).join(str);
    }
    console.log(repeatString("abc", 3));   // abcabcabc
    console.log(repeatString("Hi", 5));   // HiHiHiHiHi
    

    2、push()和pop()
     push(): 可以接收任意数量的参数,把它们逐个添加到数组末尾,并返回修改后数组的长度。
     pop():数组末尾移除最后一项,减少数组的 length 值,然后返回移除的项。

    var arr = ["Lily","lucy","Tom"];
    var count = arr.push("Jack","Sean");
    console.log(count);  // 5
    console.log(arr);   // ["Lily", "lucy", "Tom", "Jack", "Sean"]
    var item = arr.pop();
    console.log(item);   // Sean
    console.log(arr);   // ["Lily", "lucy", "Tom", "Jack"]
    

    3、shift() 和 unshift()
     shift():删除原数组第一项,并返回删除元素的值;如果数组为空则返回undefined 。
     unshift:将参数添加到原数组开头,并返回数组的长度 。
     这组方法和上面的push()和pop()方法正好对应,一个是操作数组的开头,一个是操作数组的结尾。

    var arr = ["Lily","lucy","Tom"];
    var count = arr.unshift("Jack","Sean");
    console.log(count);   // 5
    console.log(arr);   //["Jack", "Sean", "Lily", "lucy", "Tom"]
    var item = arr.shift();
    console.log(item);   // Jack
    console.log(arr);   // ["Sean", "Lily", "lucy", "Tom"]
    

    4、sort()
     sort():按升序排列数组项——即最小的值位于最前面,最大的值排在最后面。
     在排序时,sort()方法会调用每个数组项的 toString()转型方法,然后比较得到的字符串,以确定如何排序。即使数组中的每一项都是数值, sort()方法比较的也是字符串,因此会出现以下的这种情况:

    var arr1 = ["a", "d", "c", "b"];
    console.log(arr1.sort());   // ["a", "b", "c", "d"]
    arr2 = [13, 24, 51, 3];
    console.log(arr2.sort());   // [13, 24, 3, 51]
    console.log(arr2);   // [13, 24, 3, 51](元数组被改变)
    

     为了解决上述问题,sort()方法可以接收一个比较函数作为参数,以便我们指定哪个值位于哪个值的前面。比较函数接收两个参数,如果第一个参数应该位于第二个之前则返回一个负数,如果两个参数相等则返回 0,如果第一个参数应该位于第二个之后则返回一个正数。以下就是一个简单的比较函数:

    function compare(value1, value2) {
        if (value1 < value2) {
        	return -1;
        } else if (value1 > value2) {
       		return 1;
        } else {
        	return 0;
        }
    }
    arr2 = [13, 24, 51, 3];
    console.log(arr2.sort(compare));   // [3, 13, 24, 51]
    

     如果需要通过比较函数产生降序排序的结果,只要交换比较函数返回的值即可:

    function compare(value1, value2) {
        if (value1 < value2) {
        	return 1;
        } else if (value1 > value2) {
        	return -1;
        } else {
        	return 0;
        }
    }
    arr2 = [13, 24, 51, 3];
    console.log(arr2.sort(compare));   // [51, 24, 13, 3]
    

    5、reverse()
     reverse():反转数组项的顺序。

    var arr = [13, 24, 51, 3];
    console.log(arr.reverse());   //[3, 51, 24, 13]
    console.log(arr);   //[3, 51, 24, 13](原数组改变)
    

    6、concat()
     concat() :将参数添加到原数组中。这个方法会先创建当前数组一个副本,然后将接收到的参数添加到这个副本的末尾,最后返回新构建的数组。在没有给 concat()方法传递参数的情况下,它只是复制当前数组并返回副本。

    var arr = [1,3,5,7];
    var arrCopy = arr.concat(9,[11,13]);
    console.log(arrCopy);   //[1, 3, 5, 7, 9, 11, 13]
    console.log(arr);   // [1, 3, 5, 7](原数组未被修改)
    

     从上面测试结果可以发现:传入的不是数组,则直接把参数添加到数组后面,如果传入的是数组,则将数组中的各个项添加到数组中。但是如果传入的是一个二维数组呢?

    var arrCopy2 = arr.concat([9,[11,13]]);
    console.log(arrCopy2);   //[1, 3, 5, 7, 9, Array[2]]
    console.log(arrCopy2[5]);   //[11, 13]
    

     上述代码中,arrCopy2数组的第五项是一个包含两项的数组,也就是说concat方法只能将传入数组中的每一项添加到数组中,如果传入数组中有些项是数组,那么也会把这一数组项当作一项添加到arrCopy2中。
    7、slice()
     slice():返回从原数组中指定开始下标到结束下标之间的项组成的新数组。slice()方法可以接受一或两个参数,即要返回项的起始和结束位置。在只有一个参数的情况下, slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数,该方法返回起始和结束位置之间的项,但不包括结束位置的项。

    var arr = [1,3,5,7,9,11];
    var arrCopy = arr.slice(1);
    var arrCopy2 = arr.slice(1,4);
    var arrCopy3 = arr.slice(1,-2);
    var arrCopy4 = arr.slice(-4,-1);
    console.log(arr);   //[1, 3, 5, 7, 9, 11](原数组没变)
    console.log(arrCopy);   //[3, 5, 7, 9, 11]
    console.log(arrCopy2);   //[3, 5, 7]
    console.log(arrCopy3);   //[3, 5, 7]
    console.log(arrCopy4);   //[5, 7, 9]
    

     arrCopy只设置了一个参数,也就是起始下标为1,所以返回的数组为下标1(包括下标1)开始到数组最后。
     arrCopy2设置了两个参数,返回起始下标(包括1)开始到终止下标(不包括4)的子数组。
     arrCopy3设置了两个参数,终止下标为负数,当出现负数时,将负数加上数组长度的值(6)来替换该位置的数,因此就是从1开始到4(不包括)的子数组。
     arrCopy4中两个参数都是负数,所以都加上数组长度6转换成正数,因此相当于slice(2,5)。
    8、splice()
     splice():很强大的数组方法,它有很多种用法,可以实现删除、插入和替换。
     删除:可以删除任意数量的项,只需指定 2 个参数:要删除的第一项的位置和要删除的项数。例如, splice(0,2)会删除数组中的前两项。
     插入:可以向指定位置插入任意数量的项,只需提供 3 个参数:起始位置、 0(要删除的项数)和要插入的项。例如,splice(2,0,4,6)会从当前数组的位置 2 开始插入4和6。
     替换:可以向指定位置插入任意数量的项,且同时删除任意数量的项,只需指定 3 个参数:起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如,splice (2,1,4,6)会删除当前数组位置 2 的项,然后再从位置 2 开始插入4和6。
     splice()方法始终都会返回一个数组,该数组中包含从原始数组中删除的项,如果没有删除任何项,则返回一个空数组。

    var arr = [1,3,5,7,9,11];
    var arrRemoved = arr.splice(0,2);
    console.log(arr);   //[5, 7, 9, 11]
    console.log(arrRemoved);   //[1, 3]
    var arrRemoved2 = arr.splice(2,0,4,6);
    console.log(arr);   // [5, 7, 4, 6, 9, 11]
    console.log(arrRemoved2);   // []
    var arrRemoved3 = arr.splice(1,1,2,4);
    console.log(arr);   // [5, 2, 4, 4, 6, 9, 11]
    console.log(arrRemoved3);   //[7]
    

    9、indexOf()和 lastIndexOf()
     indexOf():接收两个参数:要查找的项和(可选的)表示查找起点位置的索引。其中, 从数组的开头(位置 0)开始向后查找。
     lastIndexOf:接收两个参数:要查找的项和(可选的)表示查找起点位置的索引。其中, 从数组的末尾开始向前查找。
     这两个方法都返回要查找的项在数组中的位置,或者在没找到的情况下返回1。在比较第一个参数与数组中的每一项时,会使用全等操作符。

    var arr = [1,3,5,7,7,5,3,1];
    console.log(arr.indexOf(5));   //2
    console.log(arr.lastIndexOf(5));   //5
    console.log(arr.indexOf(5,2));   //2
    console.log(arr.lastIndexOf(5,4));   //2
    console.log(arr.indexOf("5"));   //-1
    

    10、forEach()
     forEach():对数组进行遍历循环,对数组中的每一项运行给定函数。这个方法没有返回值。参数都是function类型,默认有传参,参数分别为:遍历的数组内容;第对应的数组索引,数组本身。

    var arr = [1, 2, 3, 4, 5];
    arr.forEach(function(x, index, a){
    	console.log(x + '|' + index + '|' + (a === arr));
    });
    输出为:
     1|0|true
     2|1|true
     3|2|true
     4|3|true
     5|4|true
    

    11、map()
     map():指“映射”,对数组中的每一项运行给定函数,返回每次函数调用的结果组成的数组。
    下面代码利用map方法实现数组中每个数求平方。

    var arr = [1, 2, 3, 4, 5];
    var arr2 = arr.map(function(item){
    	return item*item;
    });
    console.log(arr2);  //[1, 4, 9, 16, 25]
    

    12、filter()
     filter():“过滤”功能,数组中的每一项运行给定函数,返回满足过滤条件组成的数组。

    var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    var arr2 = arr.filter(function(x, index) {
    	return index % 3 === 0 || x >= 8;
    }); 
    console.log(arr2);  //[1, 4, 7, 8, 9, 10]
    

    13、every()
     every():判断数组中每一项都是否满足条件,只有所有项都满足条件,才会返回true。

    var arr = [1, 2, 3, 4, 5];
    var arr2 = arr.every(function(x) {
    	return x < 10;
    }); 
    console.log(arr2);  //true
    var arr3 = arr.every(function(x) {
    	return x < 3;
    }); 
    console.log(arr3);  // false
    

    14、some()
     some():判断数组中是否存在满足条件的项,只要有一项满足条件,就会返回true。

    var arr = [1, 2, 3, 4, 5];
    var arr2 = arr.some(function(x) {
    	return x < 3;
    }); 
    console.log(arr2);  //true
    var arr3 = arr.some(function(x) {
    	return x < 1;
    }); 
    console.log(arr3);  // false
    

    15、reduce()和 reduceRight()
     这两个方法都会实现迭代数组的所有项,然后构建一个最终返回的值。reduce()方法从数组的第一项开始,逐个遍历到最后。而 reduceRight()则从数组的最后一项开始,向前遍历到第一项。
     这两个方法都接收两个参数:一个在每一项上调用的函数和(可选的)作为归并基础的初始值。
     传给 reduce()和 reduceRight()的函数接收 4 个参数:前一个值、当前值、项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上,因此第一个参数是数组的第一项,第二个参数就是数组的第二项。
     下面代码用reduce()实现数组求和,数组一开始加了一个初始值10。

    var values = [1,2,3,4,5];
    var sum = values.reduceRight(function(prev, cur, index, array){
    	return prev + cur;
    },10);
    console.log(sum);  //25
    
    展开全文
  • 主要介绍了JS数组方法slice()用法,结合实例形式分析了JavaScript数组slice()方法具体功能、用法及相关操作注意事项,需要的朋友可以参考下
  • 由于最近都在freecodecamp上刷代码,运用了很多JavaScript数组方法,因此做了一份关于JavaScript教程的整理,具体内容如下: 一、普通方法 1、join() 将数组元素连接在一起,并以字符串形式返回 参数:可选,指定...
  • 以下是个人在工作中收藏总结的一些关于javascript数组方法reduce的相关代码片段,后续遇到其他使用这个函数的场景,将会陆续添加,这里作为备忘。 javascript数组那么多方法,为什么我要单挑reduce方法,一个原因是...
  • 主要给大家介绍了一些可能被忽略的JavaScript数组方法细节,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 主要介绍了JS数组方法push()、pop()用法,结合实例形式分析了JavaScript数组push()与pop()方法基本功能、原理、使用方法与操作注意事项,需要的朋友可以参考下
  • 主要介绍了JS数组方法shift()、unshift()用法,结合实例形式分析了JavaScript数组shift()与unshift()方法功能、用法及相关操作注意事项,需要的朋友可以参考下
  • 本文实例讲述了JS数组方法concat()用法。分享给大家供大家参考,具体如下: 数组方法concat() concat()可以基于当前数组中的所有项创建一个新数组。即这个方法会先创建当前数组一个副本,然后将接收到的参数添加到这...
  • JavaScript 数组方法大全

    千次阅读 多人点赞 2016-07-04 22:09:54
    本文对JavaScript数组方法进行了汇总,首先介绍了数组的创建等基本概念,然后详细介绍了数组各个方法的功能以及使用示例。

    数组在笔试题中出现的概率最高的类型之一,JavaScript中的数组与其他语言中的数组有些区别,为了方便以后查看数组的方法,现将对数组的操作方法进行汇总整理。

    ###数组创建
    JavaScript中创建数组有两种方式,第一种是使用 Array 构造函数:

    var arr1 = new Array(); //创建一个空数组
    var arr2 = new Array(20); // 创建一个包含20项的数组
    var arr3 = new Array("lily","lucy","Tom");  // 创建一个包含3个字符串的数组
    

    创建数组的第二种基本方式是使用数组字面量表示法:

    var arr4 = []; //创建一个空数组
    var arr5 = [20]; // 创建一个包含1项的数组
    var arr6 = ["lily","lucy","Tom"];  // 创建一个包含3个字符串的数组
    

    在读取和设置数组的值时,要使用方括号并提供相应值的基于 0 的数字索引:

    var arr6 = ["lily","lucy","Tom"];  // 创建一个包含3个字符串的数组
    alert(arr6[0]); //lily
    arr6[1] = "mary"; //修改第二项为mary
    arr6[3] = "sean"; //增加第四项为sean
    

    JavaScript中数组的length属性是可以修改的,看下面的示例:

    var arr = ["lily","lucy","Tom"];  // 创建一个包含3个字符串的数组
    arr[arr.length] = "sean"; //在下标为3处(也就是数组尾部)添加一项"sean"
    arr.length = arr.length-1; //将数组的最后一项删除
    

    如果需要判断一个对象是不是数组对象,在ECMAScript 5之前,我们可以通过 instanceof Array去判断,但是instanceof 操作符的问题在于,它假定只有一个全局执行环境。如果网页中包含多个框架,那实际上就存在两个以上不同的全局执行环境,从而存在两个以上不同版本的 Array 构造函数。如果你从一个框架向另一个框架传入一个数组,那么传入的数组与在第二个框架中原生创建的数组分别具有各自不同的构造函数。

    ECMAScript 5 新增了 Array.isArray()方法。这个方法的目的是最终确定某个值到底是不是数组,而不管它是在哪个全局执行环境中创建的。

    ###数组方法
    下面开始介绍数组的方法,数组的方法有数组原型方法,也有从object对象继承来的方法,这里我们只介绍数组的原型方法,数组原型方法主要有以下这些:

    1. join()
    2. push()和pop()
    3. shift() 和 unshift()
    4. sort()
    5. reverse()
    6. concat()
    7. slice()
    8. splice()
    9. indexOf()和 lastIndexOf() (ES5新增)
    10. forEach() (ES5新增)
    11. map() (ES5新增)
    12. filter() (ES5新增)
    13. every() (ES5新增)
    14. some() (ES5新增)
    15. reduce()和 reduceRight() (ES5新增)

    针对ES5新增的方法浏览器支持情况:

    Opera 11+
    Firefox 3.6+
    Safari 5+
    Chrome 8+
    Internet Explorer 9+

    对于支持的浏览器版本,可以通过Array原型扩展来实现。下面详细介绍一下各个方法的基本功能。

    ####1、join()
    join(separator): 将数组的元素组起一个字符串,以separator为分隔符,省略的话则用默认用逗号为分隔符,该方法只接收一个参数:即分隔符。

    var arr = [1,2,3];
    console.log(arr.join()); // 1,2,3
    console.log(arr.join("-")); // 1-2-3
    console.log(arr); // [1, 2, 3](原数组不变)
    

    通过join()方法可以实现重复字符串,只需传入字符串以及重复的次数,就能返回重复后的字符串,函数如下:

    function repeatString(str, n) {
         return new Array(n + 1).join(str);
    }
    console.log(repeatString("abc", 3)); // abcabcabc
    console.log(repeatString("Hi", 5)); // HiHiHiHiHi
    

    ####2、push()和pop()
    push(): 可以接收任意数量的参数,把它们逐个添加到数组末尾,并返回修改后数组的长度。
    pop():数组末尾移除最后一项,减少数组的 length 值,然后返回移除的项。

    var arr = ["Lily","lucy","Tom"];
    var count = arr.push("Jack","Sean");
    console.log(count); // 5
    console.log(arr);   // ["Lily", "lucy", "Tom", "Jack", "Sean"]
    
    var item = arr.pop();
    console.log(item);  // Sean
    console.log(arr);   // ["Lily", "lucy", "Tom", "Jack"]
    

    ####3、shift() 和 unshift()
    shift():删除原数组第一项,并返回删除元素的值;如果数组为空则返回undefined 。
    unshift:将参数添加到原数组开头,并返回数组的长度 。

    这组方法和上面的push()和pop()方法正好对应,一个是操作数组的开头,一个是操作数组的结尾。

    var arr = ["Lily","lucy","Tom"];
    var count = arr.unshift("Jack","Sean");
    console.log(count); // 5
    console.log(arr); //["Jack", "Sean", "Lily", "lucy", "Tom"]
    
    var item = arr.shift();
    console.log(item);  // Jack
    console.log(arr);   // ["Sean", "Lily", "lucy", "Tom"]
    

    ####4、sort()
    sort():按升序排列数组项——即最小的值位于最前面,最大的值排在最后面。

    在排序时,sort()方法会调用每个数组项的 toString()转型方法,然后比较得到的字符串,以确定如何排序。即使数组中的每一项都是数值, sort()方法比较的也是字符串,因此会出现以下的这种情况:

    var arr1 = ["a", "d", "c", "b"];
    console.log(arr1.sort()); // ["a", "b", "c", "d"]
    
    arr2 = [13, 24, 51, 3];
    console.log(arr2.sort()); // [13, 24, 3, 51]
    console.log(arr2); // [13, 24, 3, 51](元数组被改变)
    

    为了解决上述问题,sort()方法可以接收一个比较函数作为参数,以便我们指定哪个值位于哪个值的前面。比较函数接收两个参数,如果第一个参数应该位于第二个之前则返回一个负数,如果两个参数相等则返回 0,如果第一个参数应该位于第二个之后则返回一个正数。以下就是一个简单的比较函数:

    function compare(value1, value2) {
    	if (value1 < value2) {
    		return -1;
    	} else if (value1 > value2) {
    		return 1;
    	} else {
    		return 0;
    	}
    }
    arr2 = [13, 24, 51, 3];
    console.log(arr2.sort(compare)); // [3, 13, 24, 51]
    

    如果需要通过比较函数产生降序排序的结果,只要交换比较函数返回的值即可:

    function compare(value1, value2) {
    	if (value1 < value2) {
    		return 1;
    	} else if (value1 > value2) {
    		return -1;
    	} else {
    		return 0;
    	}
    }
    arr2 = [13, 24, 51, 3];
    console.log(arr2.sort(compare)); // [51, 24, 13, 3]
    

    ####**5、reverse() **
    reverse():反转数组项的顺序。

    var arr = [13, 24, 51, 3];
    console.log(arr.reverse()); //[3, 51, 24, 13]
    console.log(arr); //[3, 51, 24, 13](原数组改变)
    

    ####**6、concat() **
    concat() :将参数添加到原数组中。这个方法会先创建当前数组一个副本,然后将接收到的参数添加到这个副本的末尾,最后返回新构建的数组。在没有给 concat()方法传递参数的情况下,它只是复制当前数组并返回副本。

    var arr = [1,3,5,7];
    var arrCopy = arr.concat(9,[11,13]);
    console.log(arrCopy); //[1, 3, 5, 7, 9, 11, 13]
    console.log(arr); // [1, 3, 5, 7](原数组未被修改)
    

    从上面测试结果可以发现:传入的不是数组,则直接把参数添加到数组后面,如果传入的是数组,则将数组中的各个项添加到数组中。但是如果传入的是一个二维数组呢?

    var arrCopy2 = arr.concat([9,[11,13]]);
    console.log(arrCopy2); //[1, 3, 5, 7, 9, Array[2]]
    console.log(arrCopy2[5]); //[11, 13]
    

    上述代码中,arrCopy2数组的第五项是一个包含两项的数组,也就是说concat方法只能将传入数组中的每一项添加到数组中,如果传入数组中有些项是数组,那么也会把这一数组项当作一项添加到arrCopy2中。

    ####**7、slice() **
    slice():返回从原数组中指定开始下标到结束下标之间的项组成的新数组。slice()方法可以接受一或两个参数,即要返回项的起始和结束位置。在只有一个参数的情况下, slice()方法返回从该参数指定位置开始到当前数组末尾的所有项。如果有两个参数,该方法返回起始和结束位置之间的项——但不包括结束位置的项。

    var arr = [1,3,5,7,9,11];
    var arrCopy = arr.slice(1);
    var arrCopy2 = arr.slice(1,4);
    var arrCopy3 = arr.slice(1,-2);
    var arrCopy4 = arr.slice(-4,-1);
    
    console.log(arr); //[1, 3, 5, 7, 9, 11](原数组没变)
    console.log(arrCopy); //[3, 5, 7, 9, 11]
    console.log(arrCopy2); //[3, 5, 7]
    console.log(arrCopy3); //[3, 5, 7]
    console.log(arrCopy4); //[5, 7, 9]
    

    arrCopy只设置了一个参数,也就是起始下标为1,所以返回的数组为下标1(包括下标1)开始到数组最后。
    arrCopy2设置了两个参数,返回起始下标(包括1)开始到终止下标(不包括4)的子数组。
    arrCopy3设置了两个参数,终止下标为负数,当出现负数时,将负数加上数组长度的值(6)来替换该位置的数,因此就是从1开始到4(不包括)的子数组。
    arrCopy4中两个参数都是负数,所以都加上数组长度6转换成正数,因此相当于slice(2,5)。

    ####**8、splice() **
    splice():很强大的数组方法,它有很多种用法,可以实现删除、插入和替换。

    • 删除:可以删除任意数量的项,只需指定 2 个参数:要删除的第一项的位置和要删除的项数。例如, splice(0,2)会删除数组中的前两项。
    • 插入:可以向指定位置插入任意数量的项,只需提供 3 个参数:起始位置、 0(要删除的项数)和要插入的项。例如,splice(2,0,4,6)会从当前数组的位置 2 开始插入4和6。
    • 替换:可以向指定位置插入任意数量的项,且同时删除任意数量的项,只需指定 3 个参数:起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。例如,splice (2,1,4,6)会删除当前数组位置 2 的项,然后再从位置 2 开始插入4和6。

    splice()方法始终都会返回一个数组,该数组中包含从原始数组中删除的项,如果没有删除任何项,则返回一个空数组。

    var arr = [1,3,5,7,9,11];
    var arrRemoved = arr.splice(0,2);
    console.log(arr); //[5, 7, 9, 11]
    console.log(arrRemoved); //[1, 3]
    
    var arrRemoved2 = arr.splice(2,0,4,6);
    console.log(arr); // [5, 7, 4, 6, 9, 11]
    console.log(arrRemoved2); // []
    
    var arrRemoved3 = arr.splice(1,1,2,4);
    console.log(arr); // [5, 2, 4, 4, 6, 9, 11]
    console.log(arrRemoved3); //[7]
    

    ####**9、indexOf()和 lastIndexOf() **
    indexOf():接收两个参数:要查找的项和(可选的)表示查找起点位置的索引。其中, 从数组的开头(位置 0)开始向后查找。
    lastIndexOf:接收两个参数:要查找的项和(可选的)表示查找起点位置的索引。其中, 从数组的末尾开始向前查找。

    这两个方法都返回要查找的项在数组中的位置,或者在没找到的情况下返回1。在比较第一个参数与数组中的每一项时,会使用全等操作符。

    var arr = [1,3,5,7,7,5,3,1];
    console.log(arr.indexOf(5)); //2
    console.log(arr.lastIndexOf(5)); //5
    
    console.log(arr.indexOf(5,2));  //2
    console.log(arr.lastIndexOf(5,4)); //2
    
    console.log(arr.indexOf("5")); //-1
    

    ####10、forEach()
    forEach():对数组进行遍历循环,对数组中的每一项运行给定函数。这个方法没有返回值。参数都是function类型,默认有传参,参数分别为:遍历的数组内容;第对应的数组索引,数组本身。

    var arr = [1, 2, 3, 4, 5];
    arr.forEach(function(x, index, a){
        console.log(x + '|' + index + '|' + (a === arr));
    });
    
    // 输出为:
    // 1|0|true
    // 2|1|true
    // 3|2|true
    // 4|3|true
    // 5|4|true
    

    ####11、map()
    map():指“映射”,对数组中的每一项运行给定函数,返回每次函数调用的结果组成的数组。

    下面代码利用map方法实现数组中每个数求平方。

    var arr = [1, 2, 3, 4, 5];
    var arr2 = arr.map(function(item){
    	return item*item;
    });
    console.log(arr2); //[1, 4, 9, 16, 25]
    

    ####12、filter()
    filter():“过滤”功能,数组中的每一项运行给定函数,返回满足过滤条件组成的数组。

    var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    var arr2 = arr.filter(function(x, index) {
         return index % 3 === 0 || x >= 8;
    }); 
    console.log(arr2);  //[1, 4, 7, 8, 9, 10]
    

    ####13、every()
    every():判断数组中每一项都是否满足条件,只有所有项都满足条件,才会返回true。

    var arr = [1, 2, 3, 4, 5];
    var arr2 = arr.every(function(x) {
         return x < 10;
    }); 
    console.log(arr2); //true
    
    var arr3 = arr.every(function(x) {
         return x < 3;
    }); 
    console.log(arr3); // false
    

    ####14、some()
    some():判断数组中是否存在满足条件的项,只要有一项满足条件,就会返回true。

    var arr = [1, 2, 3, 4, 5];
    var arr2 = arr.some(function(x) {
         return x < 3;
    }); 
    console.log(arr2); //true
    
    var arr3 = arr.some(function(x) {
         return x < 1;
    }); 
    console.log(arr3); // false
    

    ####15、reduce()和 reduceRight()
    这两个方法都会实现迭代数组的所有项,然后构建一个最终返回的值。reduce()方法从数组的第一项开始,逐个遍历到最后。而 reduceRight()则从数组的最后一项开始,向前遍历到第一项。

    这两个方法都接收两个参数:一个在每一项上调用的函数和(可选的)作为归并基础的初始值。

    传给 reduce()和 reduceRight()的函数接收 4 个参数:前一个值、当前值、项的索引和数组对象。这个函数返回的任何值都会作为第一个参数自动传给下一项。第一次迭代发生在数组的第二项上,因此第一个参数是数组的第一项,第二个参数就是数组的第二项。

    下面代码用reduce()实现数组求和,数组一开始加了一个初始值10。

    var values = [1,2,3,4,5];
    var sum = values.reduceRight(function(prev, cur, index, array){
    return prev + cur;
    },10);
    console.log(sum); //25
    

    近期整理一下ECMAScript 6 中数组的扩展(点击查看 ECMAScript 6 中数组的扩展)

    展开全文
  • 本文是小编给大家特意整理的关于 js 数组方法的知识非常实用在面试笔试题中经 常用得到有需要的朋友可以参考下 数组在笔试中经常会出现的面试题 javascript 中的数组与其他语言中的数组有些不同 为了方便之后数组的...
  • 主要给大家介绍了关于Javascript数组方法reduce的妙用之处,文中通过示例代码介绍的非常详细,对大家学习或者使用Javascript具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 改变原数组: pop():删除 arrayObject 的最后一个元素,把数组长度减 1,并且返回它删除的...push():push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject,而不是创建一个新的数组,...

    改变原数组:

    pop():   删除 arrayObject 的最后一个元素,把数组长度减 1,并且返回它删除的元素的值。如果数组已经为空,则 pop() 不 改变数组,并返回 undefined 值。arrayObject.pop() 

     

    push():push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject,而不是创建一个新的数组,arrayObject.push(newelement1,newelement2,….,newelementX) 


    reverse():该方法会改变原来的数组----将原来的数组倒序,而不会创建新的数组。arrayObject.reverse() 


    shift():   删除数组的第一个元素,并返回第一个元素的值,如果数组是空的,那么 shift() 方法将不进行任何操作. 

     

    unshift():  unshift() 方法可向数组的开头添加一个或更多元素,并返回新的长度。arrayObject.unshift(newelement1,newelement2,….,newelementX)返回arrayObject 的新长度


    sort():   对数组的引用。请注意,数组在原数组上进行排序,不生成副本。arrayObject.sort(sortby) (如果调用该方法时没有使用参数,将按字母顺序对数组中的元素进行排序,说得更精确点,是按照字符编码的顺序进行排序。要实现这一点,首先应把数组的元素都转换成字符串(如有必要),以便进行比较。 
    如果想按照其他标准进行排序,就需要提供比较函数,该函数要比较两个值,然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b,其返回值如下: 
    若 a 小于 b,在排序后的数组中 a 应该出现在 b 之前,则返回一个小于 0 的值。 
    若 a 等于 b,则返回 0。 
    若 a 大于 b,则返回一个大于 0 的值。) 


    splice():  splice() 方法可删除从 index 处开始的零个或多个元素,并且用参数列表中声明的一个或多个值来替换那些被删除的元素。 如果从 arrayObject 中删除了元素,则返回的是含有被删除的元素的数组 arrayObject.splice(index,howmany,item1,…..,itemX) 
     

     

    不改变原数组:

    concat():用于连接两个或多个数组,仅会返回被连接数组的一个副本,arrayObject.concat(arrayX,arrayX,……,arrayX) 


    join():返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串,然后把这些字符串连接起来,arrayObject.join(separator) 


    slice():arrayObject.slice(start,end)返回一个新的数组,包含从 start 到 end (不包括该元素)的 arrayObject 中的元素。

    展开全文
  • JavaScript数组方法总结

    万次阅读 多人点赞 2018-09-25 18:48:29
    一.JavaScript中创建数组的方式 1.使用Array构造函数 var color=new Array();  注意:括号里面参数可以有参数,若为一个数字,表示该数组的长度,如果为多个数字或者一个(多个)非数字表示的是传递数组中应该...
  • 数组在笔试中经常会出现的面试题,javascript中的数组与其他语言中的数组有些不同,为了方便之后数组方法学习,下面小编给大家整理了关于数组的操作方法,一起看看吧。 数组创建 JavaScript中创建数组有两种方式,...
  • JS数组方法总结大全

    千次阅读 2020-06-16 17:25:09
    js数组方法总结 JavaScript语言里给数组提供了很多好用的方法对数组进行操作,用起来非常方便,在此总结记录一下。 一.数组创建 1.使用 Array 构造函数: var arr1 = new Array(); //创建一个空数组 var arr2 = new...
  • js数组方法大全

    万次阅读 多人点赞 2018-10-18 16:09:31
    很早之前就想整明白JS到底有多少操作数组方法,是怎么使用的,今天正好找到了个比较好的总结,分享给大家 原文地址:https://www.cnblogs.com/obel/p/7016414.html JavaScript中创建数组有两种方式 (一)使用 ...
  • 改变原数组: pop():删除 arrayObject 的最后一个元素,把数组长度减 1,并且返回它删除的元素的值。如果数组已经为空,则 pop() 不 改变数组,并返回 undefined 值。arrayObject.pop() push()方法可把它的参数...
  • 改变原数组: ...*push():*push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject,而不是创建一个新的数组,arrayObject.push(newelement1,newelement2,….,newelementX) reverse
  • js数组方法及其返回值(简单用法)

    千次阅读 2020-05-12 18:19:18
    js数组方法及其返回值1-1.join()1-2.push()1-3.pop()1-4.unshift()1-5.shift()1-6.sort()1-7.reverse()1-8.concat()1-9.slice()1-10.splice()1-11.indexof()和includes()1-12.fill()2-1.forEach()2-2. map()2-3....
  • 一、常用的数组方法1、push() 接收参数,将参数加载到数组最后,参数可为一个或多个值,用逗号隔开,返回数组长度; 2、pop() 不接收参数,删除数组的最后一个元素,返回删除的值; 3、unshift() 接收参数,将参数...
  • 改变原数组: ...push():push() 方法可把它的参数顺序添加到 arrayObject 的尾部。它直接修改 arrayObject,而不是创建一个新的数组,arrayObject.push(newelement1,newelement2,….,newelementX) reverse()
  • js数组方法之改变或不改变原数组

    千次阅读 2020-02-07 00:15:30
    数组方法 改变原数组 push() :将参数添加到数组尾部 返回添加的元素的索引 pop() : 将参数从数组尾部删除 返回删除的元素值,如果数组的长度为0,则返回undefined unshift() : 将参数添加到数组头部 ...
  • var arr1 = new Array(); //创建一个空数组 var arr2 = new Array(20); // 创建一个包含20项的数组 var arr3 = new Array("lily","lucy","Tom"); // 创建一个包含3个字符串的数组
  • 数组js最常用的类型,JavaScript提供了很多数组方法,今天我们就来好好整理一下。 1、push 在数组末尾插入元素 let a=[1,2,3] a.push(4) a//[1,2,3,4] push方法会改变原数组 返回值为插入后数组的长度 2、pop ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 793,714
精华内容 317,485
关键字:

js数组方法