Existe-t-il un moyen d'utiliser map () sur un tableau dans l'ordre inverse avec javascript?

Je veux utiliser la map()fonction sur un tableau javascript, mais je voudrais qu'elle fonctionne dans l'ordre inverse.

La raison en est que je rends des composants React empilés dans un projet Meteor et que je souhaite que l'élément de niveau supérieur soit rendu en premier pendant que le reste charge les images ci-dessous.

var myArray = ['a', 'b', 'c', 'd', 'e'];
myArray.map(function (el, index, coll) {
    console.log(el + " ")
});

imprime a b c d emais je souhaite qu'il y ait un mapReverse () qui a imprimée d c b a

Aucune suggestion?

Si vous ne voulez pas inverser le tableau d'origine, vous pouvez en faire une copie superficielle puis mapper le tableau inversé,

myArray.slice(0).reverse().map(function(...

Ne mutant pas du tout le tableau, voici une solution O (n) à une seule ligne que j'ai trouvée:

myArray.map((val, index, array) => array[array.length - 1 - index]);

Vous pouvez utiliser Array.prototype.reduceRight()

var myArray = ["a", "b", "c", "d", "e"];
var res = myArray.reduceRight(function (arr, last, index, coll) {
    console.log(last, index);
    return (arr = arr.concat(last))
}, []);
console.log(res, myArray)

Avec la fonction de rappel nommé

const items = [1, 2, 3]; 
const reversedItems = items.map(function iterateItems(item) {
  return item; // or any logic you want to perform
}).reverse();

Raccourci (sans fonction de rappel nommée) - Syntaxe de flèche, ES6

const items = [1, 2, 3];
const reversedItems = items.map(item => item).reverse();

Voici le résultat

Une autre solution pourrait être:

const reverseArray = (arr) => arr.map((_, idx, arr) => arr[arr.length - 1 - idx ]);

Vous travaillez essentiellement avec les index de tableau

Je préfère écrire la fonction mapReverse une fois, puis l'utiliser. De plus, cela n'a pas besoin de copier le tableau.

function mapReverse(array, fn) {
    return array.reduceRight(function (result, el) {
        result.push(fn(el));
        return result;
    }, []);
}

console.log(mapReverse([1, 2, 3], function (i) { return i; }))
// [ 3, 2, 1 ]
console.log(mapReverse([1, 2, 3], function (i) { return i * 2; }))
// [ 6, 4, 2 ]

function mapRevers(reverse) {
    let reversed = reverse.map( (num,index,reverse) => reverse[(reverse.length-1)-index] );
    return reversed;
}

console.log(mapRevers(myArray));

I Vous passez le tableau à mapper Revers et dans la fonction vous renvoyez le tableau inversé. Dans la carte cb, vous prenez simplement les valeurs avec l'index comptant de 10 (longueur) à 1 à partir du tableau passé

Voici ma solution TypeScript qui est à la fois O (n) et plus efficace que les autres solutions en empêchant une exécution dans le tableau deux fois:

function reverseMap<T, O>(arg: T[], fn: (a: T) => O) {
   return arg.map((_, i, arr) => fn(arr[arr.length - i - 1]))
}

En JavaScript:

const reverseMap = (arg, fn) => arg.map((_, i, arr) => fn(arr[arr.length - 1 - i]))

// Or 

function reverseMap(arg, fn) {
    return arg.map((_, i, arr) => fn(arr[arr.length - i - 1]))
}

Vous pouvez d'abord faire myArray.reverse ().

var myArray = ['a', 'b', 'c', 'd', 'e'];
myArray.reverse().map(function (el, index, coll) {
    console.log(el + " ")
});

Une vieille question mais pour les nouveaux spectateurs, c'est le meilleur moyen d'inverser le tableau à l'aide de la carte

var myArray = ['a', 'b', 'c', 'd', 'e'];
[...myArray].map(() => myArray.pop());