මට අද්විතීය සංඛ්‍යාවක් ඇති බවට සහතික කර ගත යුතු සංඛ්‍යා සමූහයක් මා සතුව ඇත. මම පහත දැක්වෙන කේත ස්නිපටය අන්තර්ජාලයේ සොයා ගත් අතර අරාවෙහි ශුන්‍යයක් ඇති වන තෙක් එය විශිෂ්ට ලෙස ක්‍රියා කරයි. මෙම අනෙක් ස්ක්‍රිප්ට් එක ස්ටැක් පිටාර ගැලීමෙන් මට හමු විය, එය හරියටම පාහේ පෙනේ, නමුත් එය අසාර්ථක නොවේ.

ඉතින් මට ඉගෙන ගැනීමට උදව් කිරීම සඳහා, මූලාකෘති පිටපත වැරදී ඇත්තේ කොතැනදැයි තීරණය කිරීමට මට උදව් කළ හැකිද?

Array.prototype.getUnique = function() {
 var o = {}, a = [], i, e;
 for (i = 0; e = this[i]; i++) {o[e] = 1};
 for (e in o) {a.push (e)};
 return a;
}

අනුපිටපත් ප්‍රශ්නයෙන් තවත් පිළිතුරු:

• JS අරාව වෙතින් අනුපිටපත් අගයන් ඉවත් කරන්න

සමාන ප්‍රශ්නය:

• සියලු අද්විතීය නොවන අගයන් (එනම්: අනුපිටපත් / එකකට වඩා වැඩි ගණනක්) අරාවකින් ලබා ගන්න

ජාවාස්ක්‍රිප්ට් 1.6 / ඊසීඑම්එස්ක්‍රිප්ට් 5 සමඟ ඔබටfilter අද්විතීය අගයන් සහිත අරාවක් ලබා ගැනීම සඳහා පහත දැක්වෙන ආකාරයෙන් අරාවෙහි ස්වදේශීය ක්‍රමය භාවිතා කළ හැකිය :

function onlyUnique(value, index, self) { 
    return self.indexOf(value) === index;
}

// usage example:
var a = ['a', 1, 'a', 2, '1'];
var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

ස්වදේශීය ක්‍රමය filterඅරාව හරහා ලූප වන අතර ලබා දී ඇති ඇමතුම් ආපසු ගැනීමේ ශ්‍රිතය පසු කරන ප්‍රවේශයන් පමණක් ඉතිරි වේ onlyUnique.

onlyUniqueපරික්ෂා කිරීම, දී ඇති අගය පළමු වරට සිදුවන්නේ නම්. එසේ නොවේ නම්, එය අනුපිටපතක් විය යුතු අතර එය පිටපත් නොකෙරේ.

මෙම විසඳුම jQuery හෝ prototype.js වැනි අමතර පුස්තකාලයක් නොමැතිව ක්‍රියා කරයි.

එය මිශ්‍ර වටිනාකම් සහිත අරා සඳහා ද ක්‍රියා කරයි.

දේශීය ක්රම සඳහා පහසුකම් සපයන්නේ නැත පැරණි වෙබ් බ්රව්සර (<ie9), සඳහා filterසහ indexOfඔබ වෙනුවෙන් MDN ලියකියවිලි වල වැඩ arounds සොයා ගත හැකි පෙරහන් හා indexOf .

ඔබ අගය පසුගිය සිදුවීමක් පවත්වා ගැනීමට ඔබට අවශ්ය නම්, සරල වෙනුවට indexOfවිසින් lastIndexOf.

ES6 සමඟ මෙය කෙටි කළ හැකිය:

// usage example:
var myArray = ['a', 1, 'a', 2, '1'];
var unique = myArray.filter((v, i, a) => a.indexOf(v) === i); 

// unique is ['a', 1, 2, '1']

අදහස් දැක්වීම ගැන කැමිලෝ මාටින්ට ස්තූතියි .

Setඅද්විතීය අගයන් ගබඩා කිරීම සඳහා ES6 හට ස්වදේශීය වස්තුවක් ඇත. අද්විතීය අගයන් සහිත අරාවක් ලබා ගැනීම සඳහා ඔබට දැන් මෙය කළ හැකිය:

var myArray = ['a', 1, 'a', 2, '1'];

let unique = [...new Set(myArray)]; 

// unique is ['a', 1, 2, '1']

යන ඉදිකිරීමටත් SetArray වැනි iterable වස්තුව, ගත වන අතර පැතිර ක්රියාකරු ...මාලාවක් බවට නැවත කට්ටලයක් පරිණාමනය කිරීම. අදහස් දැක්වීමේ ඉඟිය සඳහා ලූකස් ලයිස්ට ස්තූතියි .

ES6 / ES2015 සඳහා යාවත්කාලීන කළ පිළිතුර : කට්ටලය භාවිතා කරමින් තනි පේළි විසඳුම:

var items = [4,5,4,6,3,4,5,2,23,1,4,4,4]
var uniqueItems = Array.from(new Set(items))

කුමන ප්‍රතිලාභද

[4, 5, 6, 3, 2, 23, 1]

ලෙස le_m යෝජනා, මෙය භාවිතා කෙටි කළ හැකි පැතිර ක්රියාකරු , වැනි

var uniqueItems = [...new Set(items)]

හැකි විසඳුම් 4 කට මම සියලු පිළිතුරු බෙදුවෙමි:

1. { }අනුපිටපත් වැළැක්වීමට වස්තුව භාවිතා කරන්න
2. උපකාරක අරාව භාවිතා කරන්න [ ]
3. භාවිත filter + indexOf
4. පාරිතෝෂිකය! ES6 Setsක්‍රමය.

පිළිතුරු වලින් සොයාගත් නියැදි කේත මෙන්න:

{ }අනුපිටපත් වැළැක්වීමට වස්තුව භාවිතා කරන්න

function uniqueArray1( ar ) {
  var j = {};

  ar.forEach( function(v) {
    j[v+ '::' + typeof v] = v;
  });

  return Object.keys(j).map(function(v){
    return j[v];
  });
} 

උපකාරක අරාව භාවිතා කරන්න [ ]

function uniqueArray2(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

භාවිත filter + indexOf

function uniqueArray3(a) {
  function onlyUnique(value, index, self) { 
      return self.indexOf(value) === index;
  }

  // usage
  var unique = a.filter( onlyUnique ); // returns ['a', 1, 2, '1']

  return unique;
}

ES6 භාවිතා කරන්න [...new Set(a)]

function uniqueArray4(a) {
  return [...new Set(a)];
}

මම කල්පනා කළා කුමන එක වේගවත්ද කියලා. කාර්යයන් පරීක්ෂා කිරීම සඳහා මම නියැදිය ගූගල් ෂීට් සාදා ඇත. සටහන: ECMA 6 ගූගල් ෂීට් වල ලබා ගත නොහැක, එබැවින් මට එය පරීක්ෂා කළ නොහැක.

පරීක්ෂණවල ප්‍රති result ලය මෙන්න:

වස්තුව භාවිතා කරන කේතය { }හැෂ් භාවිතා කරන බැවින් එය ජය ගනු ඇතැයි මම අපේක්ෂා කළෙමි . එබැවින් ක්‍රෝම් සහ අයිඊ හි මෙම ඇල්ගොරිතම සඳහා හොඳම ප්‍රති results ල පරීක්ෂණ මගින් පෙන්වීම ගැන මම සතුටු වෙමි. කේතය සඳහා @rab ට ස්තූතියි .

යාවත්කාලීන කිරීම 2020

ගූගල් ස්ක්‍රිප්ට් ES6 එන්ජිම සක්‍රීය කර ඇත. දැන් මම අවසාන කේතය පරීක්ෂා කළ Setsඅතර එය වස්තු ක්‍රමයට වඩා වේගයෙන් දර්ශනය විය.

ඔබට underscore.js ද භාවිතා කළ හැකිය .

console.log(_.uniq([1, 2, 1, 3, 1, 4]));

<script src="http://underscorejs.org/underscore-min.js"></script>

එය නැවත පැමිණේ:

[1, 2, 3, 4]

එක් ලයිනර්, පිරිසිදු ජාවාස්ක්‍රිප්ට්

ES6 සින්ටැක්ස් සමඟ

list = list.filter((x, i, a) => a.indexOf(x) == i)

x --> item in array
i --> index of item
a --> array reference, (in this case "list")

ES5 සින්ටැක්ස් සමඟ

list = list.filter(function (x, i, a) { 
    return a.indexOf(x) == i; 
});

බ්‍රව්සර් අනුකූලතාව : IE9 +

මම එතැන් සිට jQuery භාවිතා කරන හොඳ ක්‍රමයක් සොයාගෙන ඇත

arr = $.grep(arr, function(v, k){
    return $.inArray(v ,arr) === k;
});

සටහන: මෙම කේතය පෝල් අයිරිෂ්ගේ තාරා පන්ච් පෝස්ට් එකෙන් ඇද ගන්නා ලදි - මට ණය දීමට අමතක විය: පී

ES6 සමඟ කෙටිම විසඳුම: [...new Set( [1, 1, 2] )];

හෝ ඔබට අරේ මූලාකෘතිය වෙනස් කිරීමට අවශ්‍ය නම් (මුල් ප්‍රශ්නයේදී මෙන්):

Array.prototype.getUnique = function() {
    return [...new Set( [this] )];
};

EcmaScript 6 නවීන බ්‍රව්සර්වල මේ මොහොතේ (2015 අගෝස්තු) අර්ධ වශයෙන් පමණක් ක්‍රියාත්මක වන නමුත් ES6 (සහ ES7 පවා) නැවත ES5 වෙත ප්‍රවාහනය කිරීම සඳහා බාබෙල් ඉතා ජනප්‍රිය වී තිබේ. ඒ ආකාරයෙන් ඔබට අද ES6 කේතය ලිවිය හැකිය!

එහි ...තේරුම කුමක්දැයි ඔබ කල්පනා කරන්නේ නම්, එය පැතිරීමේ ක්‍රියාකරු ලෙස හැඳින්වේ . එම්ඩීඑන් වෙතින් : multiple බහු තර්ක (ක්‍රියාකාරී ඇමතුම් සඳහා) හෝ බහු මූලද්‍රව්‍ය (අරා වචනාර්ථ සඳහා) අපේක්ෂා කරන ස්ථානවල ප්‍රකාශනය පුළුල් කිරීමට පැතිරීමේ ක්‍රියාකරු ඉඩ දෙයි ». කට්ටලයක් නැවත ක්‍රියාත්මක කළ හැකි නිසා (සහ අද්විතීය අගයන් පමණක් තිබිය හැක), පැතිරීමේ ක්‍රියාකරු අරාව පිරවීම සඳහා කට්ටලය පුළුල් කරයි.

ES6 ඉගෙනීම සඳහා සම්පත්:

• ආචාර්ය ඇක්සෙල් රවුෂ්මයර් විසින් ES6 ගවේෂණය කිරීම
• JS සතිපතා පුවත් පත්‍රිකා වලින් “ES6” සොයන්න
• මොසිල්ලා හැක්ස් බ්ලොග් අඩවියෙන් ගැඹුරු ලිපිවල ES6

සරලම විසඳුම:

var arr = [1, 3, 4, 1, 2, 1, 3, 3, 4, 1];
console.log([...new Set(arr)]);

හෝ:

var arr = [1, 3, 4, 1, 2, 1, 3, 3, 4, 1];
console.log(Array.from(new Set(arr)));

මෙය කළ හැකි සරලම හා වේගවත්ම (ක්‍රෝම් භාෂාවෙන්):

Array.prototype.unique = function() {
    var a = [];
    for (var i=0, l=this.length; i<l; i++)
        if (a.indexOf(this[i]) === -1)
            a.push(this[i]);
    return a;
}

අරාවෙහි ඇති සෑම අයිතමයක් හරහාම සරලවම ගමන් කරයි, එම අයිතමය දැනටමත් ලැයිස්තුවේ තිබේදැයි පරීක්ෂා කරයි, එය එසේ නොවේ නම්, ආපසු ලැබෙන අරාව වෙත තල්ලු කරන්න.

JsPerf ට අනුව, මෙම ශ්‍රිතය මට ඕනෑම තැනක සොයාගත හැකි වේගවත්ම වේ - ඔබේම දෑ එකතු කිරීමට නිදහස් වන්න.

මූලාකෘති නොවන අනුවාදය:

function uniques(arr) {
    var a = [];
    for (var i=0, l=arr.length; i<l; i++)
        if (a.indexOf(arr[i]) === -1 && arr[i] !== '')
            a.push(arr[i]);
    return a;
}

වර්ග කිරීම

අරාව වර්ග කිරීමට අවශ්‍ය වූ විට, පහත දැක්වෙන්නේ වේගවත්ම ය:

Array.prototype.sortUnique = function() {
    this.sort();
    var last_i;
    for (var i=0;i<this.length;i++)
        if ((last_i = this.lastIndexOf(this[i])) !== i)
            this.splice(i+1, last_i-i);
    return this;
}

හෝ මූලාකෘති නොවන:

function sortUnique(arr) {
    arr.sort();
    var last_i;
    for (var i=0;i<arr.length;i++)
        if ((last_i = arr.lastIndexOf(arr[i])) !== i)
            arr.splice(i+1, last_i-i);
    return arr;
}

මෙය බොහෝ ක්‍රෝම් නොවන බ්‍රව්සර්වල ඉහත ක්‍රමයට වඩා වේගවත් වේ .

කාර්ය සාධනය පමණක්! මෙම කේතය මෙහි ඇති සියලුම කේත වලට වඩා 10X වේගවත් වේ * සියලුම බ්‍රව්සර්වල ක්‍රියා කරන අතර අවම මතක බලපෑමක් ඇති කරයි .... සහ තවත්

ඔබට පැරණි අරාව නැවත භාවිතා කිරීමට අවශ්‍ය නොවන්නේ නම්, btw ඔබ එය අද්විතීය බවට පරිවර්තනය කිරීමට පෙර අවශ්‍ය වෙනත් මෙහෙයුම් සිදු කරන්න මෙය බොහෝ විට වේගවත්ම ක්‍රමය වන අතර එය ඉතා කෙටි වේ.

var array=[1,2,3,4,5,6,7,8,9,0,1,2,1];

එවිට ඔබට මෙය උත්සාහ කළ හැකිය

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 1];

function toUnique(a, b, c) { //array,placeholder,placeholder
  b = a.length;
  while (c = --b)
    while (c--) a[b] !== a[c] || a.splice(c, 1);
  return a // not needed ;)
}
console.log(toUnique(array));
//[3, 4, 5, 6, 7, 8, 9, 0, 2, 1]

මම මෙම ලිපිය කියවමින් මෙම ලිපිය කියවමි ...

http://www.shamasis.net/2009/09/fast-algorithm-to-find-unique-items-in-javascript-array/

මම ලූපයට කැමති නැහැ. එයට බොහෝ පරාමිතීන් ඇත. අප සැවොම කැමති ක්‍රෝම් හැර අනෙක් සියලුම බ්‍රව්සර්වල වේගවත්ම ලූපය වන අතර

කෙසේ වෙතත් මම භාවිතා කරන පළමු ශ්‍රිතය ලිවීය. ඔව් එය ලිපියේ ඇති ශ්‍රිතයට වඩා ටිකක් වේගවත්ය.නමුත් එය ප්‍රමාණවත් නොවේ.unique2()

ඊළඟ පියවර නවීන js භාවිතා කරන්න. Object.keys මම අනෙක් ලූපය js1.7 හි Object.keys සමඟ ආදේශ කළෙමි ... ටිකක් වේගවත් හා කෙටි (ක්‍රෝම් 2x වේගයෙන්);). මදි!. unique3().

මේ අවස්ථාවේදී මම කල්පනා කරමින් සිටියේ මගේ අද්විතීය ක්‍රියාකාරිත්වයේ ඇත්ත වශයෙන්ම මට අවශ්‍ය දේ ගැන ය. මට පැරණි අරාව අවශ්‍ය නැත, මට වේගවත් ශ්‍රිතයක් අවශ්‍යය. ඒ නිසා මම ලූප් + ස්ප්ලයිස් අතර 2 ක් භාවිතා කළෙමි.unique4()

මා පුදුමයට පත් වූ බව කීම නිෂ් less ල ය.

ක්‍රෝම්: සුපුරුදු පරිදි තත්පරයට මෙහෙයුම් 150,000 ක් තත්පරයට මෙහෙයුම් 1800 ක් දක්වා ඉහළ ගියේය.

එනම්: 80,000 op / s එදිරිව 3,500,000 op / s

ios: 18,000 op / s vs 170,000 op / s

සෆාරි: 80,000 op / s vs 6,000,000 op / s

සාධනය http://jsperf.com/wgu හෝ වඩා හොඳින් භාවිතා කරන්න console.time ... මයික්‍රෝ ටයිම් ... ඕනෑම දෙයක්

unique5() ඔබට පරණ අරාව තබා ගැනීමට අවශ්‍ය නම් කුමක් සිදුවේද යන්න පෙන්වීමට පමණි.

ඔබ Array.prototypeකරන්නේ කුමක්දැයි ඔබ නොදන්නේ නම් භාවිතා නොකරන්න . මම පිටපත් හා අතීතය වෙනස් කළා. Object.defineProperty(Array.prototype,...,writable:false,enumerable:false})ඔබට ස්වදේශීය මූලාකෘතියක් සෑදීමට අවශ්‍ය නම් භාවිතා කරන්න. උදාහරණය: https://stackoverflow.com/a/20463021/2450730

ආදර්ශනය http://jsfiddle.net/46S7g/

සටහන: මෙම මෙහෙයුමෙන් පසු ඔබගේ පැරණි අරාව විනාශ වී ඇත / බවට පත්වේ.

ඔබට ඉහත කේතය කියවීමට නොහැකි නම්, ජාවාස්ක්‍රිප්ට් පොතක් කියවන්න හෝ කෙටි කේතය පිළිබඳ පැහැදිලි කිරීම් කිහිපයක් මෙන්න. https://stackoverflow.com/a/21353032/2450730

සමහරු භාවිතා කරති indexOf ... එපා ... http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

හිස් අරා සඳහා

!array.length||toUnique(array); 

මෙහි බොහෝ පිළිතුරු ආරම්භකයින්ට ප්‍රයෝජනවත් නොවනු ඇත. අරාව අක්‍රීය කිරීම දුෂ්කර නම්, ඔවුන් සැබවින්ම මූලාකෘති දාමය ගැන හෝ jQuery ගැන දැනගනීවිද?

නවීන බ්රවුසර, පිරිසිදු කිරීම හා සරල විසඳුමක් දී දත්ත ගබඩා කිරීම සඳහා වන Set අද්විතීය වටිනාකම් ලැයිස්තුවක් විය කිරීමට සැලසුම් කර ඇත අතර,.

const cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
const uniqueCars = Array.from(new Set(cars));

මෙම Array.fromඔබ පෙලගැස්මක් ඇති බව නියමයි ක්රම (ලක්ෂණ) සියලු ලබාගැනීම පහසු බව එසේ රැසක් සඳහා නැවත Set බවට පරිවර්තනය කිරීමට ප්රයෝජනවත් වේ. එකම දේ කිරීමට වෙනත් ක්‍රම ද තිබේ . ForEachArray.from වැනි ප්‍රයෝජනවත් විශේෂාංග කට්ටලවල ඇති බැවින් ඔබට කිසිසේත් අවශ්‍ය නොවනු ඇත.

ඔබට පැරණි ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් සඳහා සහය දැක්වීමට අවශ්‍ය නම්, ඒ අනුව සෙට් භාවිතා කළ නොහැකි නම්, සරල ක්‍රමයක් නම්, නව අරා වෙත අයිතම පිටපත් කිරීම, ඒවා දැනටමත් නව අරාවෙහි තිබේදැයි පරීක්ෂා කර බැලීමයි.

// Create a list of cars, with duplicates.
var cars = ['Volvo', 'Jeep', 'Volvo', 'Lincoln', 'Lincoln', 'Ford'];
// Create a list of unique cars, to put a car in if we haven't already.
var uniqueCars = [];

// Go through each car, one at a time.
cars.forEach(function (car) {
    // The code within the following block runs only if the
    // current car does NOT exist in the uniqueCars list
    // - a.k.a. prevent duplicates
    if (uniqueCars.indexOf(car) === -1) {
        // Since we now know we haven't seen this car before,
        // copy it to the end of the uniqueCars list.
        uniqueCars.push(car);
    }
});

මෙය ක්ෂණිකව නැවත භාවිතා කිරීමට, අපි එය ශ්‍රිතයකට දමමු.

function deduplicate(data) {
    if (data.length > 0) {
        var result = [];

        data.forEach(function (elem) {
            if (result.indexOf(elem) === -1) {
                result.push(elem);
            }
        });

        return result;
    }
}

එබැවින් අනුපිටපත් ඉවත් කිරීම සඳහා, අපි දැන් මෙය කරන්නෙමු.

var uniqueCars = deduplicate(cars);

මෙම deduplicate(cars)කොටස බවට පත් අප නම් කරන ලද දෙයක් නිසා විට කාර්යය සම්පූර්ණ වෙනවා.

ඔබ කැමති ඕනෑම අරාවක නම එය සම්මත කරන්න.

["Defects", "Total", "Days", "City", "Defects"].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

[0,1,2,0,3,2,1,5].reduce(function(prev, cur) {
  return (prev.indexOf(cur) < 0) ? prev.concat([cur]) : prev;
 }, []);

අපට මෙය ES6 කට්ටල භාවිතයෙන් කළ හැකිය:

var duplicatedArray = [1, 2, 3, 4, 5, 1, 1, 1, 2, 3, 4];
var uniqueArray = Array.from(new Set(duplicatedArray));

console.log(uniqueArray);

// ප්‍රතිදානය වනු ඇත

uniqueArray = [1,2,3,4,5];

මෙම මූලාකෘති getUniquei වැනි Array තිබේ නම් නිසා නොවේ, සම්පූර්ණයෙන්ම නිවැරදි ය: ["1",1,2,3,4,1,"foo"]එය ආපසු ඇත ["1","2","3","4"]හා "1"සංගීත හා 1එය පූර්ණ සංඛ්යාමය ය; ඒවා වෙනස් ය.

මෙන්න නිවැරදි විසඳුමක්:

Array.prototype.unique = function(a){
    return function(){ return this.filter(a) }
}(function(a,b,c){ return c.indexOf(a,b+1) < 0 });

භාවිතා කරමින්:

var foo;
foo = ["1",1,2,3,4,1,"foo"];
foo.unique();

ඉහත සඳහන් දෑ නිපදවනු ["1",2,3,4,1,"foo"]ඇත.

Array.prototype දිගු නොකර (එය නරක පුරුද්දක් යැයි කියනු ලැබේ) හෝ jquery / underscore භාවිතා නොකර, ඔබට සරලවම filterඅරාව කළ හැකිය .

අවසාන සිදුවීම තබා ගැනීමෙන්:

    function arrayLastUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps last occurrence
            return c.indexOf(a, b + 1) < 0;
        });
    },

හෝ පළමු සිදුවීම:

    function arrayFirstUnique(array) {
        return array.filter(function (a, b, c) {
            // keeps first occurrence
            return c.indexOf(a) === b;
        });
    },

හොඳයි, එය ජාවාස්ක්‍රිප්ට් ECMAScript 5+ පමණක් වන අතර එයින් අදහස් කරන්නේ IE9 + පමණි, නමුත් ස්වදේශීය HTML / JS (වින්ඩෝස් ස්ටෝර් ඇප්, ෆයර්ෆොක්ස් ඕඑස්, සෙන්චා, ෆොනෙගෑප්, ටයිටේනියම්, ...) හි වර්ධනයක් සඳහා එය කදිමයි.

[...new Set(duplicates)]

මෙය සරලම එකක් වන අතර එම්ඩීඑන් වෙබ් ලියකියවිලි වලින් යොමු කෙරේ .

const numbers = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5]
console.log([...new Set(numbers)]) // [2, 3, 4, 5, 6, 7, 32]

මැජික්

a.filter(e=>!(t[e]=e in t)) 

O (n) කාර්ය සාධනය ; අපි හිතන්නේ ඔබේ අරාව ක්‍රියාත්මකයි aසහ t={}. මෙහි පැහැදිලි කිරීම (+ ජෙප් impr.)

let t={}, unique= a=> a.filter(e=>!(t[e]=e in t));

// "stand-alone" version working with global t:
// a1.filter((t={},e=>!(t[e]=e in t)));

// Test data
let a1 = [5,6,0,4,9,2,3,5,0,3,4,1,5,4,9];
let a2 = [[2, 17], [2, 17], [2, 17], [1, 12], [5, 9], [1, 12], [6, 2], [1, 12]];
let a3 = ['Mike', 'Adam','Matt', 'Nancy', 'Adam', 'Jenny', 'Nancy', 'Carl'];

// Results
console.log(JSON.stringify( unique(a1) ))
console.log(JSON.stringify( unique(a2) ))
console.log(JSON.stringify( unique(a3) ))

ඔබ මූලාකෘති රාමුවක් භාවිතා කරන්නේ නම්, 'සඳහා' ලූප අවශ්‍ය නොවේ, ඔබට http://www.prototypejs.org/api/array/uniq භාවිතා කළ හැකිය :

var a = Array.uniq();  

එමඟින් අනුපිටපත් නොමැති අනුපිටපත් පෙළක් නිපදවනු ඇත. ඔබේ ප්‍රශ්නය මට හමු වූයේ වෙනස් අරා වාර්තා ගණනය කිරීමේ ක්‍රමයක් සෙවීමෙනි

uniq ()

මම පාවිච්චි කළා

ප්‍රමාණය ()

මගේ සරල ප්‍රති .ලය ලැබුණා. ps මම යමක් වැරදියට ටයිප් කළා නම් කණගාටුයි

සංස්කරණය කරන්න: ඔබට නිර්වචනය නොකළ වාර්තා වලින් ගැලවීමට අවශ්‍ය නම් ඔබට එකතු කිරීමට අවශ්‍ය විය හැකිය

සංගත()

පෙර, මේ වගේ:

var a = Array.compact().uniq();  

එයට හේතුව 0ජාවාස්ක්‍රිප්ට් හි ව්‍යාජ අගයකි.

this[i] අරාවෙහි අගය 0 හෝ වෙනත් ව්‍යාජ අගයක් නම් ව්‍යාජ වනු ඇත.

දැන් කට්ටල භාවිතා කිරීමෙන් ඔබට අනුපිටපත් ඉවත් කර නැවත අරාව බවට පරිවර්තනය කළ හැකිය.

var names = ["Mike","Matt","Nancy", "Matt","Adam","Jenny","Nancy","Carl"];

console.log([...new Set(names)])

තවත් විසඳුමක් වන්නේ වර්ග කිරීම සහ පෙරණය භාවිතා කිරීමයි

var names = ["Mike","Matt","Nancy", "Matt","Adam","Jenny","Nancy","Carl"];
var namesSorted = names.sort();
const result = namesSorted.filter((e, i) => namesSorted[i] != namesSorted[i+1]);
console.log(result);

Array.prototype.getUnique = function() {
    var o = {}, a = []
    for (var i = 0; i < this.length; i++) o[this[i]] = 1
    for (var e in o) a.push(e)
    return a
}

මට තරමක් වෙනස් ගැටළුවක් ඇති අතර එහිදී අනුපිටපත් හැඳුනුම් ගුණාංග සහිත වස්තු අරාවකින් ඉවත් කිරීමට අවශ්‍ය විය. මෙය ක්‍රියාත්මක විය.

let objArr = [{
  id: '123'
}, {
  id: '123'
}, {
  id: '456'
}];

objArr = objArr.reduce((acc, cur) => [
  ...acc.filter((obj) => obj.id !== cur.id), cur
], []);

console.log(objArr);

සරලම පිළිතුර නම්:

const array = [1, 1, 2, 2, 3, 5, 5, 2];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // [1, 2, 3, 5]

සිට Shamasis භට්ටාචාර්යා ගේ බ්ලොග් (සාමාන්ය (2n) කාලය සංකීර්ණත්වය):

Array.prototype.unique = function() {
    var o = {}, i, l = this.length, r = [];
    for(i=0; i<l;i+=1) o[this[i]] = this[i];
    for(i in o) r.push(o[i]);
    return r;
};

සිට පෝල් අයර්ලන්ත ගේ බ්ලොග් : jQuery මත වැඩි දියුණු කිරීම .unique():

(function($){

    var _old = $.unique;

    $.unique = function(arr){

        // do the default behavior only if we got an array of elements
        if (!!arr[0].nodeType){
            return _old.apply(this,arguments);
        } else {
            // reduce the array to contain no dupes via grep/inArray
            return $.grep(arr,function(v,k){
                return $.inArray(v,arr) === k;
            });
        }
    };
})(jQuery);

// in use..
var arr = ['first',7,true,2,7,true,'last','last'];
$.unique(arr); // ["first", 7, true, 2, "last"]

var arr = [1,2,3,4,5,4,3,2,1];
$.unique(arr); // [1, 2, 3, 4, 5]

ගේබ්‍රියෙල් සිල්වෙයිරා එම කාර්යය එසේ ලිව්වේ ඇයිදැයි මට විශ්වාස නැත, නමුත් සරල ආකාරයකින් මා වෙනුවෙන් මෙන්ම අවම කිරීමකින් තොරව ක්‍රියා කරයි:

Array.prototype.unique = function() {
  return this.filter(function(value, index, array) {
    return array.indexOf(value, index + 1) < 0;
  });
};

හෝ කෝපි ස්ක්‍රිප්ට් හි:

Array.prototype.unique = ->
  this.filter( (value, index, array) ->
    array.indexOf(value, index + 1) < 0
  )

අමතර පරායත්තතාවයන් සමඟ ඔබ හොඳින් සිටී නම්, හෝ ඔබට දැනටමත් ඔබේ කේත පදනමේ පුස්තකාලයක් තිබේ නම්, ඔබට LoDash (හෝ අන්ඩර්ස්කෝර්) භාවිතා කර ස්ථානයක ඇති අනුපිටපත් ඉවත් කළ හැකිය.

භාවිතය

ඔබගේ කේත රචනයේ දැනටමත් එය නොමැති නම්, එය npm භාවිතයෙන් ස්ථාපනය කරන්න:

npm install lodash

ඉන්පසු එය පහත පරිදි භාවිතා කරන්න:

import _ from 'lodash';
let idArray = _.uniq ([
    1,
    2,
    3,
    3,
    3
]);
console.dir(idArray);

පිටතට:

[ 1, 2, 3 ]

මෙයට බොහෝ පිළිතුරු ලැබී ඇත, නමුත් එය මගේ විශේෂ අවශ්‍යතාව සපුරාලුවේ නැත.

බොහෝ පිළිතුරු මේ වගේ ය:

a.filter((item, pos, self) => self.indexOf(item) === pos);

නමුත් මෙය සංකීර්ණ වස්තූන්ගේ අරා සඳහා ක්‍රියා නොකරයි.

අපට මේ වගේ පෙළක් ඇති බව පවසන්න:

const a = [
 { age: 4, name: 'fluffy' },
 { age: 5, name: 'spot' },
 { age: 2, name: 'fluffy' },
 { age: 3, name: 'toby' },
];

අද්විතීය නම් සහිත වස්තූන් අපට අවශ්‍ය නම්, array.prototype.findIndexඒ වෙනුවට අප භාවිතා කළ යුත්තේ array.prototype.indexOf:

a.filter((item, pos, self) => self.findIndex(v => v.name === item.name) === pos);

සරල ක්‍රමයකින් අද්විතීය අරාව අගයන් සොයා ගැනීම

function arrUnique(a){
  var t = [];
  for(var x = 0; x < a.length; x++){
    if(t.indexOf(a[x]) == -1)t.push(a[x]);
  }
  return t;
}
arrUnique([1,4,2,7,1,5,9,2,4,7,2]) // [1, 4, 2, 7, 5, 9]

වසර කිහිපයක් තිස්සේ පිළිගත් පිළිතුර ලෙස සැලකෙන රෆායෙල්ගේ පිළිතුර අපට අහිමි වී ඇති බව පෙනේ . ඔබට (අවම වශයෙන් 2017 දී) ඔබට මිශ්‍ර ආකාරයේ අරාවක් නොමැති නම් හොඳම ක්‍රියාකාරී විසඳුම මෙයයි :

Array.prototype.getUnique = function(){
    var u = {}, a = [];
    for (var i = 0, l = this.length; i < l; ++i) {
        if (u.hasOwnProperty(this[i])) {
            continue;
        }
        a.push(this[i]);
        u[this[i]] = 1;
    }
return a;
}

ඔබ නම් කළ මිශ්ර-වර්ගය මාලාවක් ඇති, ඔබ එහි පූරක ප්රධාන serialize හැක:

Array.prototype.getUnique = function() {
    var hash = {}, result = [], key; 
    for ( var i = 0, l = this.length; i < l; ++i ) {
        key = JSON.stringify(this[i]);
        if ( !hash.hasOwnProperty(key) ) {
            hash[key] = true;
            result.push(this[i]);
        }
    }
    return result;
}

අමුතු දෙයක් මෙය මීට පෙර යෝජනා කර නැත .. idඅරාව තුළ වස්තු යතුරෙන් ( පහළ) අනුපිටපත් ඉවත් කිරීමට ඔබට මෙවැනි දෙයක් කළ හැකිය:

const uniqArray = array.filter((obj, idx, arr) => (
  arr.findIndex((o) => o.id === obj.id) === idx
))