数组方法重构

1. push方法

• 在数组尾部添加若干元素，并返回数组的长度
• 会改变原数组

  function push(arr){
      for(var i=1;i<arguments.length;i++){
          arr[arr.length]=arguments[i];
      }
      return arr.length;
  }
  

2. pop方法

• 在数组尾部删除一个元素，并返回被删除的元素
• 会改变原数组

function pop(arr){
    var ele=arr[0];
    if(arr.length>0) arr.length--;
    return ele;
}

3. unshift方法

• 在数组头部添加若干元素，并返回数组的长度
• 会改变原数组

function unshift(arr){
    var len=arr.length-1;
    for(var i=arr.length-1;i>=0;i++){
        arr[i+len]=arr[i];
        arr[i]="";
    }
    for(var j=0;j<arguments.length;j++){
        arr[j-1]=arguments[j];
    }
    return arr.length;
}

function unshift(arr){
    var arr1=[];
    for(var i=0;i<arr.length;i++){
        arr1[i]=arr[i];
    }
    arr.length=0;
    for(var j=1;j<arguments.length;j++){
        arr[j-1]=arguments[j];
    }
    for(var k=0;k<arr1.length;k++){
        arr[arr.length]=arr1[k];
    }
    return arr.length;
}

4. shift方法

• 在数组头部删除一个元素，并返回这个元素
• 会改变原数组

function shift(arr){
    var ele=arr[0];
    for(var i=1;i<arr.length;i++){
        arr[i-1]=arr[i];
    }
    if(arr.length>0) arr.length--;
    return ele;
}

5. 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;
}

6. 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]!==null && arguments[j].constructor===Array){
            for(var k=0;k<arguments[j].length;k++){
                arr1[arr1.length]=arguments[j][k];
            }
        }else{
            arr1[arr1.length]=arguments[j];
        }
    }
    return arr1;
}

7. splice方法

• 将数组中第几位开始，删除多少个元素，并返回被删除元素组成的数组

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

• 在数组的第几位开始插入若干新元素，返回空的新数组

• 会改变原数组

8. slice方法

• 从第几项开始到第几项结束复制这些元素到新数组中，原数组不改变

function slice(arr,start,end){
    if(start===undefined) start=0;
    if(end===undefined) end=arr.length-1;
    start=Number(start);
    end=Number(end);
    if(!isNaN(end) && isNaN(start)) start=0;
    if(isNaN(start)) return[];
    if(start<0) start=arr.length+start;
    if(end<0) end=arr.length+end;
    var arr1=[];
    for(var i=start;i<end;i++){
        arr1[i-start]=arr[i];
    }
    return arr1;
}

9. reverse方法

• 当前数组按照倒装顺序颠倒，并返回原数组
• 会改变原数组

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;
}

10. sort方法

• 按照字符规则进行排序，返回原数组
• 会改变原数组

// 冒泡排序
function sort(arr){
    var len=arr.length-1;
    while(len>0){
        for(var i=0,j;i<arr.length;i++){
            if(arr[i]>arr[i+1]){
                var temp=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=temp;
            }
        }
        len--;
    }
}

function selectSort(arr){
    var len=arr.length-1;
    for(var i=0;i<len-1;i++){
        var minIndex=i,temp;
        for(var j=1;j<len;j++){
            if(arr[minIndex]>arr[j]){
                        minIndex=j;
            }
        }
        temp=arr[minIndex];
        arr[minIndex]=a[i];
        arr[i]=temp;
    }
    return arr;
}

function quickSort(arr){
    if(arr.length<=1) return arr;
    var avgIndex=parseInt(arr.length/2);
    var avg=arr.slice(avgIndex,1)[0];
    var left=[];
    var right=[];
    for(var i=0;i<arr.length;i++){
        if(i<avgIndex){
            left.push(arr[i]);
        }else{
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([avg],quickSort(right));
}

11. indexOf方法

• 在数组中查找元素，并返回该元素的下标，如果没有，返回-1
• 不会改变原数组

function indexOf(arr,search,index){
    if(index===undefined) index=0;
    for(var i=index;i<arr.length;i++){
        if(arr[i]===search) return i;
    }
    return -1;
}

12. lastIndexOf方法

• 从后向前查找元素，找到返回给元素的下标，如果没有，返回-1
• 不会改变原数组

function lastIndexOf(arr,search,index){
    if(index===undefined) index=arr.length-1;
    for(var i=index;i>=0;i--){
        if(arr[i]===search) return i;
    }
    return -1;
}

13. fill方法

• 只能用于有长度的数组，如果没有开始位置和结束位置，就会全部填充
• 填充对象会造成填充同一个引用地址的对象

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

14. forEach方法

• 遍历数组，获取使用元素和下标，自动过滤空元素，空元素不遍历
• 不会改变原数组

function forEach(arr,fn){
    for(var i=0;i<arr.length;i++){
        if(i in arr) fn(arr[i],i,arr);
    }
}

15. map方法

• 遍历数组，使用return返回元素，这些被返回的元素会被放在一个新数组中，新数组的长度与原数组相同

function map(arr,fn){
    var arr1=[];
    for(var i=0;i<arr.length;i++){
        if(i in arr) arr1[i]=fn(arr[i],i,arr);
    }
    return arr1;
}

16. some方法

• 判断数组是否有满足条件的元素，如果有直接跳出返回true，否则返回false

function some(arr,fn){
    for(var i=0;i<arr.length;i++){
        if(i in arr && fn(arr[i],i,arr)) return true;
    }
    return false;
}

17. every方法

• 遍历数组，判断每个元素是否满足条件，如果不满足直接跳出，返回false，否则返回true

function every(arr,fn){
    for(var i=0;i<arr.length;i++){
        if(i in arr && !fn(arr[i],i,arr)) return false;
    }
    return true;
}

18. filter方法 筛选，过滤

• 将满足条件的元素放在一个新数组中，并返回这个新数组

function reduce(arr,fn,initValue){
    var index=0;
    if(initValue===undefined){
        initValue=arr[0];
        index=1;
    }
    for(;index<arr.length;index++){
        initValue=fn(initValue,arr[index],index,arr);
    }
    return initValue;
}

19. flatMap方法

• 扁平化数组

function flatMap(arr,fn){
    var arr1=[];
    if(arr.length<=0) return arr1;
    for(var i=0;i<arr.length;i++){
        if(Array.isArray(fn(arr[i],i,arr))){
            for(var index in arr[i]){
            arr1.push(arr[i][index]);
        }
        }else{
            if(arr[i]!==undefined){
                arr1.push(arr[i]);
            }
        }
    }
    return arr1;
}