数组重构01

数组重构01

修改原数组

push ,pop ,shift ,unshift

//push ： 在数组的最后添加元素(个数没有限制)，并返回新数组的长度 ，数值类型，
// 重构push
 let arrps = [1, 2, 3]
 // ...arg :扩展运算符，用于将可迭代的对象或数组，或函数的剩余参数转换成一个逗号分隔的列表（数组） 
 function arrayPush(arr, ...arg) {
 // console.log(arg, '展开语法') // [4,5]
 	if (arr.constructor !== Array || !arr) throw new TypeError('arr is not an Array')
    if (arg.length === 0) return arr.length
    for (let i = 0; i < arg.length; i++) {
       arr[arr.length] = arg[i]
     }
       return arr.length
  }

 console.log(arrayPush(arrps, 4, 5, 6), arrps)
 

//POP： 删除数组的最后一个元素，并返回改元素，any
// 重构pop
let arrPop = [1,2,3]
function arrayPop(arr) {
    if (!arr || arr.constructor !== 'Array') throw new TypeError('arr is not an Array')
    if (arr.length === 0) return  // 如果数组为空，删除的元素为undefined
    let itm = arr[arr.length - 1]
    arr.length -= 1
    return itm
}
 console.log(arrPop.pop() , arrayPop(arrPop) ,arrPop ,arrayPop(arrPop) , arrayPop(arrPop) )

//unshift : 在数组的最前面添加元素，返回新数组的长度，number
// 重构shift
/* 
思路： 硬撸即可 , 数组是紧密型结构，前面添加元素，后面的元素相应的向后移动
*/
let arrUshift = [3,2,1]
function arrayUshift (arr , ...arg){
    if (!arr || arr.constructor !== 'Array') throw new TypeError('arr is not an Array')
    for(let i = arr.length + arg.length - 1 ; i >= 0 ; i--){
    if(i >= arg.length) arr[i] = arr[i - arg.length]
    else arr[i] = arg[i]
    }
    return arr.length
}
 console.log(  arrUshift , arrayUshift(arrUshift , 5,4))

//shift : 删除数组的第一个元素，返回删除的元素，any
//重构shift
let arrShift = [1,2,3,4,5]
function arrayShift(arr){
    if(arr.constructor !== 'Array' && !Array.isArray(arr)) throw new TypeError('arr is not an array')
    if(arr.length === 0) return  // 数组为空，返回undefined
    let itm = arr[0]
    for(let i = 0; i< arr.length -1  ; i++){  // 最终的数组长度减小一个，否个多存一个undefined
        arr[i] = arr[i+1]
    }
     arr.length -= 1
     return itm
    }
console.log(arrayShift(arrShift) ,arrShift, arrayShift(arrShift)) 

不修改原数组

concat , join , slice

//concat  ： concat(数组或则元素。。。)  返回合并后的新数组
/* 
    concat : 只需要注意一点，拼接的时候，空元素的取值, concat不能添加空元素
        需要注意 ： 因为拼接的值可以是数组，所以返回在向新数组中存值的时候索引一直用它自身的长度即可
   */

let arrCon = [,,2,4]
console.log(arrCon.concat([,,,] , 0 , [4,,5]))

function arrayConcat(arr , ...arg){
    if(!arr || arr.constructor !== Array)  throw new TypeError(arr  + 'is not an Array')
    console.log(arg , '93')
    let newArray = []
    for(let i = 0;i< arr.length + arg.length ;i++){
        if(i < arr.length) {
            i in arr  ? newArray[newArray.length] = arr[i] : newArray.length++
        }else{
            let k = i -arr.length
            if(arg[k] && Array.isArray(arg[k])){
            for(let j = 0; j < arg[k].length ; j++){
                j in arg[k] ? newArray[newArray.length] = arg[k][j] : newArray.length++
               }
            }else  newArray[newArray.length] = arg[k]
         }
     }
        return newArray
   }

console.log(arrayConcat(arrCon , [,,,] , 1,2,3,['a','b','c']))

//join ： 链接，默认用逗号将数组中的元素拼接成字符串，可以接受参数按自己想的分割符分割，返回拼接后的字符串

 /* 
    join : 数组拼接成字符串，默认分隔符是逗号
    传入undefined ==》 ，
    null ==> null 
    在讲数组转成字符串的时候，arr.join() === String([1,2,3])  默认转的话就是用的强制类型转字符串方法,所以join进行拼接的字符，都是通过  String（）  强制转换后的字符串
    并且如果数组中的元素是数组的话，在字符串拼接的时候，数组隐式转字符串也就是强制转换
        */

let arrJoin = [[1,2,3]  , {a: '1'} , 3,4,5]
console.log(arrJoin.join([,,,,]), String([,,,])  , arrJoin[0])

function arrayJoin(arr , Separator =','){
    if(!arr || arr.constructor !== Array) throw new TypeError(arr + 'is not an Array')
    let str = ''
    for(let i = 0 ; i < arr.length ; i++){
        i === 0 ? str = arr[i] : str += String(Separator) + arr[i]
    }
        return str
}

 console.log(arrayJoin(arrJoin))

//slice : 截取 ， 返回新的数组，元素为截取的元素
/* 
    slice : arr.slice(start , end ) 
       start : 开始截取的下标 ，取 ， 可正可负， 省略就从零开始, 小数向下取正，非数字取零
       end: 截取结束的下标 ， 不取， 可正开负，负数从后向前数， 省略就截取到数组最后 ， 小数向下取正，非数字取零
        包前不包后
        */

let arrSlice = [1,2,3,4,5]

function arraySlice(arr , start = 0 , end = arr.length ){
    if(!arr  ||  arr.constructor !== Array) throw new TypeError(arr + 'is not an Array')
    let newArray = []
    start = ~~start // 小数向下取整，非数字取零
    end = ~~end // 小数向下取整 ，非数字取零
    if(start < 0) start = start + arr.length  < 0 ? 0 : arr.length + start 
    if(end < 0) end = end + end.length  < 0 ? 0 : arr.length + end
    while(start < end){
        start in arr ? newArray[arr.length] = arr[start] : newArray.length++
        start++ 
    }
    return newArray
}