====== Funktionen ======
Funktionen sind Unterprogramme, die ein Resultat zurückliefern (können).

Das erlaubt es, ein Programm in kleine, übersichtliche Einheiten zu zerlegen. Das macht den Code einfacher und zugleich flexibler (und wiederverwendbarer).

Eine Funktion hat (normalerweise) einen **Namen**, eine Liste von **Argumenten** (d.h. Werte, die übergeben werden) und meistens ein Resultat, das mit **return** zurückgegeben wird.

Beispiel:
<code javascript>
// Berechnet die Summe der ersten n Zahlen
function summe(n) {  // n ist ebenfalls eine lokale Variable und existiert nur hier (und unabhängig von anderen Variablen, die auch n heissen könnten).
  let s = 0;   // Das eine lokale Variable und existiert nur hier (und unabhängig von anderen Variablen, die auch s heissen könnten).
  for (let i=1; i<=n; i++) {
     s += i;
  }
  return s;  // Resultat zurückgeben und Funktion sofort beenden.
  console.log("Das ist überflüssiger Code und wird nie ausgeführt!");
}

console.log(`Die Summe von 1 bis 100 ist ${summe(100)}`)
console.log(`Die Summe von 1 bis 1000 ist ${summe(1000)}`)

</code>

==== Lokale Variablen ====
Damit sich verschiedene Programmteile nicht gegenseitig «dreinpfuschen», sollten immer lokale Variablen verwendet werden, d.h. Variablen die nur in der Funktion existieren und nichts mit eventuellen Variablen mit gleichem Namen ausserhalb der Funktion etwas zu tun haben. 

Das setzt aber auch voraus, dass alle nötigen Daten als Argumente übergeben werden. Die Argumente sind dann ebenfalls lokale Variablen.

//Hinweis: Werden Arrays oder Objects als Argumente übergeben, erhält man keine Kopie, sondern eine Referenz darauf. Wird der Inhalt der Arrays oder des Objects verändert, ändert man das originale Arrays (bzw. Object)//

<code javascript>
function sum(a,b) {
    console.log(`    sum start:  a=${a}, b=${b}`);
    let c = a;
    a = a+b;
    console.log(`    sum ende :  c=${c}, a=${a}, b=${b}`);
    return a;
    // natürlicher wäre es, direkt return a+b; zu schreiben...
}

function bla(a,b) {
    console.log(`  bla start :  a=${a}, b=${b}`);
    a = sum(a,b);
    console.log(`  bla middle:  a=${a}, b=${b}`);
    b = sum(a,b);
    console.log(`  bla ende  :  a=${a}, b=${b}`);
    return b;
}

let a = 4;
let b = 5;
console.log(`main start: a=${a}, b=${b}`);
let c = bla(a,b);
console.log(`main ende : a=${a}, b=${b} c=${c}`);
</code>

Ausgabe:
<code txt>
main start: a=4, b=5
  bla start :  a=4, b=5
    sum start:  a=4, b=5
    sum ende :  c=4, a=9, b=5
  bla middle:  a=9, b=5
    sum start:  a=9, b=5
    sum ende :  c=9, a=14, b=5
  bla ende  :  a=9, b=14
main ende : a=4, b=5 c=14
</code>


===== Aufgaben =====
<WRAP todo>
Programmieren Sie eine Funktion ''stringMul'', die einen String mehrfach hintereinanderhängt:

<code javascript>
console.log(stringMul("*",5));      // liefert *****
console.log(stringMul("bla ",3));   // liefert bla bla bla
</code>


<hidden Lösungsvorschlag>
<code javascript>
function stringMul(str, n) {
    let res = "";
    for (let i=0; i<n; i++) {
        res += str;
    }
    return res;
}

console.log(stringMul("*",5));      // liefert *****
console.log(stringMul("bla ",3));   // liefert bla bla bla
</code>
</hidden>
</WRAP>

<WRAP todo>
Schreiben Sie eine Funktion ''toLeet'', die einen String (teilweise) in [[https://en.wikipedia.org/wiki/Leet|Leet]] umwandelt.

Hinweise: 
  * Machen Sie ein Object, das als Keys die Buchstaben und als Wert die Ersetzung hat. 
  * Sie können die 
    * [[https://www.w3schools.com/jsref/jsref_replace.asp|replace]]-Methode oder die [[https://www.w3schools.com/jsref/jsref_string_replaceall.asp|replaceAA]]-Methode verwenden, oder
    * Buchstabe für Buchstabe durch den String gehen (um mehrmalige Ersetzungen zu vermeiden).
  * Sie könnten auch mehrere Ersetzungen als Array definieren und jeweils eine daraus zufällig auswählen.

<hidden Lösungsvorschlag (einfach)>
<code javascript>
function toLeet(str) {
   str = str.replace("a", "4");
   str = str.replace("e", "3");
   str = str.replace("t", "7");
   // etc...
   return str;
}

</code>
</hidden>


<hidden Lösungsvorschlag  (advanced, mit Object)>
<code javascript>
function toLeet(str) {
    let reps = {a:['4', '^','@'],
                b:['6','8'],
                c:['(', '[',],
                d:['|)', 'cl'],
                e:['3'],
                f:['/=', 'ph'],
                g:['9'],
                h:['|-|', '1-1'],
                i:['1','|'],
                j:['j'],
                k:['|<'],
                l:['1', '|_'],
                m:['|\\/|', '^^'],
                n:['|\\|', '/V'],
                o:['0', '()'],
                p:['|"','|>'],
                q:['()_'],
                r:['/2', 'I2'],
                s:['5', '$', 'z'],
                t:['7'],
                u:['|_|', '(_)'],
                v:['\\/'],
                w:['\\/\\/', '\\^/'],
                x:['><'],
                y:['\\|/'],
                z:['7_', '2']       
    };
    str = str.toLowerCase();
    let neu = "";
    for (let p=0; p<str.length; p++) {
        if (str[p] in reps) {
            let rep = reps[str[p]];
            neu += rep[Math.floor(Math.random()*rep.length)];
        } else {
            neu += str[p];
        }
    }
    return neu;
}

let text = "The brown dog jumps over the lazy fox";
console.log(text)
console.log(toLeet(text))
</code>
</hidden>
</WRAP>