資訊專欄INFORMATION COLUMN
摘要：利用將結構轉換成數組拓展運算符內部使用循環拓展，合并數組之后去重第種方法將傳入的數組或非數組值與原數組合并組成一個新的數組并返回。該方法會產生一個新的數組再引用上面的任意一個去重方法第種。
1.第1種
雙層循環，外層循環元素，內層循環時比較值,如果有相同的值則跳過，不相同則push進數組
Array.prototype.distinct = function(){
var arr = this,
result = [],
i,
j,
len = arr.length;
for(i = 0; i < len; i++){
for(j = i + 1; j < len; j++){
if(arr[i] === arr[j]){
j = ++i;
}
}
result.push(arr[i]);
}
return result;
}
var arra = [1,2,3,4,4,1,1,2,1,1,1];
arra.distinct(); //返回[3,4,2,1]
2.第2種
優點：簡單易懂
缺點：占用內存高，速度慢
Array.prototype.distinct = function (){
var arr = this,
i,
j,
len = arr.length;
for(i = 0; i < len; i++){
for(j = i + 1; j < len; j++){
if(arr[i] == arr[j]){
arr.splice(j,1);
len--;
j--;
}
}
}
return arr;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b.toString()); //1,2,3,4,5,6,56
3.第3種
利用對象的屬性不能相同的特點進行去重
Array.prototype.distinct = function (){
var arr = this,
i,
obj = {},
result = [],
len = arr.length;
for(i = 0; i< arr.length; i++){
if(!obj[arr[i]]){ //如果能查找到，證明數組元素重復了
obj[arr[i]] = 1;
result.push(arr[i]);
}
}
return result;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b.toString()); //1,2,3,4,5,6,56
4.第4種
運用遞歸的思想
先排序，然后從最后開始比較，遇到相同，則刪除
Array.prototype.distinct = function (){
var arr = this,
len = arr.length;
arr.sort(function(a,b){ //對數組進行排序才能方便比較
return a - b;
})
function loop(index){
if(index >= 1){
if(arr[index] === arr[index-1]){
arr.splice(index,1);
}
loop(index - 1); //遞歸loop函數進行去重
}
}
loop(len-1);
return arr;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,56,45,56];
var b = a.distinct();
console.log(b.toString()); //1,2,3,4,5,6,45,56
5.第5種
Array.prototype.distinct = function (){
var arr = this,
result = [],
len = arr.length;
arr.forEach(function(v, i ,arr){ //這里利用map，filter方法也可以實現
var bool = arr.indexOf(v,i+1); //從傳入參數的下一個索引值開始尋找是否存在重復
if(bool === -1){
result.push(v);
}
})
return result;
};
var a = [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,3,2,3,3,2,2,1,23,1,23,2,3,2,3,2,3];
var b = a.distinct();
console.log(b.toString()); //1,23,2,3Array.prototype.distin
6.第6種
Set數據結構，它類似于數組，其成員的值都是唯一的。
利用Array.from將Set結構轉換成數組
function dedupe(array){
return Array.from(new Set(array));
}
dedupe([1,1,2,3]) //[1,2,3]
拓展運算符(...)內部使用for...of循環
let arr = [1,2,3,3]; let resultarr = [...new Set(arr)]; console.log(resultarr); //[1,2,3]拓展，合并數組之后去重 1.第1種
concat() 方法將傳入的數組或非數組值與原數組合并,組成一個新的數組并返回。該方法會產生一個新的數組
function concatArr(arr1, arr2){
var arr = arr1.concat(arr2);
arr = unique1(arr);//再引用上面的任意一個去重方法
return arr;
}
2.第2種
Array.prototype.push.apply()。
該方法優點是不會產生一個新的數組。
var a = [1, 2, 3];
var b = [4, 5, 6];
Array.prototype.push.apply(a, b);//a=[1,2,3,4,5,6]
//等效于:a.push.apply(a, b);
//也等效于[].push.apply(a, b);
function concatArray(arr1,arr2){
Array.prototype.push.apply(arr1, arr2);
arr1 = unique1(arr1);
return arr1;
}
文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。
轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/97080.html
摘要：數組去重第一種方法先對數組進行排序，排好序，然后把數組的當前項和后一項進行比較，相同則使用數組的相同的位置，，但是為了防止數組塌陷，每次刪除數組元素的時候要把的值減一。 數組去重 第一種方法： 先對數組進行排序sort()，排好序，然后把數組的當前項和后一項進行比較，相同則使用數組的splice(相同的位置，1)，但是為了防止數組塌陷，每次刪除數組元素的時候要把i的值減一。 ...
摘要：雖然構造函數或者對象字面量的方法都可以用來創建對象，但是這些方法使用同一個接口創建很多對象，會產生大量的重復代碼。參考資料冴羽的專題系列中高級前端面試手寫代碼無敵秘籍前端筆試之手寫代碼一本系列會從面試的角度出發圍繞JavaScript，Node.js(npm包)以及框架三個方面來對常見的模擬實現進行總結，具體源代碼放在github項目上，長期更新和維護 showImg(https://use...
摘要：種常用數組去重第一種兩個循環思路新建一個為空的結果數組外層遍歷原數組，內層循環遍歷返回數組判斷內層循環數組當前元素和外層數組元素的值是否相等，是退出內層循環經過第二部后，此時內層循環數組的索引值和返回數組的長度正好相等，外層數組元素也是唯一 8 種常用數組去重 第一種 【兩個 for 循環】 思路： 新建一個為空的結果數組 外層 for 遍歷原數組，內層循環遍歷返回數組 判斷內層循環...
摘要：注方法可以返回某個指定字符串在字符串中首次出現的位置比如首次出現的位置是數組中的第一個，即下標為遍歷數組使用標識符去重聲明一個變量標識排序后遍歷過濾數組思路先給數組排序，這樣相同的項總是相鄰。 假設我們有數組arr，并且聲明新數組hash用來存放去重后的元素： var arr = [23,44,5,2,23,5,1,7,8,7]; //包含重復元素 var hash= [];...
閱讀 821·2019-08-30 14:05
閱讀 1712·2019-08-30 11:08
閱讀 3216·2019-08-29 15:41
閱讀 3591·2019-08-23 18:31
閱讀 1510·2019-08-23 18:29
閱讀 546·2019-08-23 14:51
閱讀 2103·2019-08-23 13:53
閱讀 2126·2019-08-23 13:02
