Gibt es eine Möglichkeit, map () in einem Array in umgekehrter Reihenfolge mit Javascript zu verwenden?

Ich möchte die map()Funktion in einem Javascript-Array verwenden, möchte aber, dass sie in umgekehrter Reihenfolge ausgeführt wird.

Der Grund dafür ist, dass ich gestapelte React-Komponenten in einem Meteor-Projekt rendere und möchte, dass das Element der obersten Ebene zuerst gerendert wird, während der Rest die folgenden Bilder lädt.

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

druckt aus, a b c d eaber ich wünschte, es gäbe eine mapReverse (), die gedruckt wurdee d c b a

Irgendwelche Vorschläge?

Wenn Sie das ursprüngliche Array nicht umkehren möchten, können Sie eine flache Kopie davon erstellen und dann das umgekehrte Array zuordnen.

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

Sie können verwenden 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)

Hier ist eine einzeilige O (n) -Lösung, die ich mir ausgedacht habe:

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

Mit benannter Rückruffunktion

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

Kurzform (ohne benannte Rückruffunktion) - Pfeilsyntax, ES6

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

Hier ist das Ergebnis

Eine andere Lösung könnte sein:

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

Sie arbeiten grundsätzlich mit den Array-Indizes

Ich schreibe die mapReverse-Funktion lieber einmal und benutze sie dann. Auch dies muss das Array nicht kopieren.

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 ]

Hier ist meine TypeScript-Lösung, die sowohl O (n) als auch effizienter als die anderen Lösungen ist, indem sie verhindert, dass das Array zweimal durchlaufen wird:

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

In 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]))
}

Sie können zuerst myArray.reverse () ausführen.

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

Eine alte Frage, aber für neue Betrachter ist dies der beste Weg, um das Array mithilfe der Karte umzukehren

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