Comment obtenir de l'union de plusieurs immutable.js Listes

Donc, j'ai une Liste:

let a = Immutable.List([1])

et de la Liste b:

let b = Immutable.List([2, 3])

Je veux avoir la Liste union === List([1, 2, 3]) d'eux.

J'essaie de fusion poing:

let union = a.merge(b); //List([2, 3])

Il semble que merge méthode fonctionne avec des index, pas avec les valeurs de remplacements premier élément de List a avec le premier élément de List b. Donc, ma question est quelle est la façon la plus simple d'obtenir de l'union de plusieurs listes (idéalement sans itération sur eux, ainsi que d'autres opérations).

  • Vous êtes à la recherche pour a.concat(b)?
  • dieu de barrage, ne pas le remarquer dans la doc ) Merci. vous pouvez le coller comme une réponse afin que je puisse l'accepter.
  • Lmao, je n'ai pas vu concat.. essayé toutes sortes de choses.. merci 🙂
  • Je pense que vous avez besoin de chercher à Définir le type de données.
InformationsquelleAutor Glen Swift | 2015-05-08
  1. 26

    Vous avez raison à propos de la fusion. Fusion sera mise à jour de l'indice par la valeur actuelle de la fusion de la liste. Donc dans votre cas vous avez eu 

    [0] = 1

    et l'a fusionné avec 

    [0] = 2
[1] = 3

    qui finit par écraser [0]=1 avec [0]=2, puis définissez [1]=3 résultant dans votre observé [2,3] groupe après la fusion.

    Une approche très simple de résoudre ce qui serait d'utiliser concat

    var a = Immutable.List([1]);
var b = Immutable.List([2,3]); 

var c = a.concat(b);

    Et il va travailler pour cette situation. Cependant, si la situation est plus complexe, c'est peut-être incorrect. Par exemple,

    var a = Immutable.List([1,4]);
var b = Immutable.List([2,3,4]);

    ce serait vous donner deux 4 qui n'est pas techniquement une union plus. Malheureusement, il n'existe pas de syndicat inclus dans Immuable. Un moyen facile de mise en œuvre, il serait de définir chaque valeur de chaque liste comme la clef d'un objet, et puis prendre les clés, comme la résultante de l'union.

    jsFiddle Démo

    function union(left,right){
 //object to use for holding keys
 var union = {};

 //takes the first array and adds its values as keys to the union object
 left.forEach(function(x){
  union[x] = undefined;
 });

 //takes the second array and adds its values as keys to the union object
 right.forEach(function(x){
  union[x] = undefined;
 });

 //uses the keys of the union object in the constructor of List 
 //to return the same type we started with
 //parseInt is used in map to ensure the value type is retained
 //it would be string otherwise
 return Immutable.List(Object.keys(union).map(function(i){ 
  return parseInt(i,10); 
 }));
}

    Ce processus est O(2(n+m)). Tout processus qui utilise contains ou indexOf va finir par être O(n^2) c'est pourquoi les clés ont été utilisés ici.

    la fin de modifier

    Hyper-performant

    function union(left,right){
    var list = [], screen = {};
    for(var i = 0; i < left.length; i++){
        if(!screen[left[i]])list.push(i);
        screen[left[i]] = 1;
    }
    for(var i = 0; i < right.length; i++){
        if(!screen[right[i]])list.push(i);
        screen[right[i]] = 1;
    }
    return Immutable.List(list);
}
    • Je crois que cela peut être problématique comme une approche générale - lorsque les valeurs sont plus complexes. Il va travailler pour les valeurs qui sont immuables types de Carte - par exemple - parce que le type de toString() méthode est mise en œuvre - mais alors, cela signifie que chaque fois que vous ajoutez de la valeur comme un objet clé, vous retrouvez l'appel toString(), d'où des performances.
    • Je suis en désaccord, comme approche générale, il n'y a rien de mal à cela. Dans votre micro-optimisation de l'utilisation de toString, j'ai fait une version spéciale pour éviter ce cas de figure dans les autres cas, sont également concernés. Vous pouvez le voir dans le fin de l'edit de la section.
    InformationsquelleAutor Travis J
  2. 22

    En fait Immutable.js a une union - c'est pour l'Ensemble de la structure de données:

    https://facebook.github.io/immutable-js/docs/#/Set/union

    La grande chose au sujet Immutable.js est-il permet d'introduire plus de constructions de programmation fonctionnelle en JS - dans ce cas, une interface commune et la capacité d'abstraction des types de données. Donc, pour faire un appel à l'union sur vos listes de les convertir, utilisez de l'union, puis de les convertir en arrière pour les listes:

    var a = Immutable.List([1, 4]);
var b = Immutable.List([2, 3, 4]); 
a.toSet().union(b.toSet()).toList(); //if you call toArray() or toJS() on this it will return [1, 4, 2, 3] which would be union and avoid the problem mentioned in Travis J's answer.
    • Merci de répondre mais je pense que c'est plutôt anti-patron alors patron. La conversion de plusieurs listes de jeux et puis en arrière semble être la surcharge en comparant avec l'utilisation de concat méthode.
    • J'aime la simplicité de cette réponse est.. a été surpris par la façon dont performant Travis J réponse est par comparaison: jsperf.com/immutable-union/2
    • Ouais vous ne voulez pas le faire souvent, et honnêtement, si vous utilisez l'ensemble des opérations, il a probablement fait sens pour utiliser l'ensemble de la structure de données. Cela dit, je suis d'accord, constructions de programmation fonctionnelle, prendre pour très élégant et simple des solutions, je serais curieux de voir les performances de ce type d'opération à l'aide de mori.js de plus immuable (car il est plus performant de la bibliothèque)
    • J'ai essayé la commande et tout fonctionne très bien, je ne la duplication de valeurs (dans mon cas, les listes sont composées d'instances de la Classe (objets de), quelle est la meilleure façon de vérifier et d'éliminer les doubles emplois sur le même id de clé de mon objet? Merci, Sean.
    • Une remarque: l'Ensemble ne permet pas de conserver l'ordre d'arrivée des éléments. C'est un gros inconvénient.
    InformationsquelleAutor Geoffrey Abdallah
  3. 1

    La mise en œuvre de List#merge a changé depuis que cette question a été posté, et dans la version actuelle 4.0.0-rc-12 List#merge fonctionne comme prévu et résout le problème.

    InformationsquelleAutor darksmurf