Detaillierte Erklärung von JavaScript Reduce

/**
 * Verwenden Sie „reduce“, um die integrierte Methode „Array.prototype.map“ zu implementieren.
 * @param {any[]} arr 
 * @param {(val: any, index: number, thisArray: any[]) => jede} Zuordnung 
 * @returns {any[]}
 */
Funktion map(arr, Mapping) {
 return arr.reduce((acc, item, index) => [...acc, Zuordnung(item, index, arr)], []);
}

Karte([null, false, 1, 0, '', () => {}, NaN], val => !!val);

// [falsch, falsch, wahr, falsch, falsch, wahr, falsch]

/**
 * Verwenden Sie „reduce“, um die integrierte Methode „Array.prototype.filter“ zu implementieren.
 * @param {any[]} arr 
 * @param {(val: any, index: number, thisArray: any[]) => boolean} Prädikat 
 * @returns {any[]}
 */
Funktion Filter(arr, Prädikat) {
 return arr.reduce((acc, item, index) => Prädikat(item, index, arr) ? [...acc, item] : acc, []);
}

Filter([null, false, 1, 0, '', () => {}, NaN], Wert => !!Wert);

// [1, () => {}]

Funktion einige (arr, Prädikat) {
 return arr.reduce((acc, val, idx) => acc || Prädikat(val, idx, arr), false)
}

einige([null, falsch, 1, 0, '', () => {}, NaN], val => !!val);
// WAHR

einige([null, falsch, 0, '', NaN], val => !!val);
// FALSCH

acc || Prädikat(val, idx, arr)

Prädikat(Wert, Idx, Arr) || Acc

Funktion every(arr, Prädikat) {
 return arr.reduce((acc, val, idx) => acc und Prädikat(val, idx, arr), true)
}

Funktion findIndex(arr, Prädikat) {
 const NOT_FOUND_INDEX = -1;

 return arr.reduce((acc, val, idx) => {
 if (acc === NICHT_GEFUNDENER_INDEX) {
 Prädikat (Wert, IDX, Arr) zurückgeben? IDX: NICHT GEFUNDENER INDEX;
 }
 
 Rückgabe gem.
 }, INDEX_NICHT_GEFUNDEN)
}

findIndex([5, 12, 8, 130, 44], (Element) => Element > 8) // 3

/**
 * Gibt eine Funktion zurück, um den Eingabewert von den bereitgestellten Funktionen der Reihe nach von links nach rechts verarbeiten zu lassen.
 * @param {(funcs: any[]) => beliebige} Funktionen 
 * @returns {(arg: any) => any}
 */
Funktion Pipe(...Funktionen) {}

pipe(Wert => Wert * 2, Math.sqrt, Wert => Wert + 10)(2) // 12

// Wähle die Elemente aus, deren Wert positiv ist, multipliziere ihren Wert mit 0,1, addiere dann den Wert aller Elemente und erhalte schließlich 3
const Prozess = Pipe(
 arr => arr.filter(({ val }) => val > 0), 
 arr => arr.map(Element => ({ ...Element, Wert: Element.Wert * 0,1 })), 
 arr => arr.reduce((acc, { val }) => acc + val, 0)
);

Prozess([{ Wert: -10 }, { Wert: 20 }, { Wert: -0,1 }, { Wert: 10 }]) // 3

/**
 * Gibt eine Funktion zurück, die die Eingabewerte von den bereitgestellten Funktionen der Reihe nach von links nach rechts verarbeiten lässt.
 * @param {(funcs: any[]) => beliebige} Funktionen 
 * @returns {(args: any[]) => any}
 */
Funktion Pipe(...Funktionen) {}

pipe(Summe, Math.sqrt, Wert => Wert + 10)(0,1, 0,2, 0,7, 3) // 12

/**
 * Addieren Sie die Zahlen.
 * @param args Nummer[]
 * @returns {number} die Gesamtsumme.
 */
Funktion Summe(...args) {
 gibt args.reduce((a, b) => a + b); zurück
}

/**
 * Gibt eine Funktion zurück, um den Eingabewert von den bereitgestellten Funktionen der Reihe nach von links nach rechts verarbeiten zu lassen.
 * @param {(arg: any) => any} Funktionen
 * @returns {(arg: any) => any}
 */
Funktion Pipe(...Funktionen) {
 return (arg) => {
 Rückgabefunktion.Reduce(
 (acc, Funktion) => Funktion(acc),
 arg
 )
 }
}

/**
 * Gibt eine Funktion zurück, um den Eingabewert von den bereitgestellten Funktionen der Reihe nach von links nach rechts verarbeiten zu lassen.
 * @param {Array<(...args: any) => any>} Funktionen
 * @returns {(...args: any[]) => any}
 */
Funktion Pipe(...Funktionen) {
	// const realFuncs = funcs.filter(isFunction);

 return (...args) => {
 Rückgabefunktion.Reduce(
 (acc, func, idx) => idx === 0 ? func(...acc) : func(acc),
 Argumente
 )
 }
}

Funktion Pipe(...Funktionen) {
 return (...args) => {
 // Der erste wurde verarbeitet, nur die restlichen müssen verarbeitet werden return funcs.slice(1).reduce(
 (acc, Funktion) => Funktion(acc),
 
 // Behandeln Sie zuerst den Sonderfall als „acc“
 Funktionen[0](...Argumente)
 )
 }
}

const obj = { a: { b: { c: 'Hallo Welt' } } };

erhalte(Objekt, 'abc');

/**
 * Den Wert über den Schlüsselpfad abfragen
 * @param beliebiges Objekt
 * @param keyPath Zeichenfolge durch Punkte getrennter Schlüsselpfad* @returns {any} Zielwert*/
Funktion get(Objekt, Schlüsselpfad) {}

/**
 * Wählen Sie den Wert über den Schlüsselpfad aus.
 * @param beliebiges Objekt
 * @param keyPath Zeichenfolge durch Punkte getrennter Schlüsselpfad* @returns {any} Zielwert*/
Funktion get(Objekt, Schlüsselpfad) {
 wenn (!obj) {
 Rückgabe undefiniert;
 }

 returniere keyPath.split('.').reduce((acc, key) => acc[key], obj);
}

Funktion flatDeep(arr) {
 Rückgabewert arr.reduce((acc, item) => 
 Array.isArray(Element) ? [...acc, ...flatDeep(Element)] : [...acc, Element],
 []
 )
}

Funktion flatDeep(arr) {
 Rückgabewert arr.reduce((acc, item) => 
 acc.concat(Array.isArray(Element) ? flatDeep(Element) : Element),
 []
 )
}

Funktion flatDeep(arr) {
 Rückgabewert arr.reduce((acc, item) => 
 Array.isArray(Element) ? [...acc, ...flatDeep(Element)] : [...acc, Element],
 []
 )
}

var arr = Wiederholung([1, [2], [[3]], [[[4]]]], 20);

Konsole.log(arr);
Konsole.log(flatDeep(arr));

Konsole.Zeit('concat')
für (i = 0; i < 7 * 10000; ++i) {
 flatDeep(arr)
}
Konsole.timeEnd('concat')

Funktion „Wiederholung (arr, mal)“ { „let Ergebnis = []; für (i = 0; i < mal; ++i) { „ergebnis.push(...arr)“} „return Ergebnis“;}

sauber({ foo: null, bar: undefiniert, baz: 'hallo' })

// { baz: 'hallo' }

/**
 * Filtern Sie die „Nil“-Werte (null oder undefiniert) heraus.
 * @param {Objekt} Objekt
 * @returns {any}
 *
 * @example clean({ foo: null, bar: undefiniert, baz: 'hallo' })
 *
 * // => { baz: 'hallo' }
 */
Exportfunktion clean(obj) {
 wenn (!obj) {
 gibt Objekt zurück;
 }

 returniere Objekt.Schlüssel(Objekt).Reduce((acc, Schlüssel) => {
 wenn (!isNil(obj[Schlüssel])) {
 acc[Schlüssel] = obj[Schlüssel];
 }

 Rückgabe gem.
 }, {});
}

const Richtung = {
 Oben: 0,
 NACH UNTEN: 1,
 LINKS: 2,
 RECHTS: 3,
};

const actual = aufzählen(Richtung);

Konstante erwartet = {
 Oben: 0,
 NACH UNTEN: 1,
 LINKS: 2,
 RECHTS: 3,

 0: 'AUF',
 1: 'UNTEN',
 2: 'LINKS',
 3: 'RECHTS',
};

deepStrictEqual(tatsächlich, erwartet);

/**
 * Enumeration aus Objekt generieren.
 * @siehe https://www.typescriptlang.org/play?#code/KYOwrgtgBAglDeAoKUBOwAmUC8UCMANMmpgEw5SlEC+UiiAxgPYgDOTANsAHQdMDmAChjd0GAJQBuRi3ZdeA4QG08AXSmIgA
 * @param {Objekt} Objekt
 * @returns {Objekt}
 */
Exportfunktion enumify(obj) {
 wenn (!isPlainObject(obj)) {
 throw new TypeError('das Enumify-Ziel muss ein einfaches Objekt sein');
 }

 returniere Objekt.Schlüssel(Objekt).Reduce((acc, Schlüssel) => {
 acc[Schlüssel] = obj[Schlüssel];
 acc[Objekt[Schlüssel]] = Schlüssel;

 Rückgabe gem.
 }, {});
}