Jaki jest najbardziej zwięzły i skuteczny sposób, aby dowiedzieć się, czy tablica JavaScript zawiera wartość?

To jedyny sposób, w jaki wiem, aby to zrobić:

function contains(a, obj) {
    for (var i = 0; i < a.length; i++) {
        if (a[i] === obj) {
            return true;
        }
    }
    return false;
}

Czy jest lepszy i bardziej zwięzły sposób na osiągnięcie tego?

Jest to bardzo ściśle związane z pytaniem o przepełnienie stosu Najlepszy sposób na znalezienie przedmiotu w tablicy JavaScript? , która dotyczy znalezienia obiektów w tablicy przy użyciu indexOf.

4270
brad 26 październik 2008, 02:14

29 odpowiedzi

Najlepsza odpowiedź

Nowoczesne przeglądarki mają Array#includes , co robi dokładnie , a jest szeroko wspierany przez wszystkich, z wyjątkiem tj.:

console.log(['joe', 'jane', 'mary'].includes('jane')); //true

Możesz także użyć Array#indexOf, co jest mniejsze Bezpośredni, ale nie wymaga polipulatorów dla przestarzałych przeglądarek.


Wiele ramy oferuje również podobne metody:

Zauważ, że niektóre ramy wdrażają to jako funkcję, podczas gdy inni dodają funkcję do prototypu tablicy.

4704
37 revs, 22 users 18% 3 listopad 2020, 17:51

Oto jak Prototypia robi to:

/**
 *  Array#indexOf(item[, offset = 0]) -> Number
 *  - item (?): A value that may or may not be in the array.
 *  - offset (Number): The number of initial items to skip before beginning the
 *      search.
 *
 *  Returns the position of the first occurrence of `item` within the array &mdash; or
 *  `-1` if `item` doesn't exist in the array.
**/
function indexOf(item, i) {
  i || (i = 0);
  var length = this.length;
  if (i < 0) i = length + i;
  for (; i < length; i++)
    if (this[i] === item) return i;
  return -1;
}

Także zobacz także Oto dla tego, jak oni podłączyć go.

4
Ken 27 sierpień 2009, 17:10

Aktualizacja od 2019 r.: Ta odpowiedź wynosi od 2008 r. (11 lat!) I nie ma znaczenia dla współczesnego użycia JS. Obiecana poprawa wydajności opierała się na benchmarku wykonanym w przeglądarkach tego czasu. Może nie być istotne dla współczesnych kontekstów wykonawczych JS. Jeśli potrzebujesz łatwego rozwiązania, szukaj innych odpowiedzi. Jeśli potrzebujesz najlepszej wydajności, benchmarku dla siebie w odpowiednich środowiskach wykonawczych.

Gdy inni powiedzieli, iteracja przez tablicę jest prawdopodobnie najlepszy sposób, ale to został udowodniony że maleje Loop while jest najszybszym sposobem na Itera w JavaScript. Możesz więc przesłać swój kod w następujący sposób:

function contains(a, obj) {
    var i = a.length;
    while (i--) {
       if (a[i] === obj) {
           return true;
       }
    }
    return false;
}

Oczywiście, możesz równie dobrze rozszerzyć prototyp array:

Array.prototype.contains = function(obj) {
    var i = this.length;
    while (i--) {
        if (this[i] === obj) {
            return true;
        }
    }
    return false;
}

A teraz możesz po prostu użyć następujących:

alert([1, 2, 3].contains(2)); // => true
alert([1, 2, 3].contains('2')); // => false
456
Damir Zekić 7 sierpień 2019, 10:49

indexOf może, ale to "rozszerzenie javascript do standardu ECMA-262; jako taki może nie być obecny w innych wdrożeniu standardu. "

Przykład:

[1, 2, 3].indexOf(1) => 0
["foo", "bar", "baz"].indexOf("bar") => 1
[1, 2, 3].indexOf(4) => -1

AFAICSA Microsoft robi nie Oferuj to jakiś alternatywny do tego, ale możesz dodać podobną funkcjonalność do tablic w programie Internet Explorer (i innych przeglądarek, które nie obsługują indexOf), jeśli chcesz, jako a Szybkie wyszukiwanie Google ujawnia (na przykład Ten jeden).

220
Peter Mortensen 11 sierpień 2011, 23:41

ECMAScript 7 przedstawia Array.prototype.includes .

Może być taki używany:

[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false

Akceptuje również opcjonalny drugi argument fromIndex:

[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true

W przeciwieństwie do indexOf, który używa Surrict Equality porównawcze, {x1}} porównuje przy użyciu samevaluezero Algorytm równości. Oznacza to, że możesz wykryć, czy tablica zawiera NaN:

[1, 2, NaN].includes(NaN); // true

Również w przeciwieństwie indexOf, includes nie pomija brakujące wskaźniki:

new Array(5).includes(undefined); // true

Obecnie jest to wciąż projekt, ale może być polyfilded, aby działał na wszystkich przeglądarkach.

179
Oriol 8 luty 2016, 16:53

Najważniejsze odpowiedzi przyjmują prymitywne typy, ale jeśli chcesz dowiedzieć się, czy tablica zawiera obiekt z jakąś cechą, array.prototype.some () to bardzo eleganckie rozwiązanie:

const items = [ {a: '1'}, {a: '2'}, {a: '3'} ]

items.some(item => item.a === '3')  // returns true
items.some(item => item.a === '4')  // returns false

Miło jest o tym, że iteracja jest przerywana po znalezieniu elementu, więc niepotrzebne cykle iteracji są oszczędzone.

Ponadto ładnie pasuje do oświadczenia {x0}}, ponieważ zwraca logiczne:

if (items.some(item => item.a === '3')) {
  // do something
}

* Gdy Jamess wskazała w komentarzu, w momencie tej odpowiedzi, wrzesień 2018 r., Array.prototype.some() jest w pełni obsługiwany: Caniuse.com Tabela pomocy techniczna

163
Michael 24 sierpień 2020, 11:39

Powiedzmy, że zdefiniowałeś tak jak:

const array = [1, 2, 3, 4]

Poniżej znajdują się trzy sposoby sprawdzania, czy istnieje tam 3. Wszystkie z nich zwracają true lub false.

Natywa metoda tablicy (od ES2016) (
117
Gust van de Wal 13 listopad 2019, 17:09

Oto JavaScript 1.6 Kompatybilny Implementacja Array.indexOf:

if (!Array.indexOf) {
    Array.indexOf = [].indexOf ?
        function(arr, obj, from) {
            return arr.indexOf(obj, from);
        } :
        function(arr, obj, from) { // (for IE6)
            var l = arr.length,
                i = from ? parseInt((1 * from) + (from < 0 ? l : 0), 10) : 0;
            i = i < 0 ? 0 : i;
            for (; i < l; i++) {
                if (i in arr && arr[i] === obj) {
                    return i;
                }
            }
            return -1;
        };
}
83
Narendra Jadhav 30 styczeń 2019, 10:23

Posługiwać się:

function isInArray(array, search)
{
    return array.indexOf(search) >= 0;
}

// Usage
if(isInArray(my_array, "my_value"))
{
    //...
}
59
Peter Mortensen 7 styczeń 2017, 11:29

Rozszerzenie JavaScript Array Obiekt jest naprawdę zły pomysł, ponieważ wprowadzasz nowe właściwości (metody niestandardowe) w pętle for-in, które mogą złamać istniejące skrypty. Kilka lat temu autorzy Prototyp biblioteka musiała ponownie inżynierować ich implementację biblioteki, aby usunąć tylko tego rodzaju rzeczy.

Jeśli nie musisz się martwić o kompatybilność z innymi JavaScript pracującymi na swojej stronie, przejdź do niego, w przeciwnym razie polecam bardziej niezręczne, ale bezpieczniejsze wolnostojące rozwiązanie funkcyjne.

53
Peter Mortensen 11 sierpień 2011, 23:43

One-liner:

function contains(arr, x) {
    return arr.filter(function(elem) { return elem == x }).length > 0;
}
34
Peter Mortensen 7 styczeń 2017, 11:25

Wydajność

Dzisiaj 2020.01.07 Wykonuję testy na MacOS Highsierra 10.13.6 na Chrome V78.0.0, Safari V13.0.4 i Firefox V71.0.0 dla 15 wybranych rozwiązań. Wnioski

  • Rozwiązania oparte na JSON, Set i zaskakująco find (K, N, O) są najwolniejsze na wszystkich przeglądarkach
  • ES6 includes (f) jest szybki tylko na chromie
  • Rozwiązania oparte na for (C, D) i {X1}} (G, H) są dość szybkie we wszystkich przeglądarkach w małych i dużych tablicach, więc prawdopodobnie są najlepszym wyborem na wydajne rozwiązanie
  • Rozwiązania, w których wskaźnik spadek podczas pętli, (b) jest wolniejszy, prawdopodobnie dlatego, że sposób Pamięć CPU działa.
  • Prowadzę również test dla dużej tablicy, gdy wyszukiwany element był w pozycji 66% długości tablicy, a rozwiązania oparte na for (C, D, E) podaje podobne wyniki (~ 630 OPS / s - ale E na Safari a Firefox był 10-20% wolniej niż C i D)

Wyniki

enter image description here

Detale

Wykonuję 2 przypadki testów: dla tablicy z 10 elementami i tablicą z 1 milionami elementów. W obu przypadkach umieściliśmy wyszukiwany element w środku tablicy.

let log = (name,f) => console.log(`${name}: 3-${f(arr,'s10')}  's7'-${f(arr,'s7')}  6-${f(arr,6)} 's3'-${f(arr,'s3')}`)

let arr = [1,2,3,4,5,'s6','s7','s8','s9','s10'];
//arr = new Array(1000000).fill(123); arr[500000]=7;

function A(a, val) {
    var i = -1;
    var n = a.length;
    while (i++<n) {
       if (a[i] === val) {
           return true;
       }
    }
    return false;
}

function B(a, val) {
    var i = a.length;
    while (i--) {
       if (a[i] === val) {
           return true;
       }
    }
    return false;
}

function C(a, val) {
    for (var i = 0; i < a.length; i++) {
        if (a[i] === val) return true;
    }
    return false;
}

function D(a,val)
{
    var len = a.length;
    for(var i = 0 ; i < len;i++)
    {
        if(a[i] === val) return true;
    }
    return false;
} 

function E(a, val){  
  var n = a.length-1;
  var t = n/2;
  for (var i = 0; i <= t; i++) {
        if (a[i] === val || a[n-i] === val) return true;
  }
  return false;
}

function F(a,val) {
	return a.includes(val);
}

function G(a,val) {
	return a.indexOf(val)>=0;
}

function H(a,val) {
	return !!~a.indexOf(val);
}

function I(a, val) {
  return a.findIndex(x=> x==val)>=0;
}

function J(a,val) {
	return a.some(x=> x===val);
}

function K(a, val) {
  const s = JSON.stringify(val);
  return a.some(x => JSON.stringify(x) === s);
}

function L(a,val) {
	return !a.every(x=> x!==val);
}

function M(a, val) {
  return !!a.find(x=> x==val);
}

function N(a,val) {
	return a.filter(x=>x===val).length > 0;
}

function O(a, val) {
  return new Set(a).has(val);
}

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);
log('H',H);
log('I',I);
log('J',J);
log('K',K);
log('L',L);
log('M',M);
log('N',N);
log('O',O);
This shippet only presents functions used in performance tests - it not perform tests itself!

Mały - 10 elementów

Możesz wykonać testy w maszynie Oto

enter image description here

array Big - 1.000.000 Elementy

Możesz wykonać testy w swojej maszynie Tutaj

enter image description here

29
Kamil Kiełczewski 11 marzec 2020, 16:26

Używam następujących czynności:

Array.prototype.contains = function (v) {
    return this.indexOf(v) > -1;
}

var a = [ 'foo', 'bar' ];

a.contains('foo'); // true
a.contains('fox'); // false
28
Eduardo Cuomo 15 czerwiec 2014, 01:15
function contains(a, obj) {
    return a.some(function(element){return element == obj;})
}

array.prototype.some () dodano do ECMA -262 Standard W 5 edycji

24
dansalmo 12 wrzesień 2014, 16:55

ma nadzieję, że szybciej dwukierunkowy indexOf / lastIndexOf alternatywa

2015.

Podczas gdy nowa metoda obejmuje jest bardzo Miło, wsparcie jest na razie w zasadzie zero.

Długi czas, że myślałem o sposobie wymiany funkcji powolnego indexof / Lastindexof.

Występował już sposób, patrząc na najlepsze odpowiedzi. Od tych, które wybrałem contains Opublikowany przez @Damir Zekic, który powinien być najszybszy. Ale stwierdza również, że benchmarki są z 2008 r. I tak są przestarzałe.

Preferuję też while nad for, ale nie dla konkretnego powodu zakończyłem pisanie funkcji za pomocą pętli. Może być również wykonany za pomocą while --.

Byłem ciekawy, jeśli iteracja była znacznie wolniejsza, jeśli sprawdzę obie strony tablicy, robiąc to. Najwyraźniej nie, więc ta funkcja wynosi około dwa razy szybciej niż najlepiej głosowali. Oczywiście jest również szybszy niż rodzimy. To w świecie rzeczywistym środowisku, gdzie nigdy nie wiesz, czy wartość, której szukasz, jest na początku lub na końcu tablicy.

Kiedy wiesz, że właśnie popchnąłeś tablicę z wartością, przy użyciu Lastindexof pozostaje prawdopodobnie najlepszym rozwiązaniem, ale jeśli musisz podróżować przez duże tablicy, a wynik może być wszędzie, może to być solidne rozwiązanie, które szybciej.

dwukierunkowy indeksowanie / lastindexof

function bidirectionalIndexOf(a, b, c, d, e){
  for(c=a.length,d=c*1; c--; ){
    if(a[c]==b) return c; //or this[c]===b
    if(a[e=d-1-c]==b) return e; //or a[e=d-1-c]===b
  }
  return -1
}

//Usage
bidirectionalIndexOf(array,'value');

Test wydajności

http://jsperf.com/Sbiusirectionalindexof.

Jako test stworzyłem tablicę z wpisami 100k.

Trzy zapytania: na początku, w środku i na końcu tablicy.

Mam nadzieję, że znajdziesz również to interesujące i przetestuj wydajność.

Uwaga: Jak widać nieznacznie zmodyfikowany funkcję contains, aby odzwierciedlić indeksowanie i wzmacniacz; Wyjście Lastindexof (tak zasadniczo true za pomocą index i false za pomocą -1). To nie powinno go skrzywdzić.

Wariant prototypu tablicy

Object.defineProperty(Array.prototype,'bidirectionalIndexOf',{value:function(b,c,d,e){
  for(c=this.length,d=c*1; c--; ){
    if(this[c]==b) return c; //or this[c]===b
    if(this[e=d-1-c] == b) return e; //or this[e=d-1-c]===b
  }
  return -1
},writable:false, enumerable:false});

// Usage
array.bidirectionalIndexOf('value');

Funkcja może być również łatwa modyfikowana, aby zwrócić true lub false lub nawet obiekt, ciąg lub cokolwiek to jest.

I tutaj jest wariant while:

function bidirectionalIndexOf(a, b, c, d){
  c=a.length; d=c-1;
  while(c--){
    if(b===a[c]) return c;
    if(b===a[d-c]) return d-c;
  }
  return c
}

// Usage
bidirectionalIndexOf(array,'value');

Jak to jest możliwe?

Myślę, że proste obliczenie uzyskania wskaźnika odzwierciedlonego w tablicy jest tak proste, że jest dwa razy szybsze niż wykonanie rzeczywistej iteracji pętli.

Oto złożony przykład wykonujący trzy kontrole na iterację, ale jest to możliwe tylko z dłuższym obliczeniami, co powoduje spowolnienie kodu.

http://jsperf.com/bidirectionalindexof/2.

19
Peter Mortensen 7 styczeń 2017, 11:42

Jeśli używasz JavaScript 1.6 lub nowszego (Firefox 1.5 lub nowszy), można użyć Array.indexof. W przeciwnym razie myślę, że skończysz z czymś podobnym do twojego oryginalnego kodu.

17
Andru Luvisi 25 październik 2008, 22:44
function inArray(elem,array)
{
    var len = array.length;
    for(var i = 0 ; i < len;i++)
    {
        if(array[i] == elem){return i;}
    }
    return -1;
} 

Zwraca indeks tablicy, jeśli zostanie znaleziony lub -1, jeśli nie znaleziono

17
mpromonet 6 wrzesień 2014, 16:22

Jeśli sprawdzasz wielokrotnie dla istnienia obiektu w tablicy, powinieneś patrzeć

  1. Utrzymywanie tablicy posortowanej przez cały czas, wykonując Sortuj wkład w tablicy (umieść nowe obiekty na właściwe miejsce)
  2. Spraw, aby aktualizować obiekty jako usuń + posortowaną operację wkładki i
  3. Użyj a Szukaj binarne Wyszukaj w swoim contains(a, obj).
16
Ztyx 5 luty 2011, 18:02

Używamy tego fragmentu (współpracujemy z obiektami, tablicami, ciągami):

/*
 * @function
 * @name Object.prototype.inArray
 * @description Extend Object prototype within inArray function
 *
 * @param {mix}    needle       - Search-able needle
 * @param {bool}   searchInKey  - Search needle in keys?
 *
 */
Object.defineProperty(Object.prototype, 'inArray',{
    value: function(needle, searchInKey){

        var object = this;

        if( Object.prototype.toString.call(needle) === '[object Object]' || 
            Object.prototype.toString.call(needle) === '[object Array]'){
            needle = JSON.stringify(needle);
        }

        return Object.keys(object).some(function(key){

            var value = object[key];

            if( Object.prototype.toString.call(value) === '[object Object]' || 
                Object.prototype.toString.call(value) === '[object Array]'){
                value = JSON.stringify(value);
            }

            if(searchInKey){
                if(value === needle || key === needle){
                return true;
                }
            }else{
                if(value === needle){
                    return true;
                }
            }
        });
    },
    writable: true,
    configurable: true,
    enumerable: false
});

Użycie:

var a = {one: "first", two: "second", foo: {three: "third"}};
a.inArray("first");          //true
a.inArray("foo");            //false
a.inArray("foo", true);      //true - search by keys
a.inArray({three: "third"}); //true

var b = ["one", "two", "three", "four", {foo: 'val'}];
b.inArray("one");         //true
b.inArray('foo');         //false
b.inArray({foo: 'val'})   //true
b.inArray("{foo: 'val'}") //false

var c = "String";
c.inArray("S");        //true
c.inArray("s");        //false
c.inArray("2", true);  //true
c.inArray("20", true); //false
16
dr.dimitru 10 wrzesień 2014, 12:12

Rozwiązanie, które działa we wszystkich nowoczesnych przeglądarkach:

function contains(arr, obj) {
  const stringifiedObj = JSON.stringify(obj); // Cache our object to not call `JSON.stringify` on every iteration
  return arr.some(item => JSON.stringify(item) === stringifiedObj);
}

Stosowanie:

contains([{a: 1}, {a: 2}], {a: 1}); // true

IE6 + Solution:

function contains(arr, obj) {
  var stringifiedObj = JSON.stringify(obj)
  return arr.some(function (item) {
    return JSON.stringify(item) === stringifiedObj;
  });
}

// .some polyfill, not needed for IE9+
if (!('some' in Array.prototype)) {
  Array.prototype.some = function (tester, that /*opt*/) {
    for (var i = 0, n = this.length; i < n; i++) {
      if (i in this && tester.call(that, this[i], i, this)) return true;
    } return false;
  };
}

Stosowanie:

contains([{a: 1}, {a: 2}], {a: 1}); // true

Dlaczego warto użyć JSON.stringify?

Array.indexOf i Array.includes (jak również większość odpowiedzi tutaj) Porównaj tylko przez odniesienie, a nie według wartości.

[{a: 1}, {a: 2}].includes({a: 1});
// false, because {a: 1} is a new object

Premia

Nieoptymalizowany ES6 One-Liner:

[{a: 1}, {a: 2}].some(item => JSON.stringify(item) === JSON.stringify({a: 1));
// true

Uwaga: Porównywanie obiektów według wartości będzie działać lepiej, jeśli klucze są w tej samej kolejności, więc być bezpiecznym, możesz najpierw posortować klucze z pakietem takim jak ten: https://www.npmjs.com/package/sort -keys


Zaktualizowano funkcję contains z optymalizacją perf. Dzięki Itinance do wskazania go.

15
Igor Barbashin 4 lipiec 2017, 23:34

Użyj Lodasha niektórych funkcji.

Jest zwięzły, dokładny i ma wspaniałe wsparcie platformy.

Akceptowana odpowiedź nie spełnia nawet wymagań.

Wymagania: Zalecaj najbardziej zwięzły i skuteczny sposób, aby dowiedzieć się, czy tablica JavaScript zawiera obiekt.

Akceptowana odpowiedź:

$.inArray({'b': 2}, [{'a': 1}, {'b': 2}])
> -1

Moje zalecenie:

_.some([{'a': 1}, {'b': 2}], {'b': 2})
> true

Uwagi:

$

$.inArray(2, [1,2])
> 1

... ale pytanie wyraźnie prosi o skuteczny sposób na określenie, czy obiekt jest zawarty w tablicy.

Aby obsługiwać zarówno skalarne, jak i przedmioty, możesz to zrobić:

(_.isObject(item)) ? _.some(ary, item) : (_.indexOf(ary, item) > -1)
12
l3x 21 październik 2015, 11:58

ECMASCRIPT 6 ma elegancką propozycję na stronie.

Metoda wyszukiwania wykonuje funkcję wywołania wywołania raz na każdym elemencie obecnym w tablicy, dopóki nie znajdzie, w którym Callback zwraca wartość prawdziwej wartości. Jeśli taki element zostanie znaleziony, natychmiast zwraca wartość tego elementu. W przeciwnym razie znajdź zwroty niezdefiniowane. Callback jest wywoływany tylko dla indeksów tablicy, które mają przypisane wartości; Nie jest wywołany dla indeksów, które zostały usunięte lub które nigdy nie zostały przydzielone.

Oto Dokumentacja MDN.

Funkcjonalność Find działa w ten sposób.

function isPrime(element, index, array) {
    var start = 2;
    while (start <= Math.sqrt(element)) {
        if (element % start++ < 1) return false;
    }
    return (element > 1);
}

console.log( [4, 6, 8, 12].find(isPrime) ); // Undefined, not found
console.log( [4, 5, 8, 12].find(isPrime) ); // 5

Możesz użyć tego w ECMAScript 5 i poniżej przez Definiowanie funkcji.

if (!Array.prototype.find) {
  Object.defineProperty(Array.prototype, 'find', {
    enumerable: false,
    configurable: true,
    writable: true,
    value: function(predicate) {
      if (this == null) {
        throw new TypeError('Array.prototype.find called on null or undefined');
      }
      if (typeof predicate !== 'function') {
        throw new TypeError('predicate must be a function');
      }
      var list = Object(this);
      var length = list.length >>> 0;
      var thisArg = arguments[1];
      var value;

      for (var i = 0; i < length; i++) {
        if (i in list) {
          value = list[i];
          if (predicate.call(thisArg, value, i, list)) {
            return value;
          }
        }
      }
      return undefined;
    }
  });
}
10
Peter Mortensen 7 styczeń 2017, 11:27

Podczas gdy array.indexOf(x)!=-1 jest najbardziej zwięzłym sposobem na to (i został wspierany przez przeglądarki eksploratora innych niż Internet przez ponad dekadę ...), nie jest to O (1), ale raczej o (n), co jest straszny. Jeśli twoja tablica nie zmieni się, możesz przekonwertować tablicę do hashtable, a następnie zrobić table[x]!==undefined lub ===undefined:

Array.prototype.toTable = function() {
    var t = {};
    this.forEach(function(x){t[x]=true});
    return t;
}

Próbny:

var toRemove = [2,4].toTable();
[1,2,3,4,5].filter(function(x){return toRemove[x]===undefined})

(Niestety, podczas gdy można utworzyć tablicę Niech Trzymaj ten stan, w przeciwieństwie do Pythona na przykład.)

10
Peter Mortensen 7 styczeń 2017, 11:30

Można korzystać () ":

function contains(arr, obj) {
      var proxy = new Set(arr);
      if (proxy.has(obj))
        return true;
      else
        return false;
    }

    var arr = ['Happy', 'New', 'Year'];
    console.log(contains(arr, 'Happy'));
9
Super Man 24 styczeń 2020, 12:16

Posługiwać się:

var myArray = ['yellow', 'orange', 'red'] ;

alert(!!~myArray.indexOf('red')); //true

Próbny

Wiedzieć dokładnie, co robi tilde ~ ~, odnoszą się do tego pytania Co robi tylda, gdy poprzedza wyrażenie? .

8
Community 23 maj 2017, 12:03

OK, możesz tylko zoptymalizować kod , aby uzyskać wynik!

Istnieje wiele sposobów, aby to zrobić, które są czystsze i lepsze, ale chciałem tylko zdobyć twój wzór i zastosować do tego przy użyciu JSON.stringify, po prostu robisz coś w ten sposób w swoim przypadku:

function contains(a, obj) {
    for (var i = 0; i < a.length; i++) {
        if (JSON.stringify(a[i]) === JSON.stringify(obj)) {
            return true;
        }
    }
    return false;
}
7
Alireza 6 luty 2019, 14:48

Proste rozwiązanie dla tego wymagania jest użycie find()

Jeśli masz tablicę obiektów takich jak poniżej,

var users = [{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "admin"},
{id: "105", name: "user"}];

Następnie możesz sprawdzić, czy obiekt z twoją wartością jest już obecny, czy nie

let data = users.find(object => object['id'] === '104');

Jeśli dane są null, nie ma administratora, w przeciwnym razie zwróci istniejący obiekt taki jak poniżej.

{id: "104", name: "admin"}

Następnie znajdziesz indeks tego obiektu w tablicy i wymień obiekt za pomocą poniższego kodu.

let indexToUpdate = users.indexOf(data);
let newObject = {id: "104", name: "customer"};
users[indexToUpdate] = newObject;//your new object
console.log(users);

Otrzymasz wartość jak poniżej

[{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "customer"},
{id: "105", name: "user"}];

Mam nadzieję, że to pomoże każdemu.

7
Shiva 11 październik 2019, 17:38

Zaskoczony, że to pytanie nadal nie ma najnowszej składni dodanej, dodając moje 2 centy.

Powiedzmy, że mamy tablicę obiektów Arrobj i chcemy szukać w nim OBJ.

Array.prototype. indexof - & gt; (Powraca indeks lub -1 ) jest zwykle używany do wyszukiwania indeksu elementu w tablicy. Może to być również używane do wyszukiwania obiektu, ale działa tylko wtedy, gdy przekazywasz odniesienie do tego samego obiektu.

let obj = { name: 'Sumer', age: 36 };
let arrObj = [obj, { name: 'Kishor', age: 46 }, { name: 'Rupen', age: 26 }];


console.log(arrObj.indexOf(obj));// 0
console.log(arrObj.indexOf({ name: 'Sumer', age: 36 })); //-1

console.log([1, 3, 5, 2].indexOf(2)); //3

Array.prototype. obejmuje - & gt; (Zwraca true lub false )

console.log(arrObj.includes(obj));  //true
console.log(arrObj.includes({ name: 'Sumer', age: 36 })); //false

console.log([1, 3, 5, 2].includes(2)); //true

Array.prototype. znajdź - & gt; (Zyskiwanie wywołania zwrotnego, zwraca pierwszy wartość / obiekt , który zwraca true w CB).

console.log(arrObj.find(e => e.age > 40));  //{ name: 'Kishor', age: 46 }
console.log(arrObj.find(e => e.age > 40)); //{ name: 'Kishor', age: 46 }

console.log([1, 3, 5, 2].find(e => e > 2)); //3

Array.prototype. findindex - & gt; (Zyskiwanie wywołania zwrotnego, zwraca indeks pierwszej wartości / obiektu, który zwraca prawdziwy w CB).

console.log(arrObj.findIndex(e => e.age > 40));  //1
console.log(arrObj.findIndex(e => e.age > 40)); //1

console.log([1, 3, 5, 2].findIndex(e => e > 2)); //1

Od czasu znalezienia i findindex wymaga zwrotu pieniędzy, możemy być pobraniem dowolnego obiektu (nawet jeśli nie mamy odniesienia) od tablicy, twórczo ustawiając prawdziwy stan.

6
Sumer 7 kwiecień 2019, 13:42
    function countArray(originalArray) {
     
    	var compressed = [];
    	// make a copy of the input array
    	var copyArray = originalArray.slice(0);
     
    	// first loop goes over every element
    	for (var i = 0; i < originalArray.length; i++) {
     
    		var count = 0;	
    		// loop over every element in the copy and see if it's the same
    		for (var w = 0; w < copyArray.length; w++) {
    			if (originalArray[i] == copyArray[w]) {
    				// increase amount of times duplicate is found
    				count++;
    				// sets item to undefined
    				delete copyArray[w];
    			}
    		}
     
    		if (count > 0) {
    			var a = new Object();
    			a.value = originalArray[i];
    			a.count = count;
    			compressed.push(a);
    		}
    	}
     
    	return compressed;
    };
    
    // It should go something like this:
    
    var testArray = new Array("dog", "dog", "cat", "buffalo", "wolf", "cat", "tiger", "cat");
    var newArray = countArray(testArray);
    console.log(newArray);
6
Super Man 24 styczeń 2020, 12:01