J'essaie d'utiliser le nouvel objet Map de Javascript EC6, car il est déjà pris en charge dans les dernières versions de Firefox et Chrome.

Mais je trouve cela très limité dans la programmation "fonctionnelle", car il manque des méthodes classiques de carte, de filtre, etc. qui fonctionneraient bien avec une [key, value]paire. Il a un forEach mais qui ne renvoie PAS le résultat du rappel.

Si je pouvais transformer son map.entries()MapIterator en un simple tableau, je pourrais alors utiliser le standard .map, .filtersans hacks supplémentaires.

Existe-t-il un "bon" moyen de transformer un itérateur Javascript en un tableau? En python, c'est aussi simple que de le faire list(iterator)... mais Array(m.entries())retournez un tableau avec l'itérateur comme premier élément !!!

ÉDITER

J'ai oublié de préciser que je cherche une réponse qui fonctionne partout où Map fonctionne, ce qui signifie au moins Chrome et Firefox (Array.from ne fonctionne pas dans Chrome).

PS.

Je sais qu'il y a le fantastique wu.js mais sa dépendance au traceur me rebute ...

Vous recherchez la nouvelle Array.fromfonction qui convertit les itérables arbitraires en instances de tableau:

var arr = Array.from(map.entries());

Il est désormais pris en charge dans Edge, FF, Chrome et Node 4+ .

Bien sûr, il pourrait être utile de définir map, filteret des méthodes similaires directement sur l'interface iterator, de sorte que vous pouvez éviter l' allocation du tableau. Vous pouvez également utiliser une fonction de générateur au lieu de fonctions d'ordre supérieur:

function* map(iterable) {
    var i = 0;
    for (var item of iterable)
        yield yourTransformation(item, i++);
}
function* filter(iterable) {
    var i = 0;
    for (var item of iterable)
        if (yourPredicate(item, i++))
             yield item;
}

[...map.entries()] ou Array.from(map.entries())

C'est super facile.

Quoi qu'il en soit, les itérateurs manquent de méthodes de réduction, de filtrage et similaires. Vous devez les écrire vous-même, car c'est plus efficace que de convertir Map en tableau et inversement. Mais ne faites pas de sauts Map -> Array -> Map -> Array -> Map -> Array, car cela tuerait les performances.

Il n'est pas nécessaire de transformer un Mapfichier Array. Vous pouvez simplement créer mapet filterfonctions pour les Mapobjets:

function map(functor, object, self) {
    var result = new Map;

    object.forEach(function (value, key, object) {
        result.set(key, functor.call(this, value, key, object));
    }, self);

    return result;
}

function filter(predicate, object, self) {
    var result = new Map;

    object.forEach(function (value, key, object) {
        if (predicate.call(this, value, key, object)) result.set(key, value);
    }, self);

    return result;
}

Par exemple, vous pouvez ajouter un bang (c'est-à-dire un !caractère) à la valeur de chaque entrée d'une carte dont la clé est une primitive.

var object = new Map;

object.set("", "empty string");
object.set(0,  "number zero");
object.set(object, "itself");

var result = map(appendBang, filter(primitive, object));

alert(result.get(""));     // empty string!
alert(result.get(0));      // number zero!
alert(result.get(object)); // undefined

function primitive(value, key) {
    return isPrimitive(key);
}

function appendBang(value) {
    return value + "!";
}

function isPrimitive(value) {
    var type = typeof value;
    return value === null ||
        type !== "object" &&
        type !== "function";
}

<script>
function map(functor, object, self) {
    var result = new Map;

    object.forEach(function (value, key, object) {
        result.set(key, functor.call(this, value, key, object));
    }, self || null);

    return result;
}

function filter(predicate, object, self) {
    var result = new Map;

    object.forEach(function (value, key, object) {
        if (predicate.call(this, value, key, object)) result.set(key, value);
    }, self || null);

    return result;
}
</script>

Vous pouvez également ajouter mapet filterméthodes sur Map.prototypepour le faire mieux lire. Bien qu'il ne soit généralement pas conseillé de modifier les prototypes natifs, je pense qu'une exception peut être faite dans le cas mapet filterpour Map.prototype:

var object = new Map;

object.set("", "empty string");
object.set(0,  "number zero");
object.set(object, "itself");

var result = object.filter(primitive).map(appendBang);

alert(result.get(""));     // empty string!
alert(result.get(0));      // number zero!
alert(result.get(object)); // undefined

function primitive(value, key) {
    return isPrimitive(key);
}

function appendBang(value) {
    return value + "!";
}

function isPrimitive(value) {
    var type = typeof value;
    return value === null ||
        type !== "object" &&
        type !== "function";
}

<script>
Map.prototype.map = function (functor, self) {
    var result = new Map;

    this.forEach(function (value, key, object) {
        result.set(key, functor.call(this, value, key, object));
    }, self || null);

    return result;
};

Map.prototype.filter = function (predicate, self) {
    var result = new Map;

    this.forEach(function (value, key, object) {
        if (predicate.call(this, value, key, object)) result.set(key, value);
    }, self || null);

    return result;
};
</script>

Edit: Dans la réponse de Bergi, il a créé des génériques mapetfilter fonctions génératrices pour tous les objets itérables. L'avantage de les utiliser est que, comme ce sont des fonctions génératrices, elles n'allouent pas d'objets itérables intermédiaires.

Par exemple, les fonctions my mapet filterdéfinies ci-dessus créent de nouveaux Mapobjets. Par conséquent, l'appel object.filter(primitive).map(appendBang)crée deux nouveaux Mapobjets:

var intermediate = object.filter(primitive);
var result = intermediate.map(appendBang);

La création d'objets itérables intermédiaires est coûteuse. Les fonctions génératrices de Bergi résolvent ce problème. Ils n'allouent pas d'objets intermédiaires mais permettent à un itérateur de transmettre ses valeurs paresseusement au suivant. Ce type d'optimisation est connu sous le nom de fusion ou de déforestation dans les langages de programmation fonctionnels et peut améliorer considérablement les performances du programme.

Le seul problème que j'ai avec les fonctions génératrices de Bergi est qu'elles ne sont pas spécifiques aux Mapobjets. Au lieu de cela, ils sont généralisés pour tous les objets itérables. Par conséquent, au lieu d'appeler les fonctions de rappel avec des (value, key)paires (comme je m'y attendais lors du mappage sur a Map), il appelle les fonctions de rappel avec(value, index) paires. Sinon, c'est une excellente solution et je recommanderais certainement de l'utiliser sur les solutions que j'ai fournies.

Voici donc les fonctions de générateur spécifiques que j'utiliserais pour mapper et filtrer des Mapobjets:

function * map(functor, entries, self) {
    var that = self || null;

    for (var entry of entries) {
        var key   = entry[0];
        var value = entry[1];

        yield [key, functor.call(that, value, key, entries)];
    }
}

function * filter(predicate, entries, self) {
    var that = self || null;

    for (var entry of entries) {
        var key    = entry[0];
        var value  = entry[1];

        if (predicate.call(that, value, key, entries)) yield [key, value];
    }
}

function toMap(entries) {
    var result = new Map;

    for (var entry of entries) {
        var key   = entry[0];
        var value = entry[1];

        result.set(key, value);
    }

    return result;
}

function toArray(entries) {
    var array = [];

    for (var entry of entries) {
        array.push(entry[1]);
    }

    return array;
}

Ils peuvent être utilisés comme suit:

var object = new Map;

object.set("", "empty string");
object.set(0,  "number zero");
object.set(object, "itself");

var result = toMap(map(appendBang, filter(primitive, object.entries())));

alert(result.get(""));     // empty string!
alert(result.get(0));      // number zero!
alert(result.get(object)); // undefined

var array  = toArray(map(appendBang, filter(primitive, object.entries())));

alert(JSON.stringify(array, null, 4));

function primitive(value, key) {
    return isPrimitive(key);
}

function appendBang(value) {
    return value + "!";
}

function isPrimitive(value) {
    var type = typeof value;
    return value === null ||
        type !== "object" &&
        type !== "function";
}

<script>
function * map(functor, entries, self) {
    var that = self || null;

    for (var entry of entries) {
        var key   = entry[0];
        var value = entry[1];

        yield [key, functor.call(that, value, key, entries)];
    }
}

function * filter(predicate, entries, self) {
    var that = self || null;

    for (var entry of entries) {
        var key    = entry[0];
        var value  = entry[1];

        if (predicate.call(that, value, key, entries)) yield [key, value];
    }
}

function toMap(entries) {
    var result = new Map;

    for (var entry of entries) {
        var key   = entry[0];
        var value = entry[1];

        result.set(key, value);
    }

    return result;
}

function toArray(entries) {
    var array = [];

    for (var entry of entries) {
        array.push(entry[1]);
    }

    return array;
}
</script>

Si vous voulez une interface plus fluide, vous pouvez faire quelque chose comme ceci:

var object = new Map;

object.set("", "empty string");
object.set(0,  "number zero");
object.set(object, "itself");

var result = new MapEntries(object).filter(primitive).map(appendBang).toMap();

alert(result.get(""));     // empty string!
alert(result.get(0));      // number zero!
alert(result.get(object)); // undefined

var array  = new MapEntries(object).filter(primitive).map(appendBang).toArray();

alert(JSON.stringify(array, null, 4));

function primitive(value, key) {
    return isPrimitive(key);
}

function appendBang(value) {
    return value + "!";
}

function isPrimitive(value) {
    var type = typeof value;
    return value === null ||
        type !== "object" &&
        type !== "function";
}

<script>
MapEntries.prototype = {
    constructor: MapEntries,
    map: function (functor, self) {
        return new MapEntries(map(functor, this.entries, self), true);
    },
    filter: function (predicate, self) {
        return new MapEntries(filter(predicate, this.entries, self), true);
    },
    toMap: function () {
        return toMap(this.entries);
    },
    toArray: function () {
        return toArray(this.entries);
    }
};

function MapEntries(map, entries) {
    this.entries = entries ? map : map.entries();
}

function * map(functor, entries, self) {
    var that = self || null;

    for (var entry of entries) {
        var key   = entry[0];
        var value = entry[1];

        yield [key, functor.call(that, value, key, entries)];
    }
}

function * filter(predicate, entries, self) {
    var that = self || null;

    for (var entry of entries) {
        var key    = entry[0];
        var value  = entry[1];

        if (predicate.call(that, value, key, entries)) yield [key, value];
    }
}

function toMap(entries) {
    var result = new Map;

    for (var entry of entries) {
        var key   = entry[0];
        var value = entry[1];

        result.set(key, value);
    }

    return result;
}

function toArray(entries) {
    var array = [];

    for (var entry of entries) {
        array.push(entry[1]);
    }

    return array;
}
</script>

J'espère que cela pourra aider.

Une petite mise à jour de 2019:

Désormais, Array.from semble être universellement disponible et, de plus, il accepte un deuxième argument mapFn , qui l'empêche de créer un tableau intermédiaire. Cela ressemble essentiellement à ceci:

Array.from(myMap.entries(), entry => {...});

Vous pouvez utiliser une bibliothèque comme https://www.npmjs.com/package/itiriri qui implémente des méthodes de type tableau pour les itérables:

import { query } from 'itiriri';

const map = new Map();
map.set(1, 'Alice');
map.set(2, 'Bob');

const result = query(map)
  .filter([k, v] => v.indexOf('A') >= 0)
  .map([k, v] => `k - ${v.toUpperCase()}`);

for (const r of result) {
  console.log(r); // prints: 1 - ALICE
}

Vous pouvez obtenir le tableau de tableaux (clé et valeur):

[...this.state.selected.entries()]
/**
*(2) [Array(2), Array(2)]
*0: (2) [2, true]
*1: (2) [3, true]
*length: 2
*/

Et puis, vous pouvez facilement obtenir des valeurs de l'intérieur, comme par exemple les clés avec l'itérateur de carte.

[...this.state.selected[asd].entries()].map(e=>e[0])
//(2) [2, 3]

Vous pouvez également utiliser fluent-iterable pour transformer en tableau:

const iterable: Iterable<T> = ...;
const arr: T[] = fluent(iterable).toArray();