Meilleure façon de savoir si un élément est dans un tableau JavaScript? [dupliquer]

si vous utilisez jQuery:

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

pour plus d'informations: http://api.jquery.com/jQuery.inArray /

tout d'abord, implémenter indexOf en JavaScript pour les navigateurs qui ne l'ont pas déjà. Par exemple, voir les extras de tableau D'Erik Arvidsson (aussi, le post de blog associé ). Et puis vous pouvez utiliser indexOf sans vous soucier du support du navigateur. Voici une version légèrement optimisée de son implémentation 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;
    };
}

Il a changé pour stocker la longueur de sorte qu'il n'a pas besoin de le chercher chaque itération. Mais la différence n'est pas énorme. Une fonction moins générale pourrait être plus rapide:

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

je préfère utiliser la fonction standard et laisser cette sorte de micro-optimisation pour quand il est vraiment nécessaire. Mais si vous êtes passionné par la micro-optimisation, j'ai adapté le benchmarks que roosterononacid lié dans les commentaires, à recherche de benchmark dans les tableaux . Ils sont assez brut, un plein la recherche permettrait de tester des tableaux de différents types, de différentes longueurs et de trouver des objets qui se produisent à différents endroits.

si le tableau n'est pas trié, il n'y a pas vraiment de meilleur moyen (à part l'utilisation de l'indexOf mentionné ci-dessus, qui je pense revient à la même chose). Si le tableau est trié, vous pouvez faire une recherche binaire, qui fonctionne comme ceci:

1. choisissez l'élément central du tableau.
2. est-ce que l'élément que vous recherchez est plus grand que l'élément que vous avez choisi? Si oui, vous avez éliminé la moitié inférieure du tableau. Si ce n'est pas le cas, vous avez éliminé la moitié supérieure.
3. choisir l'élément central de la moitié restante du tableau, et continuer comme dans l'étape 2, éliminant les moitiés du tableau restant. Vous finirez soit par trouver votre élément, soit par ne plus avoir de tableau à regarder.

la recherche binaire s'exécute dans un temps proportionnel au logarithme de la longueur du tableau, de sorte qu'elle peut être beaucoup plus rapide que la recherche de chaque élément individuel.

en supposant que .indexOf() est mis en œuvre

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

!!! ne faites pas Array.prototype.has=function(){... parce que vous allez ajouter un élément énumérable dans chaque tableau et js est cassé.

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

l'utilisation de 2nd arg (drapeau) forces comparation by value instead of reference

Cela dépend de votre but. Si vous programmez pour le Web, évitez indexOf , il n'est pas pris en charge par Internet Explorer 6 (beaucoup d'entre eux encore utilisés!), ou à usage conditionnel:

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

indexOf est probablement codé en code natif, il est donc plus rapide que tout ce que vous pouvez faire en JavaScript (sauf recherche binaire/dichotomie si le tableau est approprié). Remarque: c'est une question de goût, mais je voudrais faire une return false; à la fin de votre routine, de retour d'un vrai Booléen...

voici quelques méta-connaissances pour vous - si vous voulez savoir ce que vous pouvez faire avec un tableau, consultez la documentation-voici la page du tableau pour Mozilla

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

là, vous verrez référence à indexOf, ajouté en Javascript 1.6

une manière robuste de vérifier si un objet est un tableau en javascript est détaillé ici:

voici deux fonctions du xa.js cadre que j'attache à un utils = {} "conteneur". Ceux-ci devraient vous aider à détecter correctement les tableaux.

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]+)\]/, '').toLowerCase();
};

si vous voulez ensuite vérifier si un objet est dans un tableau, je voudrais aussi inclure ce code:

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

et enfin cette fonction 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;
}