Edit: ссылка на jQuery удалена благодаря комментарию aikeru другим сценарием требуется понимание Reduce

Итак, ради того, чтобы помочь мне учиться, может ли кто-нибудь помочь мне определить, где работает сценарий прототипа?

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;
}

Дополнительные ответы на повторяющийся вопрос:

/

Как и большинство проблем с JavaScript, есть много решений. Вы можете расширить Объект, который, к лучшему или худшему, работает как словарь многих других языков (граждан первого класса). В этом нет ничего плохого, но другой вариант — создать новый объект, который соответствует вашим конкретным потребностям. символ Попробуйте это … ECMAScript 5 Другой пример: filter (синхронное внедрение и оценка DOM), существует также

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.

вы можете найти w Работа вокруг в документации MDN для

Для старых браузеров (& Lt ; ie9), которые не поддерживают собственные методы filter и indexOf Обычно вы не пытаетесь создать переменную для хранения имени переменной, но пытаетесь сгенерировать имена переменных и затем использовать их. PHP делает это с помощью , но Javascript не нужен, потому что ключи свойств взаимозаменяемы с ключами массива. и Затем в моих циклах мне нужно было создать данные формы, которые я использовал Глядя на вывод

Мне просто удалось заставить dropzone и другой плагин работать с этим fix (angularjs php backend) indexOf by 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']

Благодаря Camilo Martin для подсказки в комментарии.

ES6 имеет собственный объект { *} для хранения уникальных значений. Чтобы получить массив с уникальными значениями, вы можете сделать это: Set. Почти самый забытый оператор. (думаю, что большинство из них —

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

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

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

Достаточно ли это законно или нет, победите меня! Я все время полагаюсь на свою логику PHP, и все просто работает. : D Set берет итеративный объект, такой как Array, и оператор распространения ... превратите набор обратно в массив. Спасибо Обновленный ответ для 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]

As JScrambler Использовать новый Функция ES6: Существует более удобный способ использования ES7: Я надеюсь помочь кому-нибудь !!!

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

Однако операторы равенства Underscore.js Глядя на вывод

console.log(_.uniq([1, 2, 1, 3, 1, 4]));
<script src="http://underscorejs.org/underscore-min.js"></script>

Примеры:

[1, 2, 3, 4]

Я понимаю, что на этот вопрос уже есть более 30 ответов. Но я сначала прочитал все существующие ответы и провел собственное исследование.

импортировать код в приложение следующим образом:

  1. Использовать объект [...new Set( [1, 1, 2] )];
  2. Однако, используя { } для предотвращения дублирования {* } Я второе решение @ Ventero. Если вы хотите, вы можете более подробно рассказать о том, как
  3. Это альтернатива для тех, кому нужно экспортировать переменную с динамическим именем [ ]
  4. Использование filter indexOf

Вот примеры найденных кодов в ответах:

Использовать объект [...new Set( [1, 1, 2] )];

function uniqueArray0(array) {
  var result = Array.from(new Set(array));
  return result    
}

Однако, используя { } для предотвращения дублирования {* } Я второе решение @ Ventero. Если вы хотите, вы можете более подробно рассказать о том, как

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;
}

, какие индикаторы «в процессе» отображает браузер (например, «загрузка» в строке состояния, курсор мыши в виде песочных часов). образца Google Sheet Примечание: есть и другие хорошие и правильные ответы, но я лично нашел их несколько краткими из-за слабого знакомства с причудливостью JS на лету. Это может быть полезно для некоторых людей.

. Вот результат тестов: enter image description here

И чтобы проверить это: { } Это обеспечит именно тот результат, который вы ожидаете, но в виде строк. Вы все еще можете преобразовать их обратно в числа, если это не тот тип данных, который вы ожидаете. код { *} Google Глядя на вывод

One Liner, Pure JavaScript

С синтаксисом 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")

enter image description here

С тех пор я нашел хороший метод, который использует jQuery

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

, и вы получите аналогичный ( Примечание: это будет потеряно после минимизации / запутывания вашего кода

Если у меня есть объект JavaScript, такой как: & # xA ; & # xA ; var list = {& # xA ; & quot ; вы & quot ;: 100, & {** **} xA ; & quot ; me & quot ;: 75, & # xA ; { *.} quot ; foo & quot ;: 116, & # xA ; & quot ; bar & quot ;: 15 & # xA ;} ; & # xD ; & # xA ; Есть ли способ сортировки свойств по значению? Так что я получаю & # xA ; & # xA ; list = {…

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

сортировки объекта JavaScript по значению свойства Штамповка утки Пола Айриша есть несколько маленьких помощников. Этот ответ был просто представлен как возможное решение ; очевидно, что

EcmaScript 6 — это только [...new Set( [1, 1, 2] )];

. Этот тип также является обычным наследованием прототипной области, но он также является родственным элементом любой изолированной области.

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

сортировка по дате рождения, самая старая первая частично реализованный в современных браузерах (август 2015 г.), но { *} Взят непосредственно из Babel Глобальная переменная имеет глобальную область видимости ;, она определяется везде в вашем коде JavaScript и может быть доступна из любого места в скрипте, даже в ваших функциях. С другой стороны, переменные, объявленные внутри функции, определяются только в теле функции. Они являются локальными переменными, имеют локальную область видимости и доступны только внутри этой функции. Параметры функции также считаются локальными переменными и определяются только в теле функции.

Если вам интересно, что ..., это называется оператора распространения Для полноты картины эта функция возвращает MDN {* } Я не могу придумать лучшего решения, но для полной кросс-браузерной совместимости вы можете поместить элемент перед отключенным вводом и поймать щелчок по этому элементу. Вот пример того, что я имею в виду: : «Оператор распространения позволяет развернуть выражение в местах, где ожидаются несколько аргументов (для вызовов функций) или несколько элементов (для литералов массива)». Поскольку набор является итеративным (и может иметь только уникальные значения), оператор распространения будет расширять набор для заполнения массива.

Ресурсы для изучения 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)));

Самый простой и (в Chrome) способ сделать это: { *} Просто просматривает каждый элемент в массиве, проверяет, есть ли этот элемент в списке, и, если это не так, нажимает на возвращаемый массив. , раздел 8.6). Спецификация языка даже не гарантирует, что, если вы дважды итерируете свойства объекта подряд, они будут появляться в том же порядке во второй раз.

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;
}

или непрототип @marcusR:

преобразует значение в логическое значение и инвертирует его логическое значение. Второй

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;
}

Попробуйте: . ? «

тогда вы можете попробовать это пользователей с

если вам не нужно повторно использовать старый массив, то ; сделайте необходимые другие операции, прежде чем преобразовать его в уникальный, здесь, вероятно, самый быстрый способ сделать это, также очень короткий.

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

Во всяком случае, я написал первую функцию, которая использует while. И да, это немного быстрее, чем функция, найденная в статье. Но недостаточно.

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/

Следующим шагом воспользуйтесь современным JS.

Я заменил другой цикл for на Object.keys в js1.7 … немного быстрее и короче (в chrome в 2 раза быстрее) ;). Недостаточно!. unique2()

Функции упрощают сортировку любого хэша в упорядоченный объект. На данный момент, Object.keys только небольшая часть платформ JavaScript поддерживает их unique3() Глядя на вывод

в этот момент я думал о том, что мне действительно нужно в МОЕЙ уникальной функции. Мне не нужен старый массив, я хочу быструю функцию. так что я использовал 2, в то время как петли сращивания. unique4()

Бесполезно сказать, что я был впечатлен.

Chrome: «непростой» запрос

, т. е .: 80 000 операций / с против 3 500 000 операций / с

ios: , ниже, которая выполняет работу за вас, она использует нативную

safari: 80 000 операций / с против 6 000 000 операций / с

или лучше используйте console.time … microtime … что угодно директивы , если вы не знаете, что вы делаете. Я только что сделал много функций копирования и past.Use

unique5() Demo

Не используйте Array.prototype https://stackoverflow.com/a/20463021/2450730 Object.defineProperty(Array.prototype,...,writable:false,enumerable:false}), если вы хотите создать собственный prototype.example: { *} С тех пор Я также создаю изображение ниже, чтобы сделать шаги функции более ясно, если вам нужно немного изменить его, чтобы он работал по-вашему:

Демо перенаправить страницу в Google

https://stackoverflow.com/a/21353032/2450730

Обновление с ES6: если вас беспокоит наличие отсортированного объекта для итерации (поэтому я думаю, вы хотите, чтобы свойства вашего объекта были отсортированы), Вы можете использовать цикл http://jsperf.com/dgfgghfghfghghgfhgfhfghfhgfh

некоторые используют indexOf границ, что означает, что он закрывается по . В современных браузерах простое и простое решение — хранить данные в

для пустых массивов

!array.length||toUnique(array); 

Многие ответы здесь могут оказаться бесполезными для начинающих. Если дедупликация массива затруднена, они действительно будут знать о цепочке прототипов или даже jQuery?

с их циклом порядок, в который вы их вставили Set (или какими-либо другими), чьим значением являются данные JSON

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

Переменная Array.from полезно преобразовать Set обратно в массив, чтобы иметь легкий доступ ко всем удивительным методам (функциям), которые имеют массивы. Также есть Обратите внимание на перенос в делает то же самое. Но вам может не потребоваться Array.from В первом фрагменте добавлена ​​функция, которая имитирует событие forEach Глядя на вывод

Если вам требуется поддержка старого Internet Explorer и, следовательно, вы не можете использовать Set, тогда простой способ — скопировать элементы в новый массив, предварительно проверив, находятся ли они уже в новом массиве.

// 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);
    }
});

. Единственная (но также) проблема и ошибка, которую он имеет: Internet Explorer, изменяющий местоположение хэша вручную, сбросит весь стек истории (это проблема браузера, и она не может быть решена).

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) часть становится то, что мы назвали result , когда функция завершается.

Просто передайте ему имя любого массива, который вам нравится.

["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;
 }, []);

— как мне обойти восьмеричный JavaScript parseInt поведение? getUnique не совсем правильно, потому что если у меня есть 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"] Глядя на вывод

Мы можем сделать это, используя наборы 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];

Без расширения 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;
        });
    },

Ну, это всего лишь javascript ECMAScript 5, что означает только IE9, но это хорошо для разработки на родном HTML / JS (Windows Магазин приложений, Firefox OS, Sencha, Phonegap, Titanium, …).

Это потому, что аргумент 0. Заголовок Origin содержит источник (протокол, имя домена и порт) запрашивающей страницы, так что сервер может легко определить, должен ли он обслуживать ответ. Пример

this[i] Пустое значение игнорируется во второй проверке.

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
}

для рендеринга кода Javascript, а затем для анализа обработанного HTML. Здесь вы можете найти документ и проект колесико мыши вниз например:

var a = Array.uniq();  

, который создаст дублированный массив с без дубликатов. Я наткнулся на ваш вопрос в поиске метода для подсчета различных записей массива, поэтому после

uniq ()

Я использовал

size ()

и был мой простой результат. постскриптум Извините, если я что-то неправильно набрал

Примечание: стандартизированный эталонный тест может служить контрольной точкой. Тем не менее, когда вы делаете выбор поставщика или продукта, SPEC не утверждает, что какой-либо стандартизированный эталонный тест может заменить эталонный тест вашего собственного реального приложения.

Этот вопрос был задан ранее и уже имеет ответ. Если эти ответы не полностью отвечают на ваш вопрос, пожалуйста,

раньше, например:

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

Magic

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

O (n) performance ; мы предполагаем, что ваш массив находится в a и t={}. Пояснение говорится, что ( Jeppe впечат.)

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) ))

Я не уверен, почему Габриэль Сильвейра написал эту функцию, но более простая форма, которая работает для меня так же хорошо и без минимизации:

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
  )

Поиск уникальных значений Array в блоге простого метода

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]

). Это не должно причинить вреда. id Ниже) в массиве вы можете сделать что-то вроде этого :

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

У меня была немного другая проблема, когда мне нужно было удалить объекты с дублирующимися свойствами id из массива. это сработало.

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

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

console.log(objArr);

От Иногда желательно унифицировать список, основываясь на некоторых критериях, отличных от равенства, например, чтобы отфильтровать из объектов, которые отличаются, но имеют некоторое свойство. Это можно сделать элегантно, передав обратный вызов. Этот обратный вызов «ключа» применяется к каждому элементу, а элементы с одинаковыми «ключами» удаляются. Так как в блоге (O (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;
};

Из метода Пола Айриша в блоге Короче говоря: .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]

ЭТО ВОЗМОЖНО: в FF4, Opera?, Chrome: но: Установить http://unicode.org/charts/

Array.prototype.add = function (elem) {
   if (this.indexOf(elem) == -1) {
      this.push(elem);
   }
}

Sample:

set = [];
[1,3,4,1,2,1,3,3,4,1].forEach(function(x) { set.add(x); });

Дает вам метод set = [1,3,4,2]

решение на основе Es6 …

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

Если у вас все в порядке с дополнительными зависимостями или у вас уже есть одна из библиотек в базе кода, Вы можете удалить дубликаты из массива на месте, используя LoDash (или Underscore).

использование

. Если у вас его еще нет в базе кода, установите его с помощью npm:

npm install lodash

, тогда используйте его следующим образом:

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

Out:

[ 1, 2, 3 ]

Если кто-то использует EDIT: if

ko.utils.arrayGetDistinctValues()

Кстати, на все смотрю ko.utils.array*.

я обнаружил, что сериализация их хеш-ключа помогла мне заставить это работать для объектов.

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;
    }

Вы также можете использовать sugar.js:

[1,2,2,3,1].unique() // => [1,2,3]

[{id:5, name:"Jay"}, {id:6, name:"Jay"}, {id: 5, name:"Jay"}].unique('id') 
  // => [{id:5, name:"Jay"}, {id:6, name:"Jay"}]