$.inArray et types

[tominardi]

Bonjour à vous,

Je suis avec jQuery 1.6.4.

Je cherche à vérifier simplement si un tableau est présent dans un autre tableau. J'espérais pouvoir utiliser $.inArray, mais :

Code :

alert($.inArray(['toto'],[['toto'],'tata']));

Retourne -1

Est ce que $.inArray est utilisable pour vérifier si tout type d'objet est présent dans un tableau ?

Là j'en suis aux phases de recherches, mais pour la suite je vais avoir des structures plus complexes à chercher dans un tableau, comme :

Code :

[[],[['elem1','elem2']]]

Merci d'avance pour votre coup de main

[NoSmoking]

Bonjour,

Code :

$.inArray( 'toto', ['toto','tata']));

devrait suffire.

Là j'en suis aux phases de recherches,...

cela tombe bien il existe jQuery.inArray()

[tominardi]

Merci pour la réponse rapide.


Mais ma structure de tableau est bien, grosso modo :

Code :

[['toto'],'tata']

Je ne peux pas changer ma structure juste pour obtenir ce que je désire.

imaginons que j'ai :

Code :

[['toto','tata'],['titi','tata']]

et que je veuille vérifier que ['toto','tata'] est bien contenu dans mon ensemble ?

[NoSmoking]

dans ce cas il te faut récupérer les différents contenus et les comparés, cela pourrait donner un truc du style

Code :

1
2
3
4
5
6
var tab = [['toto','tata'],['titi','tata']];
var val = ['toto','tata'];
$.each( tab, function( index, value){
  alert( tab[index] +'\n' +value);        // c'est la meme chose
  alert( $.inArray( val[0], tab[index])); // ou value
});

et si val est un tableau tu encapsules avec un each.

[Bovino]

JavaScript ne permet pas de comparer l'égalité de deux tableaux et dans le code de jQuery, tu pourras constater qu'inArray() se contente de tester l'égalité de la valeur recherchée avec chaque élément du tableau (si indexOf n'est pas disponible, mais ça revient au même).
Tu devras donc, si tu as vraiment besoin de cette fonctionnalité, la coder toi-même.

[tominardi]

Ouep...

Bon bah... je vais m'y atteler.
Merci à vous !

[Bovino]

Allez, c'est mon jour de bonté
Une première approche qui semble concluante d'après mes premiers tests :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Array.prototype.isEqual = function(val){
	if(!val.join){return false;}
	if(this.length != val.length){return false;}
	var long = val.length;
	for(var i = 0; i < long; i++){
		if(val[i].join && this[i].join){
			if(!this[i].isEqual(val[i])){
				return false;
			}
		}
		else if(this[i] != val[i]){
			return false;
		}
	}
	return true;
}

Alors, ce serait améliorable en utilisant la nouvelle méthode forEach des tableaux, mais j'ai eu la flemme du double codage pour les navigateurs un peu anciens (entre autre IE<9).
D'autre part, la fonction ne teste que l'égalité au niveau des tableaux, pas pour les autres objets complexes (objets, fonctions, ...)

[tominardi]

Oui, c'est sûr que l'idéal voudrait une comparaison de "tout".

Mais je me pose aussi sérieusement la question : en général, quand tu cherches à faire quelque chose que personne ne fait jamais, c'est que ce que tu cherches à faire est une mauvaise idée.

En fait je suis coincé avec une structure de tableaux imbriqués complexes que je reçois du backend, mais je ne vois pas comment l'améliorer.

Pour le forEach, utiliser le $.each() de jQuery serait l'alternative, non ?

[danielhagnoul]

Bonjour

J'arrive à traiter un tableau complexe (plusieurs niveaux).

Bien entendu, si vous recherchez différents tableaux de valeur dans le même tableau de données, vous devez utiliser la méthode récursive une seule fois.

Reste à tester si la fonction récursive n'a pas une consommation mémoire excessive et un temps d'exécution prohibitif pour des tableaux complexes comportant plusieurs milliers d'éléments.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
var tabData = ['toto','tata', [['toto',[['toto','tata'], 'toto','tata', "toti", ['titi','tata'], "toti"]],['titi','tata']], "toti"],
	tabValues = ['toto','tata'];
 
/*
 * dvjhInArray cherche si une valeur contenue dans le
 * tableau arrayValues est présente dans le tableau arrayData.
 *
 * arrayValues doit être un tableau simple (1 seul niveau)
 * 
 * arrayData peut être un tableau à plusieurs niveaux, dans
 * ce cas la fonction récursive dvjhSimpleArray le transforme
 * en un tableau simple.
 *
 * On retourne un array qui contient tabR et tabS.
 *
 * tabR est un tableau simple qui contient les éléments
 * présents dans tabS.
 *
 * tabS est un tableau simple qui contient les données présentes
 * dans arrayData.
 *
 * On ne stocke pas l'index de l'élément puisque indexOf() utilisé
 * par inArray()arrête la recherche au premier élément trouvé et
 * l'index dans tabS n'a rien à voir avec celui dans arrayData
 */
function dvjhInArray(arrayValues, arrayData){
	var tabS = [], tabR = [];
 
	dvjhSimpleArray(tabS, arrayData);
 
	$.each(arrayValues, function(i, item){
		if ( $.inArray(item, tabS) > -1 ){
			tabR.push(item);
		}
	});
 
	function dvjhSimpleArray(r, array){				
		$.each(array, function(i, item){
			if ($.isArray(item)){
				dvjhSimpleArray(r, item);
			} else {
				r.push(item);
			}
		});
	}
 
	return [tabR, tabS];
}
 
console.log( tabData );
var results = dvjhInArray(tabValues, tabData)
console.log( results[0] );
console.log( results[1] );			
 
/*
 ['toto','tata', [['toto',[['toto','tata'], 'toto','tata', "toti", ['titi','tata'], "toti"]],['titi','tata']], "toti"]
 ["toto", "tata", "toto", "toto", "tata", "toto", "tata", "toti", "titi", "tata", "toti", "titi", "tata", "toti"]
*/