const istGerade = (zahl) => zahl % 2 === 0;

const zahlen = [1, 2, 3, 4, 5, 6];

// filter() ist die HOF, die istGerade als Wert konsumiert
const geradeZahlen = zahlen.filter(istGerade); 
            

function erstelleZaehler() {
    let zaehler = 0; // Private Variable
    
    return function inkrementieren() {
        zaehler += 1; // Greift auf privaten Zustand zu
        return zaehler;
    };
} 

const meinZaehler = erstelleZaehler();
const wert1 = meinZaehler(); // 1
const wert2 = meinZaehler(); // 2
            

let operation;

if (true) {
    // Der Funktionswert wird dynamisch zugewiesen
    operation = (a, b) => a - b; 
} else {
    operation = (a, b) => a + b;
}

const ergebnis = operation(20, 5); // Ausführung über den Variablennamen
            

function erstelleMultiplikator(faktor) {
    // Äußere Funktion gibt innere Funktion zurück (Closure speichert faktor)
    return function(zahl) {
        return zahl * faktor; 
    };
}

// Spezialisierte Funktion erstellen
const malZwei = erstelleMultiplikator(2);

const wert = malZwei(10); // Nur das zweite Argument übergeben
            

function datenGeladen(daten) {
    console.log("Daten empfangen:", daten);
}

// Die Funktion wird als Wert übergeben und später vom API-Code aufgerufen
// fetch('api/daten').then(datenGeladen); 
            

const verdoppeln = (x) => x * 2;
const addiereEins = (x) => x + 1;

// 1. addiereEins(5) -> 6
// 2. verdoppeln(6) -> 12
const ergebnis = verdoppeln(addiereEins(5)); 
            

function memoize(fn) {
    const cache = {}; 
    return function(arg) {
        if (cache[arg]) return cache[arg]; // Cache Hit
        const result = fn(arg);
        cache[arg] = result;
        return result;
    };
}
// Wird oft für rekursive Funktionen verwendet, um Wiederholungen zu vermeiden.
            

(function() {
    const temporaererWert = 5; // Nur in dieser IIFE sichtbar
    // Code, der diesen Wert verwendet...
})(); // Sofortiger Aufruf
            

// Pure Function: Die Ausgabe hängt nur von a und b ab.
function addierePure(a, b) {
    return a + b;
}

// Pure: addierePure(1, 2) gibt IMMER 3 zurück.
const ergebnis = addierePure(5, 5); // 10
            

// HOF: Generischer Prozess (Transformation)
function starteProzess(daten, transformation) {
    return daten.map(transformation);
}

// Callback: Spezifische Aktion 1
const grossschreibung = (str) => str.toUpperCase();

const namen = ['anna', 'max'];
const ergebnis = starteProzess(namen, grossschreibung);
            

function erstelleValidierer(minLength) {
    // Gibt Validierungsfunktion mit festem minLength zurück
    return (wert) => wert.length >= minLength; 
}

const valideFuenf = erstelleValidierer(5);

const istValide = valideFuenf("Hallo"); // true
            

function datenVerarbeiten(response) {
    // Die Funktion wird als Wert an das Promise übergeben
    return response.json(); 
}

// fetch() gibt ein Promise zurück, .then() nimmt die Funktion datenVerarbeiten als Callback
// fetch('/user').then(datenVerarbeiten).then(console.log);
            

function mitLogging(fn) {
    return function(...args) {
        console.log("Aufruf mit:", args);
        return fn(...args);
    }
}

function add(a, b) { return a + b; }

// Die ursprüngliche Funktion wird "dekoriert"
const addMitLog = mitLogging(add); 
const ergebnis = addMitLog(2, 3); // 5, mit Log in Konsole
            

const Strategien = {
    SUMME: (a, b) => a + b,
    PRODUKT: (a, b) => a * b
};

function rechne(strategieFn, a, b) {
    // Die Funktion (Strategie) wird ausgeführt
    return strategieFn(a, b); 
}

const ergebnis = rechne(Strategien.PRODUKT, 5, 4); // 20
            

function log(level, message) {
    console.log(`[${level.toUpperCase()}]: ${message}`);
}

// bind() legt das erste Argument ('WARN') fest und gibt neue Funktion zurück
const warn = log.bind(null, 'WARN'); 

warn('Achtung, Fehler'); // [WARN]: Achtung, Fehler
            

const pipe = (...fns) => (x) => fns.reduce((y, f) => f(y), x);

const verdoppeln = (x) => x * 2;
const addiereEins = (x) => x + 1;

// Erstellt eine Pipeline, die von links nach rechts liest
const transformiere = pipe(addiereEins, verdoppeln); 

const ergebnis = transformiere(5); // 5 -> 6 -> 12
            

const zahlen = [1, 2, 3, 4];

// Reducer-Funktion: Definiert, wie akkumuliert wird
const summe = (akkumulator, zahl) => akkumulator + zahl;

// Reduziere das Array mit der Summe-Funktion (Startwert 0)
const total = zahlen.reduce(summe, 0); // 10
            

const namen = ['Max', 'Anna'];

// Die Funktion wird für jedes Element ausgeführt, ohne eine for-Schleife zu schreiben.
namen.forEach(name => {
    console.log(`Hallo, ${name}!`);
});
            

const istGross = (wort) => wort.length > 5;

// Point-Free: Die Funktion istGross wird direkt übergeben.
const langeWoerter = ['kurz', 'sehrlang'].filter(istGross); 

// Nicht Point-Free (würde eine temporäre Variable nutzen):
// const langeWoerter = ['kurz', 'sehrlang'].filter(w => istGross(w));
            

const daten = [10, 'Fehler', 20];

// Callback: Prüft, ob der Wert eine Zahl ist
const istZahl = (wert) => typeof wert === 'number';

// filter() nutzt die Prüfungs-Funktion als Strategie
const nurZahlen = daten.filter(istZahl);