Javascript 数组方法 splice，slice，indexOf，lastIndexOf, reverse 及实现过程

splice ( ) ，给数组中添加、删除、替换一个或者多个元素，返回被删除元素组成的数组，原始数组会被改变

• 参数含义：arr.splice (从什么位置开始，删除多少个元素，要添加的元素)
• 当参数为空时，不删除任何元素，等于创建了一个空数组
• 当只有一个参数时，表示从当前参数下标开始，删除后面的所有元素
• 当第一个参数为负数时，表示从数组的尾部开始倒着数第几个

var arr = [1,2,3,4,5];
// arr.splice(从什么位置开始，删除多少个元素，要添加的元素)
var arr1 = arr.splice();//[] 当参数为空时，不删除任何东西，等于创建了一个空数组
var arr2 = arr.splice(0);//[1,2,3,4,5]表示从下标0开始，删除所有元素,arr变成了空数组，相当于将原数组的所有元素传递给新数组
var arr3 = arr.splice(-2);//[4,5] 负数指从后向前数，-2就是倒数第2个
var arr4 = arr.splice(2,2);//[3,4]从下标2开始，删除2个元素
var arr5 = arr.splice(2,0,12,14);//[ ] 从下标2开始，插入12和14
var arr6 = arr.splice(2,2,12,14);//[3,4] 从下标2开始，删除两位，替换为12，14

splice ( ) 的实现过程：

var arr=[4,5,6,7,8];
function splice(arr,start,count){
    var arr1 = [];
    //将参数转成数字
    start=Number(start);
    count=Number(count);
    //如果第一个参数为空，则直接返回空数组arr1
    if(isNaN(start)) return arr1;
    //如果第一个参数是负数，则让它变成正着数的下标
    if(start<0) start+=arr.length;
    //如果第二个参数为空，则让它等于第一个参数到数组尾部的元素数
    if(isNaN(count)) count=arr.length-start;
    //从第一个参数开始循环数组
    for(var i=start,index=0;i<arr.length;i++,index++){
        //到第二个参数为止，将第一个参数到第二个参数之间的元素添加到arr1里
        if(index<count) arr1[index] = arr[i];
        //原数组的元素往前挪
        arr[i] = arr[i+count];
    }
    //按照第一个参数的值和添加元素的数量，让原数组从第一个参数的位置增加count数量
    for(var j=0;j<arguments.length-3;j++){
        for(var m=arr.length-1;m>=start+j;m--){
            arr[m+1]=arr[m];
        }
    }
    //将参数添加到原数组对应的位置
    for(var y=0;y<arguments.length-3;y++){
        arr[start+y] = arguments[y+3];
    }
    //第二个参数代表删除的元素数，所以让原数组的长度变短
    for(var k=0;k<count;k++){
        arr.length--;
    }
    return arr1;
}
console.log(splice(arr,3,2,9,9,9));

slice ( ) 返回指定数组的一个片段或者子数组，等于是复制一个新数组，修改原数据后，新数组不改变

• 参数含义：arr.slice(从什么位置开始，截取到什么位置之前)，两个参数都表示下标
• 如果参数为空，则复制一个新数组
• 如果只有一个参数，表示从第几项开始复制到尾部
• 如果参数为负数，表示从倒数第几位开始复制到尾部

var arr = [1,2,3,4,5];
var arr1 = arr.slice();//复制一个新数组，修改原数据，新数组不改变
arr[0] = 100;
var arr2 = arr.slice(1);//[2,3,4,5] 从下标1开始到尾部，复制给arr1
var arr3 = arr.slice(-2);//[4,5] 从倒数第2位开始到尾部，复制给arr1
var arr4 = arr.slice(2,3);//[3] 从下标2位复制到下标3，不包含下标3
var arr5 = arr.slice(-3,-1);//[3,4]从倒数第3位复制到倒数第1位，不包含倒数第1位
var arr6 = arr.slice(2,-1);//[3,4] 从下标2开始到倒数第1位，复制给arr1,不包含倒数第1位

slice ( ) 实现过程：

var arr = [1,2,3,4,5];
function slice(arr,start,end){
	var arr1 = [];
	start = Number(start);
	end = Number(end);
	if(isNaN(start)) start=0;
	if(isNaN(end)) end=arr.length;
	if(start<0) start+=arr.length;
	if(end<0) end+=arr.length;
	if(end>arr.length-1) end=arr.length;
	for(var i=start,index=0;i<end;i++,index++){
	   arr1[index] = arr[i];
	}
	return arr1;
}
console.log(slice(arr,2,-1);

indexOf ( ) ，查找元素在数组中的下标，返回下标值，如果没有查找到返回-1

• 参数含义：indexOf(m,n) 从下标为 n 的位置（不包含n）往后查找 m
• 如果第二个参数是负数，表示从数组尾部倒着数第 n 位开始查找
• lastIndexOf ( m,n ) 从数组尾部倒着数第 n 位开始查找 m

获取数组中某一元素出现的所有下标位置：

var arr=[1,2,2,4,3,4,5,4,2,6,2,7];
//for 循环
for(var i=0;i<arr.length;i++){
    if(arr[i]==2){ console.log(i)
}
//while 循环
var index=-1;
while(~(index=arr.indexOf(2,index+1))) console.log(index)

用 indexOf ( ) 来写数组去重

var arr=[1,2,2,4,3,4,5,4,2,6,2,7];
for(var i=1;i<arr.length;i++){
	//从当前元素下标往后找，如果有相同元素，则删除当前的元素
    if(arr.indexOf(arr[i],i+1)>-1) delete arr[i];
}
var arr1=[];
//for in 遍历数组，不会获取到数组中的空元素
for(var prop in arr){
    arr1.push(arr[prop]);
}
arr=arr1.splice(0);
arr1=null;
console.log(arr);

reverse ( ) 将原数组按倒序方式显示，原数组改变，返回原数组

var arr=[1,4,6,2,3,8,7,6,5,3,9];
arr.reverse();
console.log(arr);// [9,3,5,6,7,8,3,2,6,4,1]

reverse ( ) 实现过程：第一位跟最后一位互换位置，第二位跟倒数第二位互换位置…

var arr = [1,2,3,4,5,6];
function reverse(arr){
	//如果数组的个数是单数，最中间的元素不用动
    var len = parseInt(arr.length/2);
    for(var i=0;i<len;i++){
        var temp = arr[i];
        arr[i]=arr[arr.length-1-i];
        arr[arr.length-1-i]=temp;
    }
    return arr;
}
console.log(reverse(arr))