25 erweiterte Verwendungsmöglichkeiten von JS Array Reduce, die Sie kennen müssen

const arr = [3, 5, 1, 4, 2];
Verwenden Sie die Funktion a = arr.reduce((t, v) => t + v);
//Entspricht const b = arr.reduce((t, v) => t + v, 0);

Funktion Akkumulation(...vals) {
    gibt vals.reduce((t, v) => t + v, 0); zurück
}

Funktion Multiplikation(...Werte) {
    gibt vals.reduce((t, v) => t * v, 1); zurück
}

Akkumulation(1, 2, 3, 4, 5); // 15
Multiplikation(1, 2, 3, 4, 5); // 120

Konstante Punktzahlen = [
    { Punktzahl: 90, Fach: "Chinesisch", Gewichtung: 0,5 },
    { Punktzahl: 95, Fach: "Mathe", Gewichtung: 0,3 },
    { Punktzahl: 85, Fach: "Englisch", Gewichtung: 0,2 }
];
const Ergebnis = Punktzahlen.Reduce((t, v) => t + v.Punktzahl * v.Gewicht, 0); // 90,5

Funktion Umgekehrt(arr = []) {
    arr.reduceRight((t, v) => (t.push(v), t), []);
}

Umgekehrt([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

const arr = [0, 1, 2, 3];

// Karte ersetzen: [0, 2, 4, 6]
Konstanten a = arr.map(v => v * 2);
const b = arr.reduce((t, v) => [...t, v * 2], []);

// Filter ersetzen: [2, 3]
const c = arr.filter(v => v > 1);
const d = arr.reduce((t, v) => v > 1 ? [...t, v] : t, []);

// Karte und Filter ersetzen: [4, 6]
const e = arr.map(v => v * 2).filter(v => v > 2);
const f = arr.reduce((t, v) => v * 2 > 2 ? [...t, v * 2] : t, []);

Konstante Punktzahlen = [
    { Punktzahl: 45, Betreff: "Chinesisch" },
    { Punktzahl: 90, Fach: "Mathe" },
    { Punktzahl: 60, Betreff: "Englisch" }
];

// Ersetze einige: mindestens ein qualifiziertes const isAtLeastOneQualified = scores.reduce((t, v) => t || v.score >= 60, false); // true

// Ersetze alle: alle qualifizierten const isAllQualified = scores.reduce((t, v) => t && v.score >= 60, true); // false

Funktion Chunk(arr = [], Größe = 1) {
    gibt arr.length zurück? arr.reduce((t, v) => (t[t.length - 1].length === Größe ? t.push([v]) : t[t.length - 1].push(v), t), [[]]) : [];
}

const arr = [1, 2, 3, 4, 5];
Chunk(arr, 2); // [[1, 2], [3, 4], [5]]

Funktion Differenz(arr = [], oarr = []) {
    return arr.reduce((t, v) => (!oarr.includes(v) && t.push(v), t), []);
}

const arr1 = [1, 2, 3, 4, 5];
const arr2 = [2, 3, 6]
Unterschied(arr1, arr2); // [1, 4, 5]

Funktion Füllen(arr = [], val = "", start = 0, end = arr.length) {
    wenn (Start < 0 || Start >= Ende || Ende > arr.Länge) return arr;
    zurückkehren [
        ...arr.slice(0, Start),
        ...arr.slice(Start, Ende).reduce((t, v) => (t.push(val || v), t), []),
        …arr.slice(Ende, arr.Länge)
    ];
}

const arr = [0, 1, 2, 3, 4, 5, 6];
Füllen(arr, "aaa", 2, 5); // [0, 1, "aaa", "aaa", "aaa", 5, 6]

Funktion Flat(arr = []) {
    return arr.reduce((t, v) => t.concat(Array.isArray(v) ? Flat(v) : v), [])
}

const arr = [0, 1, [2, 3], [4, 5, [6, 7]], [8, [9, 10, [11, 12]]]];
Flach(arr); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

Funktion Uniq(arr = []) {
    gibt arr.reduce((t, v) => t.includes(v) ? t : [...t, v], []);
}

const arr = [2, 1, 0, 3, 2, 1, 2];
Uniq(arr); // [2, 1, 0, 3]

Funktion Max(arr = []) {
    gibt arr.reduce((t, v) => t > v ? t : v); zurück
}

Funktion Min(arr = []) {
    gibt arr.reduce((t, v) => t < v ? t : v); zurück
}

const arr = [12, 45, 21, 65, 38, 76, 108, 43];
Max(an); // 108
Min(an); // 12

Funktion Entpacken(arr = []) {
    Rückkehr arr.reduce(
        (t, v) => (v.fürEach((w, i) => t[i].push(w)), t),
        Array.from({ Länge: Math.max(...arr.map(v => v.length)) }).map(v => [])
    );
}

const arr = [["a", 1, wahr], ["b", 2, falsch]];
Entpacken(arr); // [["a", "b"], [1, 2], [wahr, falsch]]

Funktion Zählen(arr = []) {
    : return arr.reduce((t, v) => (t[v] = (t[v] || 0) + 1, t), {});
}

arr = [0, 1, 1, 2, 2, 2];
Anzahl(arr); // { 0: 1, 1: 2, 2: 3 }

Funktion Position(arr = [], val) {
    : Gibt an, ob t.push(i), t) oder v) reduce(i) ist.
}

const arr = [2, 1, 5, 4, 2, 1, 6, 6, 7];
Position(arr, 2); // [0, 4]

Funktion Gruppe(arr = [], Schlüssel) {
    Taste zurückgeben? arr.reduce((t, v) => (!t[v[key]] && (t[v[key]] = []), t[v[key]].push(v), t), {}) : {};
}

Konstanten arr = [
    { Gebiet: "GZ", Name: "YZW", Alter: 27 },
    { Gebiet: "GZ", Name: "TYJ", Alter: 25 },
    { Gebiet: "SZ", Name: "AAA", Alter: 23 },
    { Bereich: "FS", Name: "BBB", Alter: 21 },
    { Gebiet: "SZ", Name: "CCC", Alter: 19 }
]; // Benutze Bereich als Gruppierungsbasis Group(arr, "Bereich"); // { GZ: Array(2), SZ: Array(2), FS: Array(1) }

Funktion Schlüsselwort(arr = [], Schlüssel = []) {
    Rückgabeschlüssel.Reduce((t, v) => (arr.some(w => w.includes(v)) && t.push(v), t), []);
}

const text = [
    „Heute ist ein schöner Tag, ich möchte angeln gehen“,
    „Ich sehe fern, während ich meine Hausaufgaben mache“,
    „Xiao Ming mag Xiao Hong, der neben ihm sitzt, und Xiao Jun, der neben ihm sitzt. Er ist so wankelmütig“,
    „Es gibt in letzter Zeit zu viele Leute, die bei der Arbeit gerne faulenzen. Sie schreiben Code nicht richtig und sind am Tagträumen.“
];
const keyword = ["faul", "mögen", "schlafen", "Angeln", "großartig", "während", "morgen"];
Schlüsselwort (Text, Schlüsselwort); // ["Gefällt mir", "Faulenzen", "Wirklich nett", "Währenddessen"]

Funktion ReverseStr(str = "") {
    return str.split("").reduceRight((t, v) => t + v);
}

const str = "Reduzieren ist das Beste";
ReverseStr(str); // „Der leistungsstärkste Ecuder“

Funktion TausendZahl(Zahl = 0) {
    const str = (+num).toString().split(".");
    const int = nums => nums.split("").reverse().reduceRight((t, v, i) => t + (i % 3 ? v : `${v},`), "").replace(/^,|,$/g, "");
    const dec = nums => nums.split("").reduce((t, v, i) => t + ((i + 1) % 3 ? v : `${v},`), "").replace(/^,|,$/g, "");
    gibt str.length > 1 zurück? `${int(str[0])}.${dec(str[1])}` : int(str[0]);
}

TausendZahl(1234); // "1,234"
TausendZahl(1234.00); // "1,234"
TausendZahl(0.1234); // "0.123,4"
TausendZahl(1234.5678); // "1,234.567,8"

asynchrone Funktion AsyncTotal(arr = []) {
    returniere arr.reduce(async(t, v) => {
        const at = warte auf t;
        const todo = warte auf Todo(v);
        at[v] = zu tun;
        Rückkehr um;
    }, Versprechen.auflösen({}));
}

const result = await AsyncTotal(); // Muss im asynchronen Surround verwendet werden

Funktion Fibonacci(Länge = 2) {
    const arr = [...neues Array(Länge).keys()];
    Fügt eine Variable hinzu, die die Regression von t auf v reduziert.
}

Fibonacci(10); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Funktion ParseUrlSearch() {
    Rückgabeort.Suche.Ersetzen(/(^\?)|(&$)/g, "").Split("&").Reduce((t, v) => {
        const [Schlüssel, Wert] = v.split("=");
        t[Schlüssel] = decodeURIComponent(Wert);
        Rückkehr t;
    }, {});
}

// Angenommen, die URL lautet: https://www.baidu.com?age=25&name=TYJ
ParseUrlSearch(); // { Alter: "25", Name: "TYJ" }

Funktion StringifyUrlSearch(Suche = {}) {
    returniere Objekt.Einträge(Suche).Reduzieren(
        (t, v) => `${t}${v[0]}=${encodeURIComponent(v[1])}&`,
        Objekt.Schlüssel(Suche).Länge ? "?" : ""
    ).replace(/&$/, "");
}

StringifyUrlSearch({ Alter: 27, Name: "YZW" }); // "?Alter=27&Name=YZW"

Funktion GetKeys(Objekt = {}, Schlüssel = []) {
    gibt Object.keys(obj).reduce((t, v) => (keys.includes(v) && (t[v] = obj[v]), t), {}); zurück.
}

const Ziel = { a: 1, b: 2, c: 3, d: 4 };
const Schlüsselwort = ["a", "d"];
GetKeys(Ziel, Schlüsselwort); // { a: 1, d: 4 }

const Leute = [
    { Gebiet: "GZ", Name: "YZW", Alter: 27 },
    { Gebiet: "SZ", Name: "TYJ", Alter: 25 }
];
const map = Leute.reduce((t, v) => {
    const { name, ...rest } = v;
    t[Name] = Ruhe;
    Rückkehr t;
}, {}); // { YZW: {…}, TYJ: {…} }

Funktion Compose(...funs) {
    wenn (funs.length === 0) {
        gibt arg zurück => arg;
    }
    wenn (funs.length === 1) {
        gib Spaß zurück[0];
    }
    returniere funs.reduce((t, v) => (...arg) => t(v(...arg)));
}

// Erstellen Sie ein Array mit der Länge 100000 const list = [...new Array(100000).keys()];

// für
Konsole.Zeit("für");
lass result1 = 0;
für (lass i = 0; i < Listenlänge; i++) {
    Ergebnis1 += i + 1;
}
konsole.log(ergebnis1);
console.timeEnd("für");

// fürJedes
Konsole.Zeit("fürJeden");
lass result2 = 0;
list.forEach(v => (Ergebnis2 += v + 1));
console.log(Ergebnis2);
console.timeEnd("fürJedes");

// Karte
Konsole.Zeit("Karte");
lass result3 = 0;
list.map(v => (Ergebnis3 += v + 1, v));
console.log(Ergebnis3);
console.timeEnd("Karte");

// reduzieren
console.time("reduzieren");
const result4 = list.reduce((t, v) => t + v + 1, 0);
konsole.log(ergebnis4);
console.timeEnd("reduzieren");