重量法を達成するために、JavaScriptの配列

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

関数固有の（ARR）{
   戻り Array.from（新しいセット（ARR））
} 
VARを [1,1、 '真'、 '真' ARR = 真、真、15,15、偽、偽、不定、不定NULL、NULLは、NaN、NaNで、 'のNaN'、0、0、 ''、 '' 、{}、{}]。
console.log（ユニーク（ARR））
// [15、偽、未定義、ヌルは、NaN、1、 "真の"真"のNaN"、0、 "A"、{}、{}]

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

 

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

機能UNIQUE（ARR）を{            
     ため（VARの I = 0;私は<arr.length; Iは++ ）{
         ため（VARの J = I + 1、。J <arr.length; J ++ ）{
             IF（ARR [I] == ARR [ J]）{          // 第二に第1の等価、スプライス第2の方法削除 
                arr.spliceを（J ,. 1 ）; 
                J - ; 
            } 
        } 
    } 
  戻りARR; 
} 
VARの ARR = [1,1、 '真の''「真の、本当の、真の、15、15、falseに、falseに、未定義、未定義、ヌル、ヌル、NaN 3を、NaN 3を、 'のNaN 3'、0、0、 'A'、 'A' 、{}、{}]; 
はconsole.log（UNIQUE（ARR））
// [1、 "真の"、15、。偽、未定義の、NaN 3を、NaN 3をに、 "NaN 3を"、 "A"、{...}、{...}]      
// NaN 3を}と{重量は行かなかった、2つのヌルは直接消えます

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

 

  第三に、頻繁に使用するために使用するのindexOfは、

関数固有の（ARR）{
     場合（！{Array.isArray（ARR））
        はconsole.log（ 'タイプのエラー！' ）
         リターン
    } 
    VARの配列= [];
    用（VAR i = 0; I <arr.length; iは++ ）{
         場合（アレイ.indexOf（ARR [I]）=== -1）{     // NaNで、{}没有去重
       // もし（配列！。含む（ARR [I]））{// {}没有去重
            アレイ.push（ARR [I]）
        } 
    } 
    戻り値のアレイ; 
} 
VAR ARR = [1,1、 '真'、 '真の' 真の、真の、15,15偽、偽、未定義未定義NULL、NULLは、NaN、NaNで、 'のNaN'、0、0、 ''、 '' 、{}、{}]。
console.log（ユニーク（ARR））
// [1、 "真の"真、15、偽、未定義、ヌルは、NaN、NaNに、 "NaNに"、0、 "A"、{...}、{...}]   
// NaNで、{}没有去重

• • indexOf（）メソッドは、配列内の特定の要素を見つけるための最初のインデックスを返し、そうでない場合には-1を返します。

  • （）を含む方法は、そうでない場合は偽を返し、それがtrueを返すが含まれている場合、いくつかのケースでは、配列が指定された値を含むかどうかを決定するために使用されます。

　　どちらの方法でもまったく同じ考えを達成するため、最終的な結果はわずかに異なっています、

• • indexOfを達成した後、NaN 3を、{}は重い行きませんでした

  • 後の実装を含む、唯一{} 再ではありません　　

 

  第四に、使用するソート（）

機能のユニークな（ARR）{
     場合（！Array.isArray（ARR））{ 
        はconsole.log（ '！タイプエラー' ）
         のリターン; 
    } 
    ARR = arr.sort（）
     VaRの arrry = [0 [ARR ]。
    用（VAR I = 1; I <arr.length; iは++ ）{
         場合（ARR [i]を== ARR [I-1] ]）{ 
            arrry.push（ARR [I]）。
        } 
    } 
    戻りarrry。
} 
VARの ARR = [1,1、 '真' '真'、真の、真の、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNで、 'のNaN'、0、0、 ''、 '' 、{}、{}]。
console.log（ユニーク（ARR））
// [0、1、15、 "NaNの"は、NaN、NaNで、{...}、{...}、 "A"、FALSE、NULL、真、 "真"、不定]      
// NaNで、{}没有去重

　　ソートを使用して（）メソッドをソートし、次にソート隣接の結果に応じて元素比を横切ります。

 

  第五に、オブジェクトの同じプロパティの使用は、デエンファシス特性（そのようなアレイの重複排除方法はまだ完璧ではない）にすることはできません

関数固有の（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、 '真の'、 '真の' 真の、真の、15、15、falseに、falseに、未定義の未定義、NULL、NULL、のNaN 3、NaN 3を、 'のNaN 3'、0、0、 'A' 、 'A' 、{}、{}]; 
はconsole.log（UNIQUE（ARR））
// [1、 "真の"、15、falseに、未定義、ヌル、NaN 3を、0、 "A"、{...}]。     
// 二つの真の直接除去は、NaN、および{}

 

  第六に、hasOwnPropertyをを使用

関数固有の（ARR）{
     VARの OBJ = {};
    戻り（arr.filter 関数{（項目、インデックス、ARR）
         を返す obj.hasOwnProperty（typeof演算項目+アイテム）？偽（OBJ [ typeof演算項目+アイテムは] = 真）
    }）
} 
VARを「、ARR = [1,1真」、 ''、真の真の、真の、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNで、 'のNaN'、0、0、 ''、 '' 、{} {}]。
console.log（）ARR（ユニーク）
//[偽未定義、ヌル、NaN 3をに、 "NaN 3を"、0、 "A"、{...} 15、trueに、 "真の"。1、、]    
//はすべてが重い行きます

　　これは、プロパティを使用して、オブジェクトが存在するか否かを判断するhasOwnPropertyを

 

  七、フィルタの使用

機能UNIQUE（ARR）{
   戻り arr.filter（関数（項目、指標、ARR）{
     // 現在の要素、元の配列==現在のインデックス値の最初のインデックスを、そうでなければ現在の要素が
    戻り arr.indexOfを（項目、0）=== 指数; 
  }）; 
} 
VARの ARR = [1,1、 '真の'、 '真の' 真の、真の、15、15、falseに、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"、{...}、{...}]

 

  八、再帰を多用します

機能UNIQUE（ARR）{
     VARの配列= ARRと、
     VaRの LEN = Array.lengthとすること; 
    のArray.sort（関数（A、B）は、{    //は再が容易にソート
        戻り - B; 
    }）
    関数ループ（インデックス）{
         IF（インデックス> = 1 ）{
             IF（配列[インデックス] ===配列[index- 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に、 "NaNに"、0、 "A"、 {...}、不定]

 

  地図データ構造の重複排除機能を使用してナイン、

関数arrayNonRepeatfy（ARR）は{ 
  地図せ = 新しい新しいマップ（）; 
  LET配列 = 新しい新しいアレイ（）;   // 配列の結果を返す
  ために（; I <arr.length I ++はLET I = 0 ）{
     IF（マップ.has （ARR [I]））{   // キー値であれば 
      マップ.SET（ARR [I]、真の）; 
    } そうでなければ{ 
      マップ.SET（ARR [I]、偽に）;    // キー値がない場合
      、配列.push（ARR [I]）; 
    } 
  } 
  戻り、アレイ
} 
VARの ARR = [1,1、 '真の'、 '真の' trueに、真、15,15、偽、偽、不定、不定、NULL、NULLは、NaN、NaNで、 'のNaN'、0、0、 ''、 '' 、{}、{}]。
console.log（ユニーク（ARR））
// [1、 "A"、 "真"、1、15、TRUE、FALSE {...}、ヌルは、NaN、NaNに、 "NaNに"、0、 "A"、 {...}、不定]

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

 

  テン、+減らすには、の使用を含みます

関数固有の（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"、{...}、{...}]

　　参考ブログ：ヘビーにJavaScript配列（メソッドの12種類の、最も完全な履歴）：https://segmentfault.com/a/1190000016418021