Sprawdź, czy ciąg jest na liście w JavaScript

W SQL możemy sprawdzić, czy ciąg znajduje się na liście w taki sposób:

Column IN ('a', 'b', 'c')

Jaki jest dobry sposób na to w JavaScript? To takie niezręczne:

if (expression1 || expression2 || str === 'a' || str === 'b' || str === 'c') {
   // do something
}

Nie jestem pewien co do wydajności ani przejrzystości tego:

if (expression1 || expression2 || {a:1, b:1, c:1}[str]) {
   // do something
}

Lub można użyć funkcji przełączania:

var str = 'a',
   flag = false;

switch (str) {
   case 'a':
   case 'b':
   case 'c':
      flag = true;
   default:
}

if (expression1 || expression2 || flag) {
   // do something
}

Ale to okropny bałagan. Jakieś pomysły?

W takim przypadku muszę użyć programu Internet Explorer 7, ponieważ jest on przeznaczony dla firmowej strony intranetowej. Więc ['a', 'b', 'c'].indexOf(str) !== -1nie będzie działać natywnie bez cukru składniowego.

Możesz zadzwonić indexOf:

if (['a', 'b', 'c'].indexOf(str) >= 0) {
    //do something
}

EcmaScript 6

Jeśli używasz ES6, możesz zbudować tablicę przedmiotów i użyć includes:

['a', 'b', 'c'].includes('b')

Ma to pewne nieodłączne zalety, indexOfponieważ może poprawnie przetestować obecność NaNna liście i może dopasować brakujące elementy tablicy, takie jak środkowy [1, , 2]do undefined. includesdziała również na tablicach typu JavaScript, takich jak Uint8Array.

Jeśli martwisz się o obsługę przeglądarki (np. IE lub Edge), możesz to sprawdzić Array.includesna CanIUse.Com , a jeśli chcesz kierować na przeglądarkę lub brakującą wersję przeglądarki includes, polecam polyfill.io do wypełniania.

Bez szyku

Możesz dodać nową isInListwłaściwość do ciągów w następujący sposób:

if (!String.prototype.isInList) {
   String.prototype.isInList = function() {
      let value = this.valueOf();
      for (let i = 0, l = arguments.length; i < l; i += 1) {
         if (arguments[i] === value) return true;
      }
      return false;
   }
}

Następnie użyj go w następujący sposób:

'fox'.isInList('weasel', 'fox', 'stoat') // true
'fox'.isInList('weasel', 'stoat') // false

Możesz zrobić to samo dla Number.prototype.

Array.indexOf

Jeśli korzystasz z nowoczesnej przeglądarki, indexOfzawsze działa. Jednak w IE8 i wcześniejszych wersjach będziesz potrzebować wielokrotnego wypełnienia.

Jeśli indexOfzwraca -1, pozycji nie ma na liście. Pamiętaj jednak, że ta metoda nie sprawdza poprawnie NaNi chociaż może dopasować jawne undefined, nie może dopasować brakującego elementu do undefinedjak w tablicy [1, , 2].

Wielokrotne wypełnianie dla indexOflub includesw IE, lub dowolnej innej przeglądarce / wersji bez wsparcia

Jeśli nie chcesz korzystać z usługi takiej jak polyfill.io, jak wspomniano powyżej, zawsze możesz zawrzeć w swoim własnym kodzie źródłowym niestandardowe polypełniacze zgodne z normami. Na przykład Mozilla Developer Network ma jeden dla indexOf.

W tej sytuacji, w której musiałem stworzyć rozwiązanie dla Internet Explorera 7, „opracowałem własną” prostszą wersję indexOf()funkcji, która nie jest zgodna ze standardami:

if (!Array.prototype.indexOf) {
   Array.prototype.indexOf = function(item) {
      var i = this.length;
      while (i--) {
         if (this[i] === item) return i;
      }
      return -1;
   }
}

Nie sądzę jednak, aby modyfikowanie Array.prototypebyło najlepszą odpowiedzią na dłuższą metę. Modyfikowanie Objecti tworzenie Arrayprototypów w JavaScript może prowadzić do poważnych błędów. Musisz zdecydować, czy jest to bezpieczne we własnym środowisku. Najważniejszą rzeczą jest to, że iteracja tablicy (gdy Array.prototype ma właściwości) for ... inzwróci nową nazwę funkcji jako jeden z kluczy:

Array.prototype.blah = function() { console.log('blah'); };
let arr = [1, 2, 3];
for (let x in arr) { console.log(x); }
// Result:
0
1
2
blah // Extra member iterated over!

Twój kod może już działać, ale w momencie, gdy ktoś w przyszłości doda bibliotekę JavaScript lub wtyczkę innej firmy, która nie gorliwie chroni przed odziedziczonymi kluczami, wszystko może się zepsuć.

Starym sposobem uniknięcia tego zerwania jest, podczas wyliczania, sprawdzenie każdej wartości, aby sprawdzić, czy obiekt rzeczywiście ma ją jako właściwość nieprzechowaną, if (arr.hasOwnProperty(x))i tylko z nią pracować x.

Nowy ES6 sposobem na uniknięcie tego problemu dodatkowy klucz jest użycie ofzamiast in, for (let x of arr). Jednakże, chyba że możesz zagwarantować, że cały twój kod i biblioteki stron trzecich ściśle trzymają się tej metody, to do celów tego pytania prawdopodobnie po prostu będziesz chciał użyć, includesjak podano powyżej.

Większość odpowiedzi sugeruje Array.prototype.indexOfmetodę, jedynym problemem jest to, że nie będzie działać na żadnej wersji IE przed IE9.

Alternatywnie pozostawiam ci dwie dodatkowe opcje, które będą działać na wszystkich przeglądarkach:

if (/Foo|Bar|Baz/.test(str)) {
  // ...
}


if (str.match("Foo|Bar|Baz")) {
  // ...
}

Tablice mają indexOfmetodę, za pomocą której można wyszukiwać ciągi:

js> a = ['foo', 'bar', 'baz']
foo,bar,baz
js> a.indexOf('bar')
1
js> a.indexOf('quux')
-1

Trik, którego użyłem, to

>>> ("something" in {"a string":"", "somthing":"", "another string":""})
false
>>> ("something" in {"a string":"", "something":"", "another string":""})
true

Możesz zrobić coś takiego

>>> a = ["a string", "something", "another string"];
>>> b = {};
>>> for(var i=0; i<a.length;i++){b[a[i]]="";} /* Transform the array in a dict */
>>> ("something" in b)
true

To moje:

String.prototype.inList=function(list){
    return (Array.apply(null, arguments).indexOf(this.toString()) != -1)
}

var x = 'abc';
if (x.inList('aaa','bbb','abc'))
    console.log('yes');
else
    console.log('no');

Ten jest szybszy, jeśli jesteś w stanie przekazać tablicę:

String.prototype.inList=function(list){
    return (list.indexOf(this.toString()) != -1)
}

var x = 'abc';
if (x.inList(['aaa','bbb','abc']))
    console.log('yes')

Oto jsperf: http://jsperf.com/bmcgin-inlsit

RegExpjest uniwersalny, ale rozumiem, że pracujesz z tablicami. Sprawdź to podejście. Używam go, a to jest bardzo skuteczne i płonące szybko!

var str = 'some string with a';
var list = ['a', 'b', 'c'];
var rx = new RegExp(list.join('|'));

rx.test(str);

Możesz także zastosować pewne modyfikacje, np .:

Jednowarstwowa

new RegExp(list.join('|')).test(str);

Bez względu na wielkość liter

var rx = new RegExp(list.join('|').concat('/i'));

I wiele innych!

Korzystanie z indexOf (nie działa z IE8).

if (['apple', 'cherry', 'orange', 'banana'].indexOf(value) >= 0) {
    // found
}

Aby wesprzeć IE8, możesz zaimplementować indexOf Mozilli.

if (!Array.prototype.indexOf) {
    // indexOf polyfill code here
}

Wyrażenia regularne za pośrednictwem String.prototype.match (docs).

if (fruit.match(/^(banana|lemon|mango|pineapple)$/)) {

}

Wygląda na to, że musisz użyć funkcji in_array.

jQuery -> inArray

Prototyp -> Array.indexOf

Lub zobacz poniższe przykłady, jeśli nie używasz jQuery lub Prototype:

• http://phpjs.org/functions/in_array:432
• http://www.bitrepository.com/equivalent-of-phps-in_array-function.html
• http://codingforums.com/showthread.php?t=63796

Uwaga stylistyczna: zmienne o nazwie thisthing thatthing, powinny być nazwane, aby powiedzieć ci coś o tym, co zawierają (rzecz.).

Oprócz indexOf(które sugerują inne plakaty) użycie Enumerable.include () prototypu może uczynić to bardziej schludnym i zwięzłym:

var list = ['a', 'b', 'c'];
if (list.include(str)) {
  // do stuff
}

Dzięki za pytanie i rozwiązanie za pomocą metody Array.indexOf.

Użyłem kodu z tego rozwiązania, aby utworzyć funkcję inList (), która, IMO, uprościłaby pisanie, a odczyt był jaśniejszy:

function inList(psString, psList) 
{
    var laList = psList.split(',');

    var i = laList.length;
    while (i--) {
        if (laList[i] === psString) return true;
    }
    return false;
}

STOSOWANIE:

if (inList('Houston', 'LA,New York,Houston') {
  // THEN do something when your string is in the list
}

Dziwi mnie, że nikt nie wspomniał o prostej funkcji, która pobiera ciąg znaków i listę.

function in_list(needle, hay)
{
    var i, len;

    for (i = 0, len = hay.length; i < len; i++)
    {
        if (hay[i] == needle) { return true; }
    }

    return false;
}

var alist = ["test"];

console.log(in_list("test", alist));

Moje rozwiązanie daje następującą składnię:

// Checking to see if var 'column' is in array ['a', 'b', 'c']

if (column.isAmong(['a', 'b', 'c']) {
  // Do something
}

I implementuję to poprzez rozszerzenie podstawowego prototypu Object, jak poniżej:

Object.prototype.isAmong = function (MyArray){
   for (var a=0; a<MyArray.length; a++) {
      if (this === MyArray[a]) { 
          return true;
      }
   }
   return false;
}

Alternatywnie możemy nazwać metodę isInArray (ale prawdopodobnie nie inArray) lub po prostu isIn.

Zalety: Prosty, prosty i samodokumentujący.

Uproszczona wersja odpowiedzi SLaks działa również:

if ('abcdefghij'.indexOf(str) >= 0) {
    // Do something
}

.... ponieważ ciągi są rodzajem samych tablic. :)

W razie potrzeby zaimplementuj funkcję indexof dla Internet Explorera zgodnie z wcześniejszym opisem.