underscore.js - Déterminer si toutes les valeurs dans un tableau de tableaux de correspondance

J'ai un tableau de tableaux, qui ressemble à quelque chose comme ceci:

[["Some string", "Some other string"],["Some third string", "some fourth string"]]

Je pense que je peux utiliser le _.all méthode dans Trait de soulignement pour déterminer si tous les tableaux de match de 100% (c'est l'ensemble de leurs valeurs match), mais je ne suis pas sûr de savoir comment écrire le nécessaire itérateur pour effectuer la vérification.

Quelqu'un a une idée?

OriginalL'auteur Kevin Whitaker | 2012-04-11

javascript underscore.js

14

Essayer ce gars-là (de l'ordre indépendant):
```
function allArraysAlike(arrays) {
  return _.all(arrays, function(array) {
    return array.length == arrays[0].length && _.difference(array, arrays[0]).length == 0;
  });
}
```
C'est en supposant que vous voulez tous les tableaux contiennent les mêmes éléments ~~dans le même ordre~~ comme l'un de l'autre (ainsi, par votre exemple d'entrée de la fonction doit retourner false).

et si vous ne voulez pas utiliser l' _ ?
_.difference vérifie seulement si les valeurs du premier tableau ne sont pas présents dans le second tableau; des valeurs supplémentaires dans le second tableau, ne sont pas détectés, si vraiment vous voulez vous assurer que les deux tableaux sont les mêmes que vous devriez faire _.difference(array, arrays[0]).length == 0 && _.difference(array[0], arrays).length == 0

OriginalL'auteur Dan Tao
31

Pourquoi pas d'intersection? (si vous voulez vraiment utiliser certains Soulignent des fonctions de cette dernière)
http://underscorejs.org/#intersection

Si les tableaux sont de la même longueur, et la longueur de l'intersection est égale à la longueur des tableaux, puis ils contiennent tous les mêmes valeurs.

Je crois que cela ne fonctionne que si vous supposez tableau les valeurs sont uniques

OriginalL'auteur peterfoldi
20

Ma préférence:
```
_.isEqual(_.sortBy(first), _.sortBy(second))
```
Et si l'ordre des questions:
```
_(first).isEqual(second)
```
OriginalL'auteur paulmelnikow
11

Utilisation trait de soulignement pour déterminer la différence entre les deux, et vérifier la longueur du tableau. Un moyen facile de le faire serait:
```
_.isEmpty(_.difference(array1, array2)) && _.isEmpty(_.difference(array2, array1))
```
Ce sera le retour de true si elles sont les mêmes et false si ils ne le sont pas.

.isEmpty(.différence([], [1,2,3]) renvoie vrai, mais le tableau ne sont pas les mêmes. Il convient de .isEmpty(.différence(matrice1, matrice2)) && .isEmpty(.différence(tableau2, matrice1))
Bien repéré. Stackoverflow supprime les caractères de soulignement dans les commentaires pour une raison quelconque

OriginalL'auteur Craig Myles
4
```
_.isEmpty(_.xor(array1, array2))
```
lodash.com/docs#xor est en lodash, mais pas dans le caractère de soulignement.

OriginalL'auteur Ron
2

Si vous voulez vérifier que les éléments sont les mêmes et dans le même ordre, je voudrais aller avec:
```
arrayEq = function(a, b) {
  return _.all(_.zip(a, b), function(x) {
    return x[0] === x[1];
  });
};
```
Même plus proprement en coffeescript:
```
arrayEq = (a,b) ->
    _.all _.zip(a,b), (x) -> x[0]==x[1]
```
ou, pour chaque ensemble de paires de valeurs, return _.union(x).length == 1; pour un nombre arbitraire de tableaux de comparaison.
Lorsque l'ordre des questions, vous pouvez simplement utiliser _.isEqual.

OriginalL'auteur jazmit

Ma mise en œuvre avec http://underscorejs.org/

/**
 * Returns true if the arrays are equal
 *
 * @param {Array} array1
 * @param {Array} array2
 * @returns {boolean}
 */
equal: function ( array1, array2 )
{
    return ( array1.length === array2.length)
        && (array1.length === _.intersection( array1, array2 ).length);
}

OriginalL'auteur klodoma

Si vous n'avez pas besoin de savoir qui éléments sont inégales, l'utilisation de transitivité:

function allEqual(list) {
  return _.all(list.slice(1), _.partial(_.isEqual, list[0]));
}
allEqual([2, 2, 2, 2]) //=> true
allEqual([2, 2, 3, 2]) //=> false
allEqual([false])      //=> true
allEqual([])           //=> true

OriginalL'auteur chbrown

0

Je ne peux pas commenter sur Dan Tao réponse, petit changement pour ignorer la vérification du premier tableau à l'encontre de lui-même (inutile _.différence d'appel)
```
function allArraysAlike(arrays) {
    return _.all(arrays, function(array) {
        if(array === arrays[0]) return true;
        return array.length == arrays[0].length && _.difference(array, arrays[0]).length == 0;
    });
}
```
Autant que je sache, on ne peut pas comparer 2 tableaux avec === eg, [4,5] === [4,5] sera toujours faux! Au moins dans google chrome.
à l'époque où j'ai écrit ce commentaire, j'ai été travailler sur de gros et de désordre web app, avec divers magasins/modèles etc.. il y avait des tableaux autour de la pose représentant les mêmes données (id, etc), certains tableaux sont des copies, des références et nous avons vérifier la présence de différences. Parfois, nous aimerions vérifier même les tableaux les uns contre les autres (dans le cas où ils ont été les références), cette case ici seulement d'optimiser ce cas: a = [1, ... x]; b = a; allArraysAlike([a, b])
il semble que le "tous" est désormais obsolète

OriginalL'auteur cotko

Vous devez vous connecter pour publier un commentaire.