数组操作方法归总

一、添加元素

1.push()

//向数组的末尾添加一个或多个元素(多个参数就可以)
//push方法返回的值为改变后的数组的长度
var arr = [1,2,3];		//[1,2,3,a]
var re = arr.push(a);	//4

2.unshift()

//和push相反，在数组的最前边添加一个或多个元素，返回修改后数组的长度
var arr = [1, 2];//arr[1,2,3,2]
var re = arr.unshift(3, 2);//4(长度为4)

3.concat()

concat:合并数组，把concat所有的参数添加的数组的尾部,直接返回合并后的新数组
   - concat可以有多个参数，一起合并
   - concat的参数可以是数组，把数组展开合并到arr中,只能展开一个维度
var arr = [1, 2];
var re = arr.concat([1, [2]], [3, 4]);   
//re返回[1,2, [1,[2]] , [3,4]]

4.fill()

固定值填充数组
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob");
输出Runoob,Runoob,Runoob,Runoob

二、删除元素

1.pop()

//删除数组的最后一位，并返回删除的元素
var arr = ["a","b","1"];	//["a","b"]
var re = arr.pop();			//[1]

2.shift()

//和pop相反，删除数组的最前的一个元素，并返回删除的元素
var arr2 = ["a", 2, 3, 4];//[2,3,4]
var re = arr2.shift();//[a]

3.delete

var arr = [1,2,3,4]
delete arr[1]; //把数组的下标为1的值删掉了
//[1, empty, 3, 4]

三、不对元素做修改，返回一个值

1.peek()

//返回栈顶元素(最后一个元素)，不对栈做修改
var arr = [1,2,3,"a"]  //[1,2,3,"a"]
var re = arr.peek();  //a

2.isEmpty()

//判断栈中是否为空，返回布尔值
function isEmpty(arr) {
            return arr.length === 0;
        }
var re = isEmpty(arr);

3.isArray()

isArray是数组的静态方法，也就是Array.isArray()来使用
- 检测一个值是不是数组，返回布尔值
var arr = [];//true
var arr = {};//false

4.clear()

//清空整个栈
var arr = ["a","b",3]
 function clear(arr) {
            arr.length = 0;
        }
 clear(arr);//arr = []

5.tostring方法

- 将数组转为字符串，当数组处在一个字符串环境的时候会自动的调用
- 其实是把数组的中括号去掉，然后添加了引号 变成一个字符串
var arr = [1,2,3]
var re = arr.string();//1,2,3,4

6.join()方法

- 将数组转为字符串,原数组不变 返回一个字符串
- 可以传递参数，参数就是取代 数组转为字符串后的逗号 的符号
var arr = [1,2,3,4]
var re = arr.join("")//1234

7.indexOf方法和lastIndexOf

indexOf:检验数组中有没有出现某个元素 
- 返回检测到第一个元素所在的下标，如果没有检测到则返回-1
- 参数1：被检测的元素
- 参数2：开始检测的位置
- 检测的时候 是全等判断
lastIndexOf:
和indexOf类似，只不过是倒着开始检测，返回的仍然是下标

var arr = ["a", "b", "c", "d", [], o, "a", "e", "f"];
var re = arr.indexOf("a",0);//0 

8.every方法

判断数组中所有的元素是否都符合条件，返回布尔值  一假即假
使用every:  
every接受一个回调函数作为参数
数组的值会依次调用函数执行
回调函数接受3个参数 
1.item 当前的值  
2.index 当前值的下标 
3.array 原数组的引用
 var arr = [{
                name: "xiaowang",
                age: 19
            },{
                name: "laowang",
                age: 29
            },{
                name: "xiaohuang",
                age: 13
            }, ];
var re = arr.every(function(item,index,array)
                  {
    			return item.age > 18;
});

9.some方法

判断数组中元素是否有符合条件的，如果有则返回布尔值 一真即真
some接受一个回调函数作为参数
数组的值会依次调用函数执行
回调函数接受3个参数 
1.item 当前的值  
2.index 当前值的下标 
3.array 原数组的引用
 var arr = [{
                name: "xiaowang",
                age: 19
            },{
                name: "laowang",
                age: 29
            },{
                name: "xiaohuang",
                age: 13
            }, ];
var re = arr.some(function(item,index,array){
    return item.age <18;
})

四、不对元素做修改，返回一个数组

1.map方法

- 映射数组
- 和forEach的书写方法一致
- 一定会返回一个和原数组长度一样的新数组
- 返回新数组的每一个元素的值，就是对应原数组的值在回调函数操作后的返回值
- 当想要对数组中的每个值都进行修饰操作的时候，此时可以选择map

var arr = [1,2,3,4];
var re = arr.map(function(item,index){
    return item + 1;
})//re = [2,3,4,5]

2.filter方法

- fliter方法是过滤数组
- 书写和forEach一致
- 一定返回一个数组
- 当原数组的值依次进入回调函数执行的时候，如果回调函数返回true,则把当前的值放到返回的新数组中
 var arr = [{
                name: "xiaowang",
                age: 19
            },
            {
                name: "laowang",
                age: 29 
            },
            {
                name: "xiaohuang",
                age: 13
            },];
var re = arr.filter(function(item,index){
    return item.age > 20;
})
        

3.slice方法

- 截取数组,对原数组没有影响，返回截取后的新数组
- 参数1：开始截取的下标，一般不为负数
- 参数2：结束位置（不包含），结束位置为负数，则倒着数
var arr = [1,2,3]
var re = arr.slice(0,2)//[1,2]

五、改变原数组

1.reverse方法

- 数组倒序输出
- 直接改变了原数组，并把原数组的地址值返回出去
var arr = [1,3,5,7]
var re = arr.reverse();//[7,5,3,1]

2.splice方法

 - 参数1：开始删除元素的下标,如果是负数，则倒着查找
 - 参数2：删除元素的长度，长度为负数 默认为0
 - 参数3: 在删除的位置添加的元素，可以是多个
作用：
 - 删除：参数1和参数2
 - 添加：参数1是添加的下标，参数2长度要设置为0，添加的新元素
 - 替换：参数1是添加的下标，参数2要被替换的长度，参数3是添加的新元素，可以是任意长度
 - 返回值：splice改变了原数组，并把删除的元素组成了一个新的数组返回

var arr = ["a", "b", "c", "d", "e"];//["a", "x" ,"d","e"]
var re = arr.splice(1, 2, "x");//["b","c"]

3.sort方法

- 改变了原数组 并返回原数组的地址值 
- 如果没有任何参数，则默认升序排列，默认会转成字符串进行比较(字符串比较就是按照一位一位比较了)
- 常用排序，sort接受一个回调函数，也就是参数是一个函数
- 回调函数的接受两个参数，每次进来两个进行比较
- 回调函数如果return 负数 则交换位置  return的是其他则不会交换位置
- 回调函数的第一个参数和第二个参数 分别对应着后边的值和前边的值
- return a-b 是升序  return b-a是降序

var arr = [1, 31, 111, 45, 26];
var re = arr.sort();
arr.sort(function (a, b) {//参数是一个函数
    //每次拿相邻的两个数据进行比较
            return b - a;//简化
            /* if (a > b) {
                return -1;
            } else if (a < b) {
                return 1;
            } else {
                return 1
            } */
        })
console.log(arr);//[111,45,31,26,1]

六、forEach方法

专门用来遍历数组，比for循环好用
- 接受一个回调函数作为参数，数组的值依次调用回调函数执行
- 回调函数接受3个参数  分别是 
1.当前值 2.下标  3.原数组的引用
- 单纯的遍历数组，没有返回值
//给数组的值都加1
 		var arr = [1, 2, 3, 4, 5, 6];
        var newArr = [];
        arr.forEach(function (item, index, array) {
            // console.log(item, index)
            newArr.push(item + 1);
        })

七.数组操作图

// push():向数组的末尾添加一个或多个元素(多个参数就可以)push方法返回改变后数组的长度             

//  pop():删除数组的最后一位，并返回删除的元素                
//  peek:返回栈顶元素 不对栈做修改

// isEmpty 判断栈中是否为空，返回布尔值

// clear:清空整个栈

//  unshift:和push相反，在数组的最前边添加一个或多个元素，返回修改后数组的长度            
     
//  shift:和pop相反，删除数组的最前的一个元素，并返回删除的元素