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:

// 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)}`)

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)

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}`);

Ausgabe:

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

Programmieren Sie eine Funktion stringMul, die einen String mehrfach hintereinanderhängt:

console.log(stringMul("*",5));      // liefert *****
console.log(stringMul("bla ",3));   // liefert bla bla bla

Lösungsvorschlag

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

Schreiben Sie eine Funktion toLeet, die einen String (teilweise) in Leet umwandelt.

Hinweise:

Machen Sie ein Object, das als Keys die Buchstaben und als Wert die Ersetzung hat.
Sie können die
- replace-Methode oder die 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.

Lösungsvorschlag (einfach)

function toLeet(str) {
   str = str.replace("a", "4");
   str = str.replace("e", "3");
   str = str.replace("t", "7");
   // etc...
   return str;
}

Lösungsvorschlag (advanced, mit Object)

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))

Funktionen

Lokale Variablen

Aufgaben

https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG