Уважаемые все, я пытаюсь найти неповторяющееся значение в массиве с помощью javascript. Я написал код, но он не работает должным образом. Вы можете сказать мне, в чем проблема. Спасибо.

var arr = [-1, 2, 5, 6, 2, 9, -1, 6, 5, -1, 3];
var n = arr.length;
var result = '';

function nonrep() {
  for (var i = 0; i < n; i++) {
    var j;
    for (j = 0; j < n; j++)
      if (i != j && arr[i] == arr[j]) {
        result = arr[i];
        break;
      }
    if (j == n)
      return arr[i];
  }
  return result;
}
console.log(nonrep())
-1
Anil kumar 14 Июн 2018 в 13:00
1
3
arr.lenght Орфография имеет значение в программировании.
 – 
CertainPerformance
14 Июн 2018 в 13:01
Пожалуйста, помогите мне
 – 
Anil kumar
14 Июн 2018 в 13:02
Каков ваш ожидаемый результат? Вам нужно, чтобы уникальные значения или значения появлялись в массиве только один раз?
 – 
Eddie
14 Июн 2018 в 13:02
1
TYPO, используйте length, и ваш код будет работать
 – 
Satpal
14 Июн 2018 в 13:03

7 ответов

Вы можете использовать фильтр и < a href = "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf" rel = "nofollow noreferrer"> indexOf для этого:

console.log(
  [-1, 2, 5, 6, 2, 9, -1, 6, 5, -1, 3].filter((v, i, a) => a.indexOf(v, i + 1) === -1 )
);
0
ZER0 14 Июн 2018 в 13:10

Вы можете сначала использовать reduce, чтобы получить один объект со счетчиком для каждого элемента числа, а затем filter на Object.keys, чтобы вернуть массив неповторяющихся чисел.

var arr=[-1,2,5,6,2,9,-1,6,5,-1,3];
var obj = arr.reduce((r, e) => (r[e] = (r[e] || 0) + 1, r), {});
var uniq = Object.keys(obj).filter(e => obj[e] == 1).map(Number)

console.log(uniq)

Решение с циклом for.

var arr = [-1, 2, 5, 6, 2, 9, -1, 6, 5, -1, 3];

var uniq = [];
for (var i = 0; i < arr.length; i++) {
  for (var j = 0; j < arr.length; j++) {
    if (arr[i] == arr[j] && i != j) break;
    else if (j == arr.length - 1) uniq.push(arr[i])
  }
}

console.log(uniq)
0
Nenad Vracar 14 Июн 2018 в 13:18

Фильтрация только уникальных элементов по запросу OP:

При этом используются циклы for по запросу. Он возвращает массив, содержащий только элементы, появляющиеся один раз в исходном массиве.

var arr = [-1, 2, 5, 6, 2, 9, -1, 6, 5, -1, 3];
var n = arr.length;
var result = [];

function nonrep() {
  for (var i = 0; i < n; i++) {
    for (var j=0 ; j < n; j++)
      if (i!=j && arr[i]==arr[j])
        break;
    if(j==n)
        result.push(arr[i]);
  }
  return result;
}
console.log(nonrep())
0
Attersson 14 Июн 2018 в 13:30
Мне нужно решение в цикле, а также код выше не работает
 – 
Anil kumar
14 Июн 2018 в 13:12
Я отредактировал свой ответ и использовал для циклов, реализовав запрошенную вами фильтрацию.
 – 
Attersson
14 Июн 2018 в 13:24

Некоторые изменения:

  • Переместите все объявления переменных внутрь функции.
  • Используйте параметр функции для переданного массива, сохраняйте функцию чистой.
  • Заранее объявите все необходимые переменные в верхней части функции.
  • Возьмите массив как массив результатов unique.
  • Проверьте i и j и, если они равны, continue (внутренний) цикл.
  • Проверьте значение в i и j и выйдите из (внутреннего) цикла, поскольку обнаружен дубликат.
  • Выполните проверку в конце внутреннего цикла и проверьте индекс j с длиной массива l, и, если он равен, вставьте значение в unique.
  • Используйте один оператор return с массивом unique в конце внешнего цикла.
function getUnique(array) {
    var l = array.length,
        i, j,
        unique = [];

    for (i = 0; i < l; i++) {
        for (j = 0; j < l; j++) {
            if (i === j) {
                continue;
            }
            if (array[i] === array[j]) {
                break;
            }
        }
        if (j === l) {
            unique.push(array[i]);
        }
    }
    return unique;
}

console.log(getUnique([-1, 2, 5, 6, 2, 9, -1, 6, 5, -1, 3]));

Другим решением может быть проверка, возвращают ли indexOf и lastIndexOf одно и то же значение. Тогда вы нашли уникальное значение.

var array = [-1, 2, 5, 6, 2, 9, -1, 6, 5, -1, 3],
    unique = array.filter((v, i) => array.indexOf(v) === array.lastIndexOf(v));

console.log(unique);
0
Nina Scholz 14 Июн 2018 в 14:00
Хотя, как всегда, вы обнаруживаете увлекательные концепции, на этот раз я должен указать, что сложность O (2N ^ 2) является избыточной. Хотя просто наблюдение.
 – 
Attersson
14 Июн 2018 в 13:28
var arr1 = [45, 4,16,25,45,4,16, 9,7, 16, 25];
 var arr=arr1.sort();
  console.log(arr);
 var str=[];
 arr.filter(function(value){

if( arr.indexOf(value) === arr.lastIndexOf(value))
{ str.push(value);
console.log("ntttttttttttttnnn" +str)

}// how this works ===============A
 })

O / P

 7,9
0
Tested 13 Сен 2018 в 11:19
Please try the below code snippet.

var arr = [-1, 2, 5, 6, 2, 9, -1, 6, 5, -1, 3];
    var uniqArr = [];
    for (var i = 0; i < arr.length; i++) {
      for (var j = 0; j < arr.length; j++) {
        if (arr[i] == arr[j] && i != j) break;
        else if (j == arr.length - 1){
          uniqArr.push(arr[i])
        } 
      }
    }

    console.log(uniqArr)
0
Hemanta 21 Июл 2019 в 18:17

Этот код ES6 работал у меня:

A.map (c => a.filter (b => c == b)). filter (e => e.length <2) .reduce ((total, cur) => total.concat (cur), [ ])

0
Ali Awais 11 Мар 2020 в 15:46