數組的扁平化、排序、隨機亂序、去重、並集、交集、差集

是否爲數組？
Array.isArray(arr)，不用typeof(arr爲Object)；

傳統：Object.prototype.toString.call(arr)=="[object Array]"；
Array類型的Array.toString()是Object基礎類的封裝方法；

深淺克隆

基本類型值：number、string、boolean、undefined；
“==“，”===”比較時，是否值相等；

引用類型值：functioin、object、array、RegExp；
“==“，”===”比較時，是否爲同對象；

null爲基本類型值，但是typeof爲object，歸類存爭議；null === null 爲true；

賦值引用：var a = arr1; var b = arr1; a==b==true
淺克隆：var newArr = [].concat(arr)；var newArr = [...arr]
深克隆：遞歸

JS Array
arr.push()/unshift() 返回數組長度，新增到末尾/開頭；
arr.pop()/shift() 返回被刪的元素，刪除末尾/開頭；
arr.splice(startIndex,length,addArr,…addArr) 剪/接/替換，返回被刪數組；
indexOf(obj,startIndex) 從頭向尾查；
lastIndexOf(obj,startIndex) 從尾向頭查，找不到時，返回-1；
arr.slice(startIndex,endIndex) 剪切返回被切數組，原數組不變；
arr1.concat(arr2,arr3) 拼接；
arr.toString() 默認逗號隔開字符串；
arr.join("+") 指定連接符隔開轉字符串；
arr.reverse() 倒序/反轉，返回改變數組；
arr.sort() 按規則排序；

扁平化

多層嵌套數組的扁平化，例如[1,2,3,[4,[5,6,7],8],9]=>[1,2,3,4,5,6,7,8,9];
遞歸遍歷數組，concat合併數組；關鍵在於遍歷數組；

1. arr.some()
   Arr.some(fo(item,index,arr),callback)數組遍歷每一項傳入fo()，item傳入回調函數；
   如果有一個元素滿足條件，則返回布爾值true（剩餘的元素不會再執行檢測）；

function flatten(arr){
	//while循環，內部子項有數組，擴展運算符展開concat合併，繼續arr進行while循環
	while(arr.some(item=>Array.isArray(item))){
		arr = [].concat(...arr);
	}
	return arr;
}
flatten([1,2,[3,4]])//[1,2,3,4]

2. arr.map()
   Arr.map(fo(item,index,arr),callback)數組遍歷每一項傳入fo()，item傳入回調函數；
   返回新數組，（遍歷所有項）；

function flatten(arr){
	var res = [];
	//遍歷
	arr.map(item=>{
		if(Array.isArray(item){
			//遞歸
			res.res.concat(flatten(item));
		}else{
			//推入新數組
			res.push(item);
		})
	})
	return res;
}
flatten([1,2,[3,4]])//[1,2,3,4]

3. arr.reduce()
   Arr.map(fo(result,item,index,arr),initValue)回調函數fo()，result初始值爲initValue；
   同樣可以遍歷數組，concat合併數組；

function flatten(arr){
	return arr.reduce((result, item)=>{
		//遞歸
		return result.concat(Array.isArray(item)?flatten(item):item);
	},[])
}

4. 轉爲字符串分割
   arr.join(",").split(",").map()；
   arr.toString().split(",").map()；

5. for循環+遞歸

排序

arr.sort()排序數組，按照首字符以0-9A-Za-z排列，特殊符號除外；
arr.reverse()反轉數組，同上規則反轉排列；

1. 冒泡排序
   for嵌套，相鄰比較，交換位置，(注意判斷交換的條件，先末尾的排好)

//比較幾輪
for(let i=0;i<len-1;i++){
	//每輪幾次
	for(let j=0;j<len-i-1;j++){
		//arr[j]和arr[j+1]比較
	}
}

2. 選擇排序
   for嵌套，序位選出，(先開頭的排好)

//比較幾輪
for(let i=0;i<len-1;i++){
	//每輪幾次
	for(let j=i+1;j<len-1;j++){
		//arr[i]和arr[j]比較
	}
}

3. 快速排序：二分法
   取中間值，一分爲二，遞歸二分爲四，直到不能分

function fo(arr){
	//最後停止遞歸循環
	if(arr.length<=1){
		return arr;
	}
	
	let leftArr = [];
	let rightArr = [];
	let mid = arr.splice(Math.floor(arr.lenght/2),1)
	for(var i=0;i<arr.length;i++){
		if(arr[i]<=mid){
			leftArr.push(arr[i])
		}else{
			rightArr.push(arr[i])
		}
	}
	//遞歸 繼續二分
	return fo(leftArr).concat(mid,fo(rightArr));
}

隨機亂序

本質：數組下標的隨機；隨機刪除一個推進新數組，遞歸；

去重

JavaScript 高性能數組去重
只是整數數組類型，不可全拿，必要情況之下，依賴實測決定方案；
本質：遍歷數組;

1. arr.filter()/for(of)/arr.forEach()+indexOf()/includes()
   arr.filter(fo(currentValue,index,arr), thisValue)通過fo()返回布爾值，過濾；
   for(of)循環，不重複項推進新數組；

	let newArr = [];
	for(let i of arr){
		!newArr.includes(i) && newArr.push(i);
	}
	return newArr;

2. for(i)嵌套
   冒泡查詢，刪除重複性；

	//for循環
	for(let i=0,len=arr.length;i<len;i++){
		for(let j=i+1;j<len;j++){
			if(arr[i] == arr[j]){
				arr.splice(j,1);
				j--;
				len--;
			}
		}
	}
	return arr;

3. arr.sort()
   排序後，遍歷去重
4. new Set()
   arr.from(new Set([...a,...b]))，根據new Set()並集的數據結構arr.from()創建數組，(自動去重)
5. for(of)+Object
   利用自定義對象的屬性，標記重複性；
   結束後釋放內存，垃圾回收機制；

	let newArr = []
	let obj = {}
	for(let i of arr){
		if(!obj[i]){
			//標記已存在
			obj[i] = true;
			newArr.push(i);
		}
	}

並集、交集，差集

new Set(arr1,arr2) (去重的)並集，

new Set([...arr1].filter(i => b.has(i)); 交集

new Set([...arr1].filter( i=> !b.has(i))); 差集