Der beste Weg, um herauszufinden, ob ein Element in einem JavaScript-Array ist?

Question

Wie kann man am besten herausfinden, ob ein Objekt in einem Array enthalten ist?

Das ist der beste Weg, den ich kenne:

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

console.log(include([1, 2, 3, 4], 3)); // true
console.log(include([1, 2, 3, 4], 6)); // undefined

Answer 1

Das hängt von Ihrem Zweck ab. Wenn Sie für das Web programmieren, vermeiden Sie indexOf Es wird vom Internet Explorer 6 nicht unterstützt (viele benutzen ihn noch!), oder es wird nur bedingt verwendet:

if (yourArray.indexOf !== undefined) result = yourArray.indexOf(target);
else result = customSlowerSearch(yourArray, target);

indexOf ist wahrscheinlich in nativem Code kodiert, so dass es schneller ist als alles, was Sie in JavaScript tun können (außer binäre Suche/Dichotomie, wenn das Array geeignet ist). Hinweis: Es ist eine Frage des Geschmacks, aber ich würde eine return false; am Ende Ihrer Routine, um einen true Boolean zurückzugeben...

Answer 2

Hier ist etwas Meta-Wissen für Sie - wenn Sie wissen wollen, was Sie mit einem Array machen können, schauen Sie in der Dokumentation nach - hier ist die Array-Seite für Mozilla

https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array

Dort finden Sie einen Verweis auf indexOf, der in Javascript 1.6 hinzugefügt wurde

Answer 3

Eine robuste Art und Weise zu prüfen, ob ein Objekt ein Array in Javascript ist, ist hier detailliert:

Hier sind zwei Funktionen aus dem xa.js Gerüst, das ich mit einem utils = {} Container'. Diese sollten Ihnen helfen, Arrays richtig zu erkennen.

var utils = {};

/**
 * utils.isArray
 *
 * Best guess if object is an array.
 */
utils.isArray = function(obj) {
     // do an instanceof check first
     if (obj instanceof Array) {
         return true;
     }
     // then check for obvious falses
     if (typeof obj !== 'object') {
         return false;
     }
     if (utils.type(obj) === 'array') {
         return true;
     }
     return false;
 };

/**
 * utils.type
 *
 * Attempt to ascertain actual object type.
 */
utils.type = function(obj) {
    if (obj === null || typeof obj === 'undefined') {
        return String (obj);
    }
    return Object.prototype.toString.call(obj)
        .replace(/\[object ([a-zA-Z]+)\]/, '$1').toLowerCase();
};

Wenn Sie dann prüfen wollen, ob ein Objekt in einem Array ist, würde ich auch diesen Code einfügen:

/**
 * Adding hasOwnProperty method if needed.
 */
if (typeof Object.prototype.hasOwnProperty !== 'function') {
    Object.prototype.hasOwnProperty = function (prop) {
        var type = utils.type(this);
        type = type.charAt(0).toUpperCase() + type.substr(1);
        return this[prop] !== undefined
            && this[prop] !== window[type].prototype[prop];
    };
}

Und schließlich die Funktion in_array:

function in_array (needle, haystack, strict) {
    var key;

    if (strict) {
        for (key in haystack) {
            if (!haystack.hasOwnProperty[key]) continue;

            if (haystack[key] === needle) {
                return true;
            }
        }
    } else {
        for (key in haystack) {
            if (!haystack.hasOwnProperty[key]) continue;

            if (haystack[key] == needle) {
                return true;
            }
        }
    }

    return false;
}