La mejor manera de encontrar si un elemento está en una matriz de JavaScript? [duplicar]

Si está utilizando jQuery:

$.inArray(5 + 5, [ "8", "9", "10", 10 + "" ]);

Para más información: http://api.jquery.com/jQuery.inArray /

Primero, implemente indexOf en JavaScript para navegadores que aún no lo tengan. Por ejemplo, verarray extras de Erik Arvidsson (también, la entrada de blogasociada ). Y luego puede usar indexOf sin preocuparse por el soporte del navegador. Aquí hay una versión ligeramente optimizada de su implementación indexOf:

if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (obj, fromIndex) {
        if (fromIndex == null) {
            fromIndex = 0;
        } else if (fromIndex < 0) {
            fromIndex = Math.max(0, this.length + fromIndex);
        }
        for (var i = fromIndex, j = this.length; i < j; i++) {
            if (this[i] === obj)
                return i;
        }
        return -1;
    };
}

Se ha cambiado para almacenar la longitud para que no tenga que buscarla en cada iteración. Pero la diferencia no es enorme. Una función de propósito menos general podría ser más rápido:

var include = Array.prototype.indexOf ?
    function(arr, obj) { return arr.indexOf(obj) !== -1; } :
    function(arr, obj) {
        for(var i = -1, j = arr.length; ++i < j;)
            if(arr[i] === obj) return true;
        return false;
    };

Prefiero usar la función estándar y dejar este tipo de microoptimización para cuando sea realmente necesario. Pero si estás interesado en la microoptimización, adapté los benchmarks a los que roosterononacid enlazó en los comentarios, a benchmark buscando en arrays. Sin embargo, son bastante crudos, una investigación completa probaría matrices con diferentes tipos, diferentes longitudes y encontraría objetos que ocurren en diferentes lugares.

Si la matriz no está ordenada, no hay realmente una mejor manera (aparte de usar el indexOf mencionado anteriormente, que creo que equivale a lo mismo). Si la matriz está ordenada, puede hacer una búsqueda binaria, que funciona así:

1. Elige el elemento central de la matriz.
2. ¿El elemento que estás buscando es más grande que el elemento que elegiste? Si es así, ha eliminado la mitad inferior de la matriz. Si no lo es, has eliminado la mitad superior.
3. Elige el medio elemento de la mitad restante de la matriz, y continuar como en el paso 2, eliminando mitades de la matriz restante. Eventualmente encontrará su elemento o no tendrá ninguna matriz para mirar a través.

La búsqueda binaria se ejecuta en tiempo proporcional al logaritmo de la longitud de la matriz, por lo que puede ser mucho más rápida que mirar cada elemento individual.

Suponiendo que .indexOf() se implementa

Object.defineProperty( Array.prototype,'has',
{
    value:function(o, flag){
    if (flag === undefined) {
        return this.indexOf(o) !== -1;
    } else {   // only for raw js object
        for(var v in this) {
            if( JSON.stringify(this[v]) === JSON.stringify(o)) return true;
        }
        return false;                       
    },
    // writable:false,
    // enumerable:false
})

!!! no haga Array.prototype.has=function(){... porque agregará un elemento enumerable en cada matriz y js está roto.

//use like          
[22 ,'a', {prop:'x'}].has(12) // false
["a","b"].has("a") //  true

[1,{a:1}].has({a:1},1) // true
[1,{a:1}].has({a:1}) // false

El uso de 2nd arg (flag) fuerza la comparación por valor en lugar de referencia

Depende de tu propósito. Si programa para la Web, evite indexOf, no es compatible con Internet Explorer 6 (muchos de ellos todavía se utilizan!), o hacer uso condicional:

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

indexOf probablemente está codificado en código nativo, por lo que es más rápido que cualquier cosa que pueda hacer en JavaScript (excepto la búsqueda binaria/dicotomía si el array es apropiado). Nota: es una cuestión de gusto, pero yo haría un return false; al final de su rutina, para devolver un verdadero booleano...

Aquí tienes algunos meta-conocimientos para ti - si quieres saber qué puedes hacer con un Array, revisa la documentación-aquí está la página de Array para Mozilla

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

Allí verás la referencia a indexOf, añadida en Javascript 1.6

Una forma robusta de comprobar si un objeto es una matriz en javascript se detalla aquí:

Aquí hay dos funciones de la xa.js framework que adjunto a un utils = {} 'container'. Estos deberían ayudarle a detectar correctamente los arrays.

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

Si luego desea verificar si un objeto está en una matriz, también incluiría este código:

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

Y finalmente esta función 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;
}