配列APIの実装と配列の再結合

1.配列6個のapiの実現javascriptでは、配列に関するapiが多すぎて、記憶力がよくないので、酔いやすいです.これらのアプリがどのように実現されているかを知るだけで、彼らを利用する時にうまくいくと思います.
1.1 joinarr.join('char')は、入力された文字で配列中の各要素を結合し、文字列を形成するものである.

let arr = [1,2,3];
arr.join('-')//‘1-2-3’

ジョインを実現する

Array.prototype.join = function(char){
	let result = this[0]||'';
    let len = this.length;
    for(let i=1;i//     i 1,             ，           
    	result+=char+this[i]
	}
    return result;
}

1.2 slicearr.slice(begin,end)は、下付きbeginから配列要素を下付きendまで傍受する(endを含まない).

Array.prototype.slice = function(begin,end){
    let begin = begin || 0;//    begin，        0
    let end = end || this.length;//    end,               
    let result = []；
    for(let i=begin;i//     i
        result.push(this[i]);
    }
    return result;
}

sliceは新しい配列を切り取ります.だから多くの人がsliceで疑似配列を行列に変換します.

arr = [].slice.call(arrLike)

ESの新しい文法Aray.fromは、疑似配列を配列に変換することもできます.

array = Array.from(arrLike)

1.3 forEach
forEachは配列を巡回するための各項目です.

arr.forEach(function(item,index,arr){
    //item        
    //index       
    //arr      
})

Array.forEach = function(fn){
    for(let i=0;i<this.length;i++){
		fn.call(undefined,this[i],i,this);
        //call()               
        //              
    }
}

forEachとforの違い:

forEachはbreak

ができません.

forEachは、反復ごとに新しい関数関数領域

を生成する.
1.4 map
mapは、配列を変更する各項目を操作して、新しい配列を返します.

let arr = [1,2,3];
arr.map(function(item,index,arr){
	return item*2
})//[2,4,6]

Array.prototype.map = function(fn){
	let result = [];
    let temp;//            
    for(let i=0;i<this.length;i++){
        if(i in this){//         ，
            temp = fn.call(undefined,thiss[i],i,this)
            result.push(temp)
        }
    }
    return result;
}

1.5 filter
filterはフィルタの役割であり、配列に必要な要素を絞り出して、配列に戻ります.

let arr = [1,2,4];
arr.filter(function(item,index,arr){
	return item%2==0
})//[2,4]

Array.prototype.filter = function(fn){
	let result = [];
    let temp;//               
    for(let i=0;i<this.length;i++){
        if(i in this){
			temp = fn.calll(undefined,this[i],i,this);
            if(temp){//      
                result.push(this[i])
            }
        }
    }
}

1.6レデュース
reduceはアキュムレータとして利用できます.

let arr = [1,2,3];
arr.reduce(function(prev,current,index,arr){
    //prev         ，              
    return prev+current;
},10)//10    ，   prev
//   10+1+2+3=16

Array.prototype.reduce = function(fn,init){
    let result = init ||  0;//    
    for(let i=0;i<this.length;i++){
        if(i in this){
            result=fn.call(undefined,result,this[i],i,this)
        }
    }
    return result;
}

小総節:
mapは配列を変える各要素を操作できます.filterは条件に合う配列要素を選別できます.reduceは累積配列中の各要素です.
1.7 reduce mapを実現する

arr = arr.map(v=>v+1);
arr = arr.reduce((prev,cur){
                 prev.push(v+1)
				 return prev
                 },[])//              

1.8 reduce filterを実現する

arr = arr.filter(v=>v%2==0)
arr = arr.reduce((prev,cur){
                 if(cur%2==0) prev.push(cur)
				 return prev
                 },[])//                  

まとめ:
reduceはmapとfilterの機能を実現できます.初期化された値はすべて空の配列に入ってきます.
2.配列の重さを消す4つの方法
2.1発泡

function unique(arr){
	let newArr = [];
    let len = arr.lenth;
    for(let i=0;ifor(let j =i+1;jif(arr[i]==arr[j]){
                i++;//          ，        
                j=i;//  if     for    j++，
            }
        }
        newArr.push(arr[i])
    }
    return newArr;
}

2.2インデックス値による

function unique(arr){
	let newArr = [];
    let len = arr.length;
    for(let i=0;iif(newArr.indexOf(arr[i])==-1){
            newArr.push(arr[i])
        }
    }
    return newArr;
}

2.3利用対象

function unique(arr){
    let newArr = [];
    let len = arr.length;
    let obj = {};
    for(let i=0;iif(!obj[arr[i]]){// obj        
           obj[arr[i]]=1;
            newArr.push(arr[i]);
        }
    }
    return newArr;
}

2.4並べ替えを利用する

function unique(arr){
    arr.sort()//     
    let newArr = [];
    newArr[0] = arr[0];//               
    let len = arr.length;
    for(let i=1;iif(arr[i]!==newArr[newArr.length-1]){
		//                           
        //      push    
         	newArr.push(arr[i])
        }
    }
    return newArr;
}

深さクローンオブジェクト
配列が重いと書いてありますが、ついでに対象の深さをクローンしても書いてください.

function deepClone(origin,target){
	target = target || {};
    let toStr = Object.prototype.toString;//           
    let arrStr = '[object Array]';
    //    .toStr().call(  )       
    for(let prop in origin){
        if(origin.hasOwnProperty(prop)){
            //hasOwnProperty                  
            if(origin[prop]!='null'&&typeof(origin[prop]=='object')){
                //typeof(  /obj)     “object”
                if(toStr.call(origin[prop])==arrStr){
                    target[prop] = []
                }else{
                    target[prop] = {}
                }
                // typeof      object ，        
                deepClone(origin[prop],target[prop]);
            }else{
				target[prop] = origin[prop]
            }
            
        }
    }
    
}

おわりに
本人のレベルが限られていますので、もし間違いがあったら、担当者によろしくお願いします.
著者のホーチ武さんは2019/6/05午前1時半に書いています.
上手に書けたら、いいね!