Funktionen

Funktionsaufruf

sayHi();

const result = addNumbers(5, 8);

Function declarations

Deklarierte Funktionen sind überall in der Datei (Bzw. in ihrem Scope) aufrufbar.
Sie haben immer einen Namen.

Einfache Funktion:

function printTime() {
    const d = new Date();
    console.log(`Es ist ${d.getHours()}:${g.getMinutes()});
}

Funktion mit Parametern und Rückgabewert:

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

Function expressions

Funktionen können auch Teil eines Ausdrucks sein. Damit können wir Funktionen in einer Variable ablegen oder als Argument an eine andere Funktion übergeben.
In diesem Fall müssen Funktionen keinen Namen haben (Anonymous Function), können aber (Named Function).

const func = function(param) {
    return param ** 2;
}
const result = func(2);
// Als Argument:
anotherFunc(func);

Arrow functions

Arrow Functions sind eine alternative Syntax für Funktionsausdrücke (function expression).
Diese sind ähnlich als "Lambda"-Funktionen auch in Java oder Python zu finden.
Vorteile:

• Schlanke Syntax
• Impliziter Rückgabewert (Kein return)
• Erleichtert funktionale Programmierung

// Mit einem Parameter
const func = x => x ** 2;

// Mit mehreren Parametern
const addNumbers = (a, b) => a + b;

// Mehrzeilige Funktion auch möglich
const longerFunc = (a, b) => {
    if (a <= 0 || b <= 0) {
        return null;
    }
    // ACHTUNG! return ist hier nötig
    return a + b;
}

Scope and closures

Scope

Der Scope bestimmt die Sichtbarkeit und Lebensdauer von Variablen in JavaScript.
Wenn eine Funktion beendet ist, wird der Scope verlassen und alle inneren Variablen werden aufgeräumt.

let outer = 1;
function addOuterAndInner() {
    const inner = 2;
    // Hier sind 'outer', 'inner' und 'number' sichtbar
    return outer + inner;
}
const resultA = addOuterAndInner(); // -> 3
outer = 2;
const resultB = addOuterAndInner(); // -> 4
// Hier ist 'outer' sichtbar, 'number' gibt es nicht
const resultC = outer + inner; // Error

Closure

Eine Closure entsteht, wenn eine Funktion auf Variablen aus ihrem äußeren Scope zugreift. Auch nachdem dieser äußere Scope bereits ausgeführt wurde, bleiben die Variablen "am Leben". Dies ist eines der mächtigsten Konzepte in JavaScript.

function createAddFunction(base) {
    const example = 'hi';
    // 'base' und 'example' sind nur hier drinnen sichtbar.
    return function generatedAddFunction(toAdd) {
        // 'base' ist im Closure von generatedAddFunction
        return base + toAdd;
    }
    // 'example' wird hier aufgeräumt. 'base' bleibt im Speicher
}
const addTwo = createAddFunction(2);
addTwo(5); // -> 7