数组的concat、join、splice、slice及简单重构

数组的concat、join、splice、slice及简单重构

1、concat

var arr = [1,2,3,4];
var s = arr.concat(5,6,7,8) 
// s = [1,2,3,4,5,6,7,8]   arr = [1,2,3,4]
var t = arr.concat([5,6,7],[8,9]) // t = [1,2,3,4,5,6,7,8,9]

concat的方法会讲数组链接若干个数组或者元素，返回一个新的连接完成的数组，与原数组无引用关系。

concat的重构：

function concat(arr){
    var arr1 = [];
    for(var i = 0; i < arr.length ;i++)  arr1[i] = arr[i];
    if(arguments.length === 1) return arr1;
    for(var j = 1; j < arguments.length; j++ ){
        if(arguments[j] !== undefined && arguments[j] !== null && arguments[j].constructor === Array){
            for(var k = 0; k < arguments[j].length; k++){
                arr1[arr1.length] = arguments[j][k]
              }
            }else{
                arr1[arr.length] = arguments[j];
              }
      }   
    return arr1;
}

2、join

var arr = [1,2,3,4];
var str = arr.join("*") // 1*2*3*4

使用某个字符作为连接符，将所有数组的元素连接成为一个字符串并且返回这个字符串，如果连接符没有，默认以逗号连接。

join的重构

function join(arr,separator){
     if(separator === undefined) separator = ',';
     separator = String(separator);
     var str = '';
     for(var i = 0;i<arr.length;i++){
        if(i !== arr.length - 1) str+= arr[i] + separator;
        else str += arr[i]
     }
     return str;
}

3、splice

splice有三种用法：

1、将数组中从第几位开始删除多少个元素，并且返回被删除的元素组成的新数组

var arr = [1,2,3,4];
var arr1 = arr.splice(1,2);//从第一位开始删除两个元素
var arr2 = arr.splice(1)//从第一位开始删除到尾部
var arr3 = arr.splice(-1)//如果参数是负数，从后向前数开始删除
var arr4 = arr.splice(0)//如果没有参数 则返回一个空数组
var arr5 = arr.splice(-3,2)//从倒数第三个元素向后删除两个元素

2、将数组中从第几位开始删除多少个元素后，并且在该位置插入新的若干元素，返回删除元素组成的新数组。

var arr = [1,2,3,4];
var arr1 = arr.splice(1,2,5,6)//从第一位开始向后删除两个元素，并在该位置插入5,6替换，返回被删除的两个元素组成的新数组

3、在数组的第几位开始插入若干个元素，并且返回空的新数组。

var arr = [1,2,3,4];
var arr1 = arr.splice(1,0,5,6)//从第一位插入元素5，6。返回空数组。

splice的重构

function splice(arr,start,count){
   start = start || 0;
   arr1= [];
   arr2 = [];
  for(var i = 3;i < arguments.length;i++)arr1[arr1.length] =arguments[i]               
                    start = start < 0 ? (start + arr.legth < 0 ? 0 : start + arr.length) : (start > arr.length ? arr.length : start);
                    count = count > (arr.length - start) ? (arr.length - start) : count;
                    for(var j = start; j < (count+start); j++) arr2.push(arr[j]);
                    for(var k = start + count; k < arr.length; k++ )  arr[k - count] = arr[k];
                    arr.length = arr.length - count;
                    for(var n = arr1.length - 1; n>=0; n--){
                        for(var m = arr.length; m > start; m--) arr[m] = arr[m-1];
                        arr[start] = arr1[n];
                    } 
                    return arr2;   
                }

4、slice

slice是将数组从第几项开始到第几项结束复制在这些元素到新数组中，原数组不改变，返回新数组。

var arr = [1,2,3,4];
var arr1 = arr.slice(1,2)//复制从第一项到第二项，不包括结束这一项。
var arr2 = arr.slice(0) //复制数组
var arr3 = arr.slice(-2) // 从后向前数第二个元素到尾部所有元素复制

slice的重构

function slice(arr,start,end){
                    var arr1 = [];
                    start = start || 0;
                    end = end || arr.length;
                    if(start < 0) start += arr.length;
                    if(start < 0) start = 0;
                    if(end < 0) end += arr.length;
                    if(end > arr.length) end = arr.length;
                    for(var i = start; i < end;i++) arr1[arr1.length] = arr[i];
                    return arr1;
                }function slice(arr,start,end){
  if(start===undefined) start = 0;
}