数组常用方法

第一部分：

数组的概念：是一种容器，可以同时存放多个数据值

数组的特点：

1. 数组是一种引用数据类型
2. 数组当中的多个数据，类型必须统一
3. 数组的长度在程序运行期间不可以改变

两种常见的初始化方式：

1.动态初始化（指定长度）
2.静态初始化（指定类容）

数组常用方法

• sort()：对数组的元素进行排序。
• reserse()：反转数组的元素排序。
• join()：将所有数组元素连接到一个字符串中。
• push()：将一个新元素添加到数组中（最后位置）。
• pop()：从数组中删除最后一个元素。
• shift()：删除第一个数组元素，并将所有其他元素移位到较低的索引。
• unshift()：将新元素添加到数组中（在开始处），并取消旧元素。
• splice()：用于向数组中添加新项目（拼接数组），返回一个包含已删除项目的数组。
• slice()：将一个数组切成一个新数组，但是并不会从原数组中删除任何元素。
• concat()：合并数组，通过合并连接现有数组来创建新的数组（不会改变原有数组，只是返回一个新数组），可以采用任意数量的数组参数。
• indexOf()：检测当前值在数组中第一次出现的位置索引
• lastIndexOf()：检测当前值在数组中最后一次出现的位置索引

数组的用法

基础方法：

.push()方法

push 可以在数组末尾添加一个值，例子：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.push(“Kiwi”)

.copyWithin() 方法

复制数组的前面两个元素到后面两个元素上：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.copyWithin(2, 0);

.unshift() 方法

unshift 向数组的开头添加一个或更多元素，并返回新的长度。

.pop()方法

移除最后一个数组元素

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.pop();

.shift() 方法

删除并返回数组的第一个元素

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.shift()

.splice() 方法

数组中添加新元素：

var fruits = [“Banana”, “Orange”, “Apple”, “Mango”];
fruits.splice(2,0,”Lemon”,”Kiwi”);

.slice()方法

选取数组的的一部分，并返回一个新数组。

var fruits = [“Banana”, “Orange”, “Lemon”, “Apple”, “Mango”];
var citrus = fruits.slice(1,3);

.map() 方法

map 方法可以方便的迭代数组，例子：

var timesFour = oldArray.map(function(val){
return val * 4;
});

map 方法会迭代数组中的每一个元素，并根据回调函数来处理每一个元素，最后返回一个新数组。注意，这个方法不会改变原始数组。

.find()方法

find()方法对数组中的每一项元素执行一次 callback 函数，直至有一个 callback 返回 true。当找到了这样一个元素后，该方法会立即返回这个元素的值，否则返回 [undefined]

let result = arr.find(function(item, index, array) {

// 如果返回 true，则返回 item 并停止迭代

// 如果全部false的情况，则返回 undefined });

.filter()

filter()  方法创建一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组。

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present']; 代码： const result = words.filter(word => word.length > 6);

console.log(result);

// expected output: Array ["exuberant", "destruction", "present"]

.some()

some() 方法用于查找数组中有至少一个元素通过回调函数的测试就会返回true 所有元素都没有返回值才会为false。

代码：

let c = [1, 5, 3, 6, 7, 6].some((item, index) => index === 5)

console.log(c)-------//true

.every()

every()  方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。

数组常用方法

1.join()

join() 方法用于把数组中的所有元素转换一个字符串
元素是通过指定的分隔符进行分隔的。默认使用逗号作为分隔符

  var app = [1,2,3];
        console.log(app); 
        console.log(app.join());   
        console.log(app.join("~")); 

2.sort()

sort()：对数组的元素进行排序。

sort() 方法用于对数组的元素进行排序。

排序顺序可以是字母或数字，并按升序或降序。

默认排序顺序为按字母升序。

var arr = [1, 2, 3, 1, 1]

var arr1 = arr.sort(function(a, b) {
     return b - a
})
console.log(arr);

console.log(arr1);

3.reverse()

reverse() :方法用于反转数组中的元素，也就是逆向排序。

        var app = ["张三", "李四", "王五", "赵六"];
        console.log(app.reverse());   
        console.log(app);  //原数组发生改变

4.shift() 和 unshift()

shift()：删除第一个数组元素，并将所有其他元素移位到较低的索引。 unshift()：将新元素添加到数组中（在开始处），并取消旧元素。

            var app = ["张三","李四","王五"];
            var count = app.unshift("宋七","赵六");  
            console.log(app);   
            var item = app.shift();
            console.log(item); 
            console.log(app);   

5.splice()

splice()：是一个很强大的数组方法，它有很多种用法，可以实现删除、插入和替换

删除元素

可以删除任意数量的项，只需指定 2 个参数：要删除的第一项的位置和要删除的项数。例如， splice(1,2)会删除数组中的第二项以及后一个。

    var app = [1,2,3,4,5,6,7];
            var app2= app.splice(4,5);
            console.log(app);  
            console.log(app2); //返回删除的元素

向指定索引处添加元素

可以向指定位置插入任意数量的项，只需提供 3 个参数：起始位置、 0（要删除的项数）和要插入的项。

            var app = [1,2,3,4,5];
            var app2= app.splice(5,4,7,9);
            console.log(app);  

替换指定索引位置的元素

可以向指定位置插入任意数量的项，且同时删除任意数量的项，只需指定 3 个参数：起始位置、要删除的项数和要插入的任意数量的项。插入的项数不必与删除的项数相等。

            var app = [1,2,3,4,5];
            var app2= app.splice(3,1,7,8);
            console.log(app);  

6.indexOf()和 lastIndexOf()

接收两个参数：要查找的项和（可选的）表示查找起点位置的索引。

indexOf()：从数组的开头（位置 0）开始向后查找。

lastIndexOf：从数组的末尾开始向前查找。

indexOf() 的用法为：

str.indexOf( str1 [,startIndex] )

lastIndexOf() 的参数含义和注意事项和indexOf()  方法的完全相同

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

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

7.push()和 pop()

push()：将一个新元素添加到数组中（最后位置）。
pop()：从数组中删除最后一个元素。

            var app = ["张三","李四","王五"];
            var count = app.push("张三","刘子");
            console.log(app);   
            var item = app.pop();//删除最后一个元素
            console.log(item);  
            console.log(app);

8.slice()

slice() 方法可以将一个数组切成一个新数组，可以从已有数组中返回选定的元素，但是并不会从原数组中删除任何元素。

array.slice(start,end)

9.concat()

concat() 方法用于合并数组，通过合并连接现有数组来创建新的数组（不会改变原有数组，只是返回一个新数组），可以采用任意数量的数组参数。

string.concat(string1, string2, ..., stringX) //语法

            var app1 = [3,5];
            var app2 = [6,8];
            var tet = app1.concat(app2);
            console.log(tet);
            // 合并多个数组，需要使用逗号将数组进行分隔
            var app3 = [4,7]
            var tet = app1.concat(app2,app3);
            console.log(tet);

数组的迭代方法

1、every

若数组中每一个元素都满足条件，则返回true，有一个不满足，则返回false

var arr = [1, 2, 3, 1, 1];

var flang = arr.every(function(itme) {
            return itme >= 3
})            
console.log(flang);           

2、reduce(function(a,b){})

对原数组进行运算合并多维数组，返回一个新数组，该方法不会改变原数组
a的值第一次为arr的第一个值，第二次a为你计算或合并的值

var arr = [1, 2, 3, 1, 1];
var flang = arr.reduce(function(a, b) {
console.log(a, b);
return a + b;
})

console.log(flang);

console.log(arr);

var arr2 = [[10, 20, 30], ['hello'], [50, 100], [40], [70, 11, 22]]；

var arrx = arr.reduce(function (a, b) {

return a.concat(b) }) 

3、forEach（）

forEach（）方法用于调用数组的每个元素，并将元素传递给回调函数。

var arr = [1, 2, 3, 1, 1];

arr.forEach(function(value, index, array) {

//value:便利数组的内容

//index:对应数组的索引

//array：数组本身

console.log(value, index, array); })

创建数组

//创建一个数组变量(不带值创建)空数组

let array_value = new Array();

//创建一个数组变量(带值创建)

let score = new Array(80,95,85,72,66,88,99);

//创建一个数据变量(混合数据类型)

let some_type =new Array('abc',123,ture,null);

for循环

for(let index = 0; index<array.length;inde++>){}