Aktualizacja: jak wspomina @orip w komentarzach, powiązany benchmark został wykonany w 2008 roku, więc wyniki mogą nie być istotne dla nowoczesnych przeglądarek. Jednak prawdopodobnie potrzebujesz tego, aby obsługiwać nienowoczesne przeglądarki i prawdopodobnie nie zostały zaktualizowane od tego czasu. Zawsze testuj dla siebie.

Jak mówili inni, iteracja poprzez tablicę jest prawdopodobnie najlepszym sposobem, ale zostało udowodnione że zmniejszająca się pętla while jest najszybszym sposobem iteracji w JavaScript. Więc możesz chcesz przepisać 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 równie dobrze możesz rozszerzyć prototyp tablicy:

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ącego:

alert([1, 2, 3].contains(2)); // => true
alert([1, 2, 3].contains('2')); // => false

indexOf może, ale jest to " rozszerzenie JavaScript do standardu ECMA-262; jako takie może nie być obecne w innych implementacjach standardu."

Przykład:

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

AFAICS Microsoft nie oferuje jakiejś alternatywy do tego, ale możesz dodać podobną funkcjonalność do tablic w Internet Explorerze (i innych przeglądarkach, które nie obsługują indexOf), jeśli chcesz, ponieważ szybkie wyszukiwanie Google ujawnia (na przykład, to jeden ).

ECMAScript 7 wprowadza Array.prototype.includes.

Można go używać w następujący sposób:

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

Przyjmuje 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 ścisłego porównania równości, includes porównuje za pomocą algorytmu równości SameValueZero. Oznacza to, że możesz wykryć, czy tablica zawiera NaN:

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

Również w przeciwieństwie do indexOf, includes nie pomija brakujących indeksów:

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

Obecnie jest to jeszcze szkic ale może być polyfilled , aby działał na wszystkich przeglądarkach.

b jest wartością, a a jest tablicą. Zwraca true lub false:

function(a, b) {
    return a.indexOf(b) != -1
}

Oto JavaScript 1.6 zgodny 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;
      };
}

Użycie:

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

// Usage
if(isInArray(my_array, "my_value"))
{
    //...
}

Górne odpowiedzi przyjmują prymitywne typy, ale jeśli chcesz dowiedzieć się, czy tablica zawiera obiekt z jakąś cechą, Array.prototyp.niektóre () 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

Fajne w tym jest to, że iteracja jest przerywana po znalezieniu elementu, więc niepotrzebne cykle iteracji są zapisywane.

Pasuje również do instrukcji if, ponieważ zwraca wartość logiczną:

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

* Jak zauważył jamess w komentarzu, stan na dziś, wrzesień 2018, Array.prototype.some() jest w pełni obsługiwane: caniuse.com tabela wsparcia

Rozszerzenie obiektu JavaScript Array jest naprawdę złym pomysłem, ponieważ wprowadzasz nowe właściwości (własne metody) do pętli for-in, które mogą łamać istniejące Skrypty. Kilka lat temu autorzy prototyp biblioteki musieli przeprojektować implementację biblioteki, aby usunąć tego typu rzeczy.

Jeśli nie musisz martwić się o kompatybilność z innymi JavaScript uruchomionych na stronie, idź do niego, w przeciwnym razie, polecam bardziej niewygodne, ale bezpieczniejsze rozwiązanie funkcji wolnostojącej.

Myśląc przez chwilę po wyjęciu z pudełka, jeśli wykonujesz to wywołanie wiele razy, znacznie bardziej wydajne jest użycie tablicy asocjacyjnej mapy do wyszukiwania za pomocą funkcji hash.

Https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map

One-liner:

function contains(arr, x) {
    return arr.filter(function(elem) { return elem == x }).length > 0;
}

Używam:

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

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

a.contains('foo'); // true
a.contains('fox'); // false

function contains(a, obj) {
    return a.some(function(element){return element == obj;})
}

/ align = "left" / prototyp.niektóre () zostały dodane do standardu ECMA-262 w piątej edycji

Mam nadzieję, że szybszy dwukierunkowy indexOf / lastIndexOf alternatywa

2015

Podczas gdy nowa metoda zawiera jest bardzo ładna, wsparcie jest w zasadzie zero na razie.

Długo myślałem o sposobie zastąpienia powolnych funkcji indexOf/lastIndexOf.

Znaleziono już sposób wykonania, patrząc na najlepsze odpowiedzi. Z nich wybrałem funkcję contains napisaną przez @ Damir Zekic, która powinna być najszybsza. Ale także stwierdza, że poziomy odniesienia pochodzą z 2008 r. i dlatego są nieaktualne.

Ja też wolę while niż for, ale z nie konkretnego powodu zakończyłem pisanie funkcji pętlą for. Można to również zrobić za pomocą while --.

Byłem ciekaw, czy iteracja jest znacznie wolniejsza, jeśli sprawdzam obie strony tablicy podczas jej wykonywania. Widocznie nie, a więc ta funkcja jest około dwa razy szybsza od najlepszych. Oczywiście jest też szybszy od rodzimego. To w prawdziwym świecie środowisko, w którym nigdy nie wiadomo, czy szukana wartość znajduje się na początku czy na końcu tablicy.

Kiedy wiesz, że właśnie wypchnąłeś tablicę z wartością, użycie lastIndexOf pozostaje prawdopodobnie najlepszym rozwiązaniem, ale jeśli musisz podróżować przez duże tablice, a wynik może być wszędzie, może to być solidne rozwiązanie, aby przyspieszyć działanie.

Bidirectional indexOf / 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');

Wydajność test

Http://jsperf.com/bidirectionalindexof

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

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

Mam nadzieję, że również uznacie to za interesujące i przetestujecie wydajność.

Uwaga: jak widzisz nieznacznie zmodyfikowałem funkcję contains, aby odzwierciedlała wyjście indexOf & lastIndexOf (więc zasadniczo true z index i false z -1). To nie powinno zaszkodzić to.

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ż łatwo zmodyfikowana, aby zwracać true lub false, a nawet obiekt, łańcuch lub cokolwiek to jest.

A oto 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');

Myślę, że proste obliczenie, aby uzyskać odzwierciedlony indeks w tablicy jest tak proste, że jest dwa razy szybsze niż wykonanie rzeczywistej iteracji pętli.

Oto złożony przykład wykonywania trzech kontroli na iteracji, ale jest to możliwe tylko przy dłuższych obliczeniach, co powoduje spowolnienie kodu.

Http://jsperf.com/bidirectionalindexof/2

Jeśli sprawdzasz wielokrotnie istnienie obiektu w tablicy, powinieneś zajrzeć do

1. utrzymywanie sortowania tablicy przez cały czas wykonując sortowanie wstawiania w tablicy (umieszczanie nowych obiektów w odpowiednim miejscu)
2. Make updating objects as remove+posorted insert operation and
3. Użyj wyszukiwania binarnego w contains(a, obj).

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 zostanie znaleziony

Używamy tego fragmentu (działa z obiektami, tablicami, łańcuchami):

/*
 * @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

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

Użyj funkcji lodash , .

Jest zwięzły, dokładny i ma świetne wsparcie między platformami.

Przyjęta odpowiedź nie spełnia nawet wymagań.

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

Zaakceptowana Odpowiedź:

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

Moja rekomendacja:

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

Uwagi:

$.inArray działa dobrze w celu ustalenia, czy Skalar wartość istnieje w tablicy skalarów...

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

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

Aby obsłużyć zarówno Skalary, jak i Obiekty, możesz to zrobić:

(_.isObject(item)) ? _.some(ary, item) : (_.indexOf(ary, item) > -1)

Podczas gdy array.indexOf(x)!=-1 jest najbardziej zwięzły sposób, aby to zrobić (i jest obsługiwany przez przeglądarki Nie - Internet Explorer od ponad dekady...), to nie jest O(1), ale raczej O(N), co jest straszne. Jeśli tablica nie będzie się zmieniać, możesz przekonwertować tablicę na hashtable, następnie wykonaj table[x]!==undefined lub ===undefined:

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

Demo:

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

(niestety, podczas gdy można utworzyć tablicę.prototyp.zawiera, aby" zamrozić " tablicę i zapisać w niej hashtable._cache w dwóch linijkach, dałoby to błędne wyniki jeśli później zdecydujesz się edytować tablicę. JavaScript ma niewystarczające Hooki, aby utrzymać ten stan, w przeciwieństwie do Pythona na przykład.)

ECMAScript 6 ma elegancką propozycję na find.

Metoda find wykonuje funkcję wywołania zwrotnego raz dla każdego elementu obecny w tablicy, dopóki nie znajdzie takiej, w której callback zwraca true wartość. Jeśli taki element zostanie znaleziony, find natychmiast zwraca wartość tego pierwiastka. W przeciwnym razie find zwraca undefined. callback jest wywoływane tylko dla indeksów tablicy, które mają przypisane wartości; to nie jest wywoływany dla indeksów, które zostały usunięte lub które nigdy przypisano wartości.

Oto dokumentacja MDN na ten temat.

Funkcja Znajdź 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 zdefiniowanie 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;
    }
  });
}

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

Użycie:

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

IE6+ rozwiązanie:

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

Użycie:

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

Dlaczego używać JSON.stringify?

Array.indexOf i Array.includes (jak również większość odpowiedzi tutaj) porównać tylko przez odniesienie, a nie przez wartość.

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

Bonus

Nie zoptymalizowany ES6 jednowierszowy:

[{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 dla bezpieczeństwa można sortować klucze najpierw z pakietem takim jak ten: https://www.npmjs.com/package/sort-keys

Zaktualizowano funkcję contains o optymalizację perf. Dzięki za wskazówkę.

Użycie:

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

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

Demo

Aby dokładnie wiedzieć, co tilde ~ czy w tym momencie, odnieść się do tego pytania co robi tylda, gdy poprzedza wyrażenie?.

Oto jak Prototype to robi :

/**
 *  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 — 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;
}

Zobacz także Tutaj , aby dowiedzieć się, jak to podłączyć.

Użycie:

Array.prototype.contains = function(x){
  var retVal = -1;

  // x is a primitive type
  if(["string","number"].indexOf(typeof x)>=0 ){ retVal = this.indexOf(x);}

  // x is a function
  else if(typeof x =="function") for(var ix in this){
    if((this[ix]+"")==(x+"")) retVal = ix;
  }

  //x is an object...
  else {
    var sx=JSON.stringify(x);
    for(var ix in this){
      if(typeof this[ix] =="object" && JSON.stringify(this[ix])==sx) retVal = ix;
    }
  }

  //Return False if -1 else number if numeric otherwise string
  return (retVal === -1)?false : ( isNaN(+retVal) ? retVal : +retVal);
}

Wiem, że to nie jest najlepszy sposób, ale ponieważ nie ma natywnego, porównywalnego sposobu interakcji między obiektami, myślę, że jest to tak blisko, jak można uzyskać, aby porównać dwa encje w tablicy. Ponadto rozszerzenie obiektu tablicy może nie być mądrą rzeczą do zrobienia, ale czasami jest OK(jeśli wiesz o tym i o kompromisie).

Można użyć zestawu , który ma metodę " has ()":

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

Możesz również użyć tej sztuczki:

var arrayContains = function(object) {
  return (serverList.filter(function(currentObject) {
    if (currentObject === object) {
      return currentObject
    }
    else {
      return false;
    }
  }).length > 0) ? true : false
}

OK, możesz po prostu zoptymalizować swój kod, Aby uzyskać wynik! Istnieje wiele sposobów, aby to zrobić, które są czystsze i lepsze, ale po prostu chciałem uzyskać Twój wzór i zastosować do tego za pomocą JSON.stringify, po prostu zrób coś takiego w Twoim 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;
}

Jak już wspomnieli inni, możesz użyć Array.indexOf, ale nie jest on dostępny we wszystkich przeglądarkach. Oto kod z https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf aby działał tak samo w starszych przeglądarkach.

IndexOf jest ostatnim dodatkiem do standardu ECMA-262; jako taki może nie być obecne we wszystkich przeglądarkach. Możesz obejść to, wstawiając poniższy kod na początku skryptów, umożliwiający korzystanie z indexOf w implementacjach, które nie wspierają go natywnie. To algorytm jest dokładnie ten określony w ECMA - 262, wydanie 5, zakładając obiekt, TypeError, liczbę, matematykę.podłoga, Matematyka.abs i matematyka.max mają swoją pierwotną wartość.

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
        "use strict";
        if (this == null) {
            throw new TypeError();
        }
        var t = Object(this);
        var len = t.length >>> 0;
        if (len === 0) {
            return -1;
        }
        var n = 0;
        if (arguments.length > 1) {
            n = Number(arguments[1]);
            if (n != n) { // shortcut for verifying if it's NaN
                n = 0;
            } else if (n != 0 && n != Infinity && n != -Infinity) {
                n = (n > 0 || -1) * Math.floor(Math.abs(n));
            }
        }
        if (n >= len) {
            return -1;
        }
        var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
        for (; k < len; k++) {
            if (k in t && t[k] === searchElement) {
                return k;
            }
        }
        return -1;
    }
}

Bynajmniej nie najlepszy, ale zaczynałem być kreatywny i dodawać do repertuaru.

Nie używaj tego

Object.defineProperty(Array.prototype, 'exists', {
  value: function(element, index) {

    var index = index || 0

    return index === this.length ? -1 : this[index] === element ? index : this.exists(element, ++index)
  }
})


// Outputs 1
console.log(['one', 'two'].exists('two'));

// Outputs -1
console.log(['one', 'two'].exists('three'));

console.log(['one', 'two', 'three', 'four'].exists('four'));