Équivalent JavaScript de in_array () de PHP

Existe-t-il un moyen en JavaScript de comparer les valeurs d'un tableau et de voir s'il se trouve dans un autre tableau?

Similaire à la in_arrayfonction de PHP ?

Non, il n'en a pas. Pour cette raison, la plupart des bibliothèques populaires sont livrées avec une dans leurs packages d'utilitaires. Consultez jQuery InArray et Prototype Array.indexOf des exemples.

L'implémentation de jQuery est aussi simple que vous pourriez vous y attendre:

function inArray(needle, haystack) {
    var length = haystack.length;
    for(var i = 0; i < length; i++) {
        if(haystack[i] == needle) return true;
    }
    return false;
}

Si vous avez affaire à une quantité raisonnable d'éléments de tableau, ce qui précède fera l'affaire.

EDIT : Oups. Je n'ai même pas remarqué que vous vouliez voir si un tableau était à l'intérieur d'un autre. Selon la documentation PHP, c'est le comportement attendu de PHP in_array:

$a = array(array('p', 'h'), array('p', 'r'), 'o');

if (in_array(array('p', 'h'), $a)) {
    echo "'ph' was found\n";
}

if (in_array(array('f', 'i'), $a)) {
    echo "'fi' was found\n";
}

if (in_array('o', $a)) {
    echo "'o' was found\n";
}

// Output:
//  'ph' was found
//  'o' was found

Le code publié par Chris et Alex ne suit pas ce comportement. Alex est la version officielle de indexOf de Prototype, et Chris ressemble plus à PHP array_intersect. Cela fait ce que vous voulez:

function arrayCompare(a1, a2) {
    if (a1.length != a2.length) return false;
    var length = a2.length;
    for (var i = 0; i < length; i++) {
        if (a1[i] !== a2[i]) return false;
    }
    return true;
}

function inArray(needle, haystack) {
    var length = haystack.length;
    for(var i = 0; i < length; i++) {
        if(typeof haystack[i] == 'object') {
            if(arrayCompare(haystack[i], needle)) return true;
        } else {
            if(haystack[i] == needle) return true;
        }
    }
    return false;
}

Et voici mon test de ce qui précède:

var a = [['p','h'],['p','r'],'o'];
if(inArray(['p','h'], a)) {
    alert('ph was found');
}
if(inArray(['f','i'], a)) {
    alert('fi was found');
}
if(inArray('o', a)) {
    alert('o was found');
}  
// Results:
//   alerts 'ph' was found
//   alerts 'o' was found

Notez que je n'ai pas intentionnellement étendu le prototype Array car c'est généralement une mauvaise idée de le faire.

Il y a maintenant Array.prototype.includes:

La méthode includes () détermine si un tableau comprend un certain élément, renvoyant vrai ou faux selon le cas.

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

Syntaxe

arr.includes(searchElement)
arr.includes(searchElement, fromIndex)

Array.indexOfa été introduit dans JavaScript 1.6, mais il n'est pas pris en charge dans les anciens navigateurs. Heureusement, les gars de Mozilla ont fait tout le travail pour vous et vous ont fourni cela pour la compatibilité:

if (!Array.prototype.indexOf)
{
  Array.prototype.indexOf = function(elt /*, from*/)
  {
    var len = this.length >>> 0;

    var from = Number(arguments[1]) || 0;
    from = (from < 0)
         ? Math.ceil(from)
         : Math.floor(from);
    if (from < 0)
      from += len;

    for (; from < len; from++)
    {
      if (from in this &&
          this[from] === elt)
        return from;
    }
    return -1;
  };
}

Il existe même des extraits d'utilisation pratiques pour votre plaisir de script.

Si les index ne sont pas en séquence, ou si les index ne sont pas consécutifs, le code des autres solutions répertoriées ici sera rompu. Une solution qui fonctionnerait un peu mieux pourrait être:

function in_array(needle, haystack) {
    for(var i in haystack) {
        if(haystack[i] == needle) return true;
    }
    return false;
}

Et, en bonus, voici l'équivalent de array_search de PHP (pour trouver la clé de l'élément dans le tableau:

function array_search(needle, haystack) {
    for(var i in haystack) {
        if(haystack[i] == needle) return i;
    }
    return false;
}

Il y a un projet appelé Locutus , il implémente des fonctions PHP en Javascript et in_array () est inclus, vous pouvez l'utiliser exactement comme vous l'utilisez en PHP.

Exemples d'utilisation:

in_array('van', myArray);

in_array(1, otherArray, true); // Forcing strict type

Vous pouvez simplement utiliser la fonction "comprend" comme expliqué dans cette leçon sur w3schools

On dirait

let myArray = ['Kevin', 'Bob', 'Stuart'];
if( myArray.includes('Kevin'))
console.log('Kevin is here');

var a = [1,2,3,4,5,6,7,8,9];

var isSixInArray = a.filter(function(item){return item==6}).length ? true : false;

var isSixInArray = a.indexOf(6)>=0;

La solution jQuery est disponible, consultez la ducumentation ici: http://api.jquery.com/jquery.inarray/

$.inArray( 10, [ 8, 9, 10, 11 ] );

Il existe une fonction équivalente:

includes()

Regardez ici: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes

Si vous voulez seulement vérifier si une seule valeur est dans un tableau, le code de Paolo fera le travail. Si vous voulez vérifier quelles valeurs sont communes aux deux tableaux, alors vous voudrez quelque chose comme ça (en utilisant la fonction inArray de Paolo):

function arrayIntersect(a, b) {
    var intersection = [];

    for(var i = 0; i < a.length; i++) {
        if(inArray(b, a[i]))
            intersection.push(a[i]);
    }

    return intersection;
}

Cela renverra un tableau de valeurs qui sont à la fois dans aet b. (Mathématiquement, il s'agit d'une intersection des deux tableaux.)

EDIT: Voir Paolo's Edited Code pour la solution à votre problème. :)

Si vous avez besoin de tous les paramètres PHP disponibles, utilisez ceci:

function in_array(needle, haystack, argStrict) {
    var key = '', strict = !!argStrict;
    if (strict) {
        for (key in haystack) {
            if (haystack[key] === needle) {
                return true;
            }
        }
    }
    else {
        for (key in haystack) {
            if (haystack[key] == needle) {
                return true;
            }
        }
    }
    return false;
}

Ajoutez ce code à votre projet et utilisez les méthodes inArray de style objet

if (!Array.prototype.inArray) {
    Array.prototype.inArray = function(element) {
        return this.indexOf(element) > -1;
    };
} 
//How it work
var array = ["one", "two", "three"];
//Return true
array.inArray("one");

Avec Dojo Toolkit , vous utiliseriez dojo.indexOf(). Voir dojo.indexOf pour la documentation et Arrays Made Easy de Bryan Forbes pour quelques exemples.

haystack.find(value => value == needle)

où meule de foin est un tableau et aiguille est un élément du tableau. Si l'élément non trouvé sera retourné non défini, sinon le même élément.

function in_array(what, where) {
    var a=false;
    for (var i=0; i<where.length; i++) {
        if(what == where[i]) {
            a=true;
            break;
        }
    }
    return a;
}

J'ai trouvé une excellente solution jQuery ici sur SO.

var success = $.grep(array_a, function(v,i) {
    return $.inArray(v, array_b) !== -1;
}).length === array_a.length;

J'aimerais que quelqu'un poste un exemple de la façon de procéder en soulignant.

function in_array(needle, haystack){

    return haystack.indexOf(needle) !== -1;
}

Un équivalent de in_arraywith underscoreest _.indexOf

Exemples:

_.indexOf([3, 5, 8], 8); // returns 2, the index of 8 _.indexOf([3, 5, 8], 10); // returns -1, not found

Si vous allez l'utiliser dans une classe, et si vous préférez qu'il soit fonctionnel (et fonctionne dans tous les navigateurs):

inArray: function(needle, haystack)
{
    var result = false;

    for (var i in haystack) {
        if (haystack[i] === needle) {
            result = true;
            break;
        }
    }

    return result;
}

J'espère que cela aide quelqu'un :-)