知識の図9に示すように、フロントエンド - 再まとめ

まず、使用ES6セットの重複排除（ES6が最も一般的に使用されます）

1  // 重複排除列
2 LET STR = "12qwe345671dsfa233dsf9876ds243dsaljhkjfzxcxzvdsf" ;
 3 =（ ""）str.split LETアレイ   // 最初の文字列配列に変換する
。4  にconsole.log（アレイ）
 5。はconsole.log（配列。 （から新しい新しいセット（アレイ）））
 。6はconsole.log（Array.from（新しい新しいセット（アレイ））。参加（ '' ））
 。7  
。8  関数uniqueStr（STR）{
 9      LETのstr.splitのARR =（ '' ）
 10      LET arrNew = Array.from（新新セット（ARR））
 。11      リターン arrNew.join（ '' ）
 12れます }
 13  にconsole.log（uniqueStr（STR））
 14  // 12qwe34567dsfa98ljhkzxcv 
15  
16  // 去重数组
17  VAR = [1,1、 '真' '真'、ARR 真の、真の、15,15、偽、偽未定義未定義、NULL、NULLは、NaN、NaNで、 'のNaN'、0、0、 ''、 '' 、{}、{}]。
18  関数uniqueArr（ARR）{
 19      LET arrNew = Array.from（新しいセット（ARR））
 20      リターンarrNew
 21  }
 22  はconsole.log（uniqueArr（ARR））
 23 // 返回：[NaNで、NULL、15、TRUE、FALSE、未定義、1、 "真"、 "NaNに"、0、 "A"、{}、{}]

最小重量に、このメソッドのコードの互換性を考慮していません。この方法は、「{}」空のオブジェクトを削除しないことができ、後者の方法は、重複を除去するために、「{}」方法高次付加します。

 

第二に、営巣のために使用するために、再度スプライスに（最も一般的に使用されるES5）

1つの VAR ARR = [1,1、 '真'、 '真'、真の、真の、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNで、 'のNaN'、0,0 ' 」、 '' 、{}、{}]。
2  関数固有の（ARR）{
 3      用（VAR iが++; iはarr.lengthを<I = 0 ）{
 4          用（VARの J = I + 1、J <arr.length; J ++ ）{
 5              であれば（ARR [I] === ARR [J]）{
 6                  arr.splice（J、1 ）
 7              }
 8         }
 。9      }
 10      リターンARR
 。11  }
 12である にconsole.log（UNIQUE（ARR））
 13である 。// 戻り値：、 "真" [1、 15、TRUE、FALSE、未定義、ヌルは、NaN、NaNに、 "NaNに"、0 、 "A"、{}、 {}]、 NaNで2つずつが} {削除しませんでした

二重ループは、外側ループ素子、インナーループ比較値。値が同じで、この値が省略されています。

 

第三に、使用のindexOf重複除外

1つの VAR ARR = [1,1、 '真'、 '真'、真の、真の、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNで、 'のNaN'、0,0 ' 」、 '' 、{}、{}]。
2  関数固有の（ARR）{
 3      であれば（！Array.isArray（ARR））{
 4          はconsole.log（ 'タイプエラー' ）
 5          リターン
6      }
 7      = LET配列[]
 8      用（VAR i = 0; iは<ARR .LENGTH; iが++ ）{
 9         もし（Array.indexOf（ARR [I]）=== -1 ）{//これがため-1？？
10              のArray.push（ARR [I]）  
 11。        }
 12れる     }
 13が     リターンアレイ;
 14  }
 15  はconsole.log（UNIQUE（ARR））
 16  // 戻り値：[1、 "真の"真、15、偽、不定、ヌルは、NaN、NaNに、 " NaNに"、0、 "A"、{}、{}]、 NaNで2つずつが} {削除しませんでした

同じ値がスキップされる場合は、空の結果の配列を作成し、元のループ、現在の要素の配列が存在するか否かの判定結果のアレイに対して、同じアレイに押しません。

第四に、使用するソート

1つの VAR ARR = [1,1、 '真'、 '真'、真の、真の、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNで、 'のNaN'、0,0 ' 」、 '' 、{}、{}]。
2  関数固有の（ARR）{
 3      であれば（！Array.isArray（ARR））{
 4          はconsole.log（ 'タイプエラー' ）
 5          リターン
6      }
 7      ARR = arr.sort（）
 8      VARの配列= [ARR [0 ] ]
 9  
10      用（VARI = 1; 私はarr.lengthを<; 私は++ ）{
 11の         場合（ARR [I]！== ARR [I-1 ]）{
 12              のArray.push（ARR [I]）
 13          }
 14      }
 15      リターンアレイ
 16  }
 17  はconsole.log（ユニーク（ARR））
 18  // 返回值：（14）[0、1、15、NaNには、NaN、 "NaNに"、{...}、{...}、 "A"、FALSE、NULL、 "真"、真未定義]

使用してsort()ソート方法を、次に隣接ソートの結果に応じて元素比を横切ります。

 

第五に、オブジェクトの同じプロパティの使用はできませんデエンファシス特性（問題の配列方法にかかる重量、推奨されない、向上させること）

関数固有の（ARR）{
   場合（！{Array.isArray（ARR））
    はconsole.log（ 'タイプのエラー！' ）
     リターン
  } 
  VARの arrry = [];
   VAR OBJ = {};
  用（VAR i = 0; I <arr.length; iは++ ）{
     場合（！OBJ [ARR [I]]）{ 
      arrry.push（ARR [i]）と
      OBJ [ARR [I] = 1 
    } 他{ 
      OBJ [ARR [I]] ++ 
    } 
  } 
  戻りarrry。
} 
VARの ARR = [1,1、 '真' '真'、真、Trueに、15、15、falseに、falseに、未定義の未定義、NULL、NULL、 'のNaN 3'、0、0、 'A'、 'A'、のNaN 3、NaN 3を、{}、{}]; 
（にconsole.log UNIQUE（ARR））
// [1、 "真"、15、falseに、未定義、ヌルは、NaN、0、 "A"、{...}] //真2を直接除去は、NaN}及び{重複排除

 

第六に、使用は、

関数固有の（ARR）{ 
  IF（Array.isArray（ARR）！）{ 
    にconsole.log（ 'タイプのエラー！'）
    リターン
  } 
  VARアレイ= []; 
  用（VAR i = 0; I <arr.length; iは++）{ 
      場合{//が含ま检测数组是否有某个值（array.includes（[I]）ARR！）
          のArray.push（ARR [I]）。
       } 
  } 
  戻りアレイ
} 
VARのARR = [1,1、 '真'、 '真の'真の、真の、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNの'NaNに' 0 、0、 'A'、 ''、{}、{}]。
console.log（ユニーク（ARR））
// [15、偽、未定義、ヌルは、NaN、1、 "真の"真"のNaN"、0、 "A"、{...}、{...}] // {}没有去重

七、hasOwnPropertyを使用　　

関数固有の（ARR）{ 
  VARのOBJ = {}; 
  （{関数（項目、インデックス、ARR）arr.filter返す
    ：（OBJ [typeof演算項目+アイテム] TRUE）= obj.hasOwnProperty（typeof演算項目+アイテム）を返し偽？
  }）
} 
「、VARをARR = [1,1真、」、 ''、真の、真の、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNで、 '真のNaN'、0、0、 ''、 ''、{} {}]。
console.log（）ARR（一意）
// [1、 "真の"真、15、偽、未定義、ヌルは、NaN、 "NaNに"、0、 "A"、{...}] //所有的都去重了

　　使用して、hasOwnProperty オブジェクトのプロパティがあるか否かを判断します

八、フィルタの使用

固有の機能（ARR）{ 
 戻りarr.filter（関数（項目、指標、ARR）{ 
  //現在の要素、元の配列の最初のインデックス==現在のインデックス値、そうでなければ現在の要素が
  arr.indexOfを返す（項目、0）===指数; 
 }）; 
} 
VARのARR = [1,1、 '真の'、 '真の' trueに、真、15、15、falseに、偽未定義未定義、NULL、NULLに、NaN 3を、 NaN 3を、 'のNaN 3'、0、0、 'A'、 'A'、{}、{}]; 
はconsole.log（UNIQUE（ARR））
// [1、 "真の"、trueに、15、falseに、未定義。 、NULL、 "NaNの" 0 、 "A"、{...}、{...}]

 

再帰を多用するナイン、

関数固有の（ARR）{ 
    VAR配列= ARR。
    VAR LEN = Array.lengthと。
  Array.sort（関数（B）{//排序后更加方便去重
    返す- B; 
  }）
  関数ループ（インデックス）{ 
    IF（インデックス> = 1）{ 
      IF（配列[インデックス]を===アレイ[インデックス-1]）{ 
        array.splice（インデックス1）。
      } 
      ループ（インデックス- 1）。//递归ループ、然后数组去重
    } 
  } 
  ループ（LEN-1）。
  配列を返します。
} 
VARのARR = [1,1、 '真'、 '真の'真の、真の、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNに'のNaN'、0,0 ' 」、 ''、{}、{}]。
console.log（ユニーク（ARR））
// [1、 "A"、 "真"、1、15、TRUE、FALSE、{...}、ヌルは、NaN、NaNに、「

重複排除機能を使用してX.マップデータ構造

機能arrayNonRepeatfy（ARR）{ 
 マップは=新しいMap（ましょう）。
 せ配列=新しいアレイ（）; //数组用于返回结果
 ため（LET I = 0; iが<arr.length; iは++）{ 
  IF（マップ.has（ARR [I]））{//有如果キー该值
   マップ.SET（ARR [I ]、TRUE）。
  }他{ 
   マップ.SET（ARR [i]は、偽）。//如果没有キー值该
   アレイ.push（ARR [I]）。
  } 
 } 
 の配列を返します。
} 
VARのARR = [1,1、 '真'、 '真の'真の、真の、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNに'のNaN'、0,0 ' 」、 ''、{}、{}]。
console.log（ユニーク（ARR））
// [1、 "A"、 "真"、1、15、TRUE、FALSE {...}、ヌルは、NaN、NaNに、 "NaNに"、0、 "A"、 {...}、不定]

マップに格納されたキーに配列の各要素に、重にアレイを横断するのに必要な空のマップデータ構造を作成します。同じキーと値の地図が表示されないので、最終的な結果ので、デエンファシスの結果です。

 

XI +減らす含み、使用して

関数固有の（ARR）{ 
  戻りarr.reduce（（PREV、CUR）=> prev.includes（CUR）PREV：[... PREV、CUR]、[]）。
} 
VARのARR = [1,1、 '真'、 '真の'真の、真の、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNに'のNaN'、0,0 ' 」、 ''、{}、{}]。
console.log（）ARR（ユニーク）。
// [NaNで、NULL、15、TRUE、FALSE、未定義、1、 "真"、 "NaNに"、0、 "A"、{...}、{...}]