Powiedzmy, że mam to:

var blockedTile = new Array("118", "67", "190", "43", "135", "520");

Jest więcej elementów tablicy, ale to tylko kilka ze względu na czytelność. Tak czy inaczej, mógłbym zrobić pętlę „for”, ale wykonałoby to 500 pętli za każdym razem, gdy klikniesz mapę ... czy istnieje inny sposób sprawdzenia, czy określony ciąg znajduje się w tablicy?

Spróbuj tego:

if(blockedTile.indexOf("118") != -1)
{  
   // element found
}

Jak wspomniano wcześniej, jeśli Twoja przeglądarka obsługuje indexOf(), świetnie! Jeśli nie, musisz go pollyfil lub polegać na pasku narzędziowym, takim jak lodash / underscore .

Chciałem tylko dodać ten nowszy dodatek ES2016 (aby zaktualizować to pytanie):

Array.prototype.includes ()

if (blockedTile.includes("118")) {
    // found element
}

function in_array(needle, haystack){
    var found = 0;
    for (var i=0, len=haystack.length;i<len;i++) {
        if (haystack[i] == needle) return i;
            found++;
    }
    return -1;
}
if(in_array("118",array)!= -1){
//is in array
}

Użyj Underscore.js

Jest zgodny z różnymi przeglądarkami i może przeprowadzać wyszukiwanie binarne, jeśli dane są posortowane.

_.indeks

_.indexOf (tablica, wartość, [posortowany]) Zwraca indeks, przy którym wartość można znaleźć w tablicy lub -1, jeśli wartość nie jest obecna w tablicy. Używa natywnej funkcji indexOf, chyba że jej brakuje. Jeśli pracujesz z dużą tablicą i wiesz, że tablica jest już posortowana, przekaż wartość true dla isSorted, aby użyć szybszego wyszukiwania binarnego.

Przykład

//Tell underscore your data is sorted (Binary Search)
if(_.indexOf(['2','3','4','5','6'], '4', true) != -1){
    alert('true');
}else{
    alert('false');   
}

//Unsorted data works to!
if(_.indexOf([2,3,6,9,5], 9) != -1){
    alert('true');
}else{
    alert('false');   
}

Niektóre przeglądarki obsługują Array.indexOf().

Jeśli nie, możesz ulepszyć Arrayobiekt za pomocą jego prototypu w ten sposób ...

if (!Array.prototype.indexOf)
{
  Array.prototype.indexOf = function(searchElement /*, fromIndex */)
  {
    "use strict";

    if (this === void 0 || 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 > 0)
    {
      n = Number(arguments[1]);
      if (n !== n) // shortcut for verifying if it's NaN
        n = 0;
      else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0))
        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;
  };
}

Źródło .

Po prostu użyj według własnego gustu:

var blockedTile = [118, 67, 190, 43, 135, 520];

// includes (js)

if ( blockedTile.includes(118) ){
    console.log('Found with "includes"');
}

// indexOf (js)

if ( blockedTile.indexOf(67) !== -1 ){
    console.log('Found with "indexOf"');
}

// _.indexOf (Underscore library)

if ( _.indexOf(blockedTile, 43, true) ){
    console.log('Found with Underscore library "_.indexOf"');
}

// $.inArray (jQuery library)

if ( $.inArray(190, blockedTile) !== -1 ){
    console.log('Found with jQuery library "$.inArray"');
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

if(array.indexOf("67") != -1) // is in array

Najlepszym sposobem na to w 2019 roku jest użycie .includes()

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

Pierwszy parametr to to, czego szukasz. Drugi parametr to pozycja indeksu w tej tablicy, od której należy rozpocząć wyszukiwanie.

Jeśli musisz być tutaj crossbrowsy - istnieje wiele starszych odpowiedzi.

Odpowiedziałem już powyżej, ale chciałem się podzielić.

Jednak nie będzie działać w IE. dzięki za wspomnienie o tym @Mahmoud

var array1 = [1, 2, 3];

console.log(array1.includes(2));
// expected output: true

var pets = ['cat', 'dog', 'bat'];

console.log(pets.includes('cat'));
// expected output: true

console.log(pets.includes('at'));
// expected output: false

Mam tutaj odniesienie . mają również Polyfill powyżej.

W zależności od dostępnej wersji JavaScript możesz użyć indexOf:

Zwraca pierwszy indeks, w którym dany element można znaleźć w tablicy lub -1, jeśli go nie ma.

Lub some:

Sprawdza, czy jakiś element w tablicy przechodzi test zaimplementowany przez podaną funkcję.

Ale jeśli robisz tego rodzaju istnienie, sprawdzaj dużo, lepiej byłoby użyć Object do przechowywania twoich ciągów (lub być może obiektu, a także tablicy, w zależności od tego, co robisz ze swoimi danymi).

Użyłbym innej struktury danych, ponieważ tablica wydaje się nie być najlepszym rozwiązaniem.

Zamiast tablicy użyj obiektu jako tablicy skrótów, na przykład:

(opublikowane również w jsbin )

var arr = ["x", "y", "z"];
var map = {};
for (var k=0; k < arr.length; ++k) {
  map[arr[k]] = true;
}

function is_in_map(key) {
  try {
    return map[key] === true;
  } catch (e) {
    return false;
  }
}


function print_check(key) {
  console.log(key + " exists? - " + (is_in_map(key) ? "yes" : "no"));
}

print_check("x");
print_check("a");

Wyjście konsoli:

x exists? - yes
a exists? - no

To proste rozwiązanie. Jeśli bardziej interesuje Cię podejście obiektowe, wyszukaj w Google „js hashtable” .

IMHO najbardziej kompatybilny ze starszymi przeglądarkami

Array.prototype.inArray = function( needle ){

    return Array(this).join(",").indexOf(needle) >-1;

}

var foods = ["Cheese","Onion","Pickle","Ham"];
test = foods.inArray("Lemon");
console.log( "Lemon is " + (test ? "" : "not ") + "in the list." );

Zamieniając kopię Array w ciąg CSV, możesz przetestować ciąg w starszych przeglądarkach.

Dlaczego nie używasz Array.filter?

var array = ['x','y','z'];
array.filter(function(item,index,array){return(item==YOURVAL)}).

Po prostu skopiuj to do swojego kodu i gotowe:

Array.prototype.inArray = function (searchedVal) {
return this.filter(function(item,index,array){return(item==searchedVal)}).length==true
}

w przykładzie tablicy, to samo w php (in_array)

 var ur_fit = ["slim_fit", "tailored", "comfort"];
 var ur_length = ["length_short", "length_regular", "length_high"];
    if(ur_fit.indexOf(data_this)!=-1){
        alert("Value is avail in ur_fit array");
    }
    else if(ur_length.indexOf(data_this)!=-1){      
         alert("value is avail in ur_legth array"); 

    }

var myArray = [2,5,6,7,9,6];
myArray.includes(2) // is true
myArray.includes(14) // is false

Możesz wypróbować poniższy kod. Sprawdź http://api.jquery.com/jquery.grep/

var blockedTile = new Array("118", "67", "190", "43", "135", "520");
var searchNumber = "11878";
arr = jQuery.grep(blockedTile, function( i ) {
  return i === searchNumber;
});
if(arr.length){ console.log('Present'); }else{ console.log('Not Present'); }

sprawdź arr.length, jeśli jest większa niż 0, oznacza, że ​​łańcuch jest obecny, w przeciwnym razie nie jest obecny.

Myślę, że najprostszy sposób jest taki:

(118 in blockedTile); //is true