Funktionen

Eine Funktion im Kontext der Programmierung bezieht sich normalerweise auf eine Einheit einer Verrichtung (Routine). Dies mag verwirrend erscheinen, also betrachten wir ein paar konkrete Beispiele.

Während Sie programmieren, bemerken Sie oft, dass Sie ähnliche Aufgaben mehrmals ausführen müssen. Wenn Sie es jedes Mal schreiben, könnten Sie irgendwo einen Fehler machen, und das ganze Programm wird unübersichtlich.

Schauen wir uns ein einfaches Beispiel an.

let sum;

sum = 1 + 2 + 3;
console.log("Sum of 1 ... 3 is ", sum);

Das ist in Ordnung, wenn diese Berechnung nur einmal durchgeführt wird, aber was ist, wenn sie viele Male vorkommt?

let sum;

sum = 1 + 2 + 3;
console.log("Sum of 3 numbers from 1 is ", sum);

sum = 5 + 6 + 7;
console.log("Sum of 3 numbers from 5 is ", sum);

sum = 10012 + 10103 + 10014;
console.log("Sum of 3 numbers from 10012 is ", sum);

Das ist fast genau das Gleiche, dreimal geschrieben, aber nur mit unterschiedlichen Zahlen.

Das Problem ist, dass

• Es ist einfach zu viel Arbeit, also umständlich.

• Wenn es irgendwo einen Fehler gibt, müssen Sie ihn an drei Stellen beheben.

  • In diesem Beispiel ist es schwer zu übersehen, weil man das Ganze sehen kann, aber wenn diese Prozeduren über das ganze Programm verstreut ist, ist es ziemlich schwer, alles richtig zu korrigieren.

• Es ist fast dasselbe wie im zweiten Problem, aber es ist nicht einfach, alles zu korrigieren, wenn man es später besser umschreiben möchte.

Übrigens: Haben Sie einen Fehler in dem obigen Programm bemerkt? Sehen Sie das obigen Programm noch mal und versuchen Sie, es zu finden. Die Antwort steht am Ende dieser Seite.

Trotz des Fehlers funktioniert dieses Programm, und schlimmer noch, es gibt ein Ergebnis aus, das so aussieht. Solche Fehler sind sehr schwer zu finden.

Um solche Probleme zu vermeiden, sollten ähnliche Verarbeitungen an einer Stelle geschrieben werden. Dafür sollte diese Prozedur als eine einzige Verrichtung, also eine Funktion, implementiert werden.

function sum3(num_from) {
  let sum;
  sum = num_from + (num_from + 1) + (num_from + 2);
  console.log("Sum of 3 numbers from", num_from, "is", sum);
}

sum3(1);
sum3(5);
sum3(10012);

Hier wird eine Funktion namens sum3 definiert. Diese Funktion nimmt einen einzelnen Wert (num_from). Dies wird als Argument bezeichnet. Die Funktion berechnet num_from + (num_from + 1) + (num_from + 2) und gibt sie aus.

Wenn Sie es so schreiben, ist die Wahrscheinlichkeit, dass Sie einen Fehler machen, geringer. Wenn diese Funktion einen Fehler enthält, ist es wahrscheinlicher, dass der Fehler gefunden wird, da er an allen Stellen auftritt, an denen diese Funktion verwendet wird.

Oder: Wenn Sie z. B. den Text der Nachricht ändern möchten, müssen Sie im Originalprogramm drei Stellen ändern, im neuen Programm aber nur eine.

Wir werden später noch genauer darauf eingehen, aber spielen Sie zunächst mit einer Funktion.

Die (normalen) Funktionen, wie z. B. sin, im Zusammenhang mit der Programmierung oft als mathematische Funktionen bezeichnet werden. Darauf wird später auf dieser Seite eingegangen.

Jetzt zeige ich, wie man eine Funktion schreibt. Wie Sie vielleicht schon erraten haben, wird sie wie folgt geschrieben werden.

function functionname(arg1, arg2, ...) {
  // Schreiben Sie hier den Vorgang.
}

function some_function_without_arguments() {
  // Eine Funktion, die keine Argumente benötigt
}

function some_function_with_one_argument(arg) {
  // Eine Funktion, die ein Argument benötigt
}

function some_function_with_two_arguments(arg1, arg2) {
  // Eine Funktion mit zwei Argumenten
}

function degree_to_radian(angle_in_degree) {
  let angle_in_radian;
  angle_in_radian = Math.PI * angle_in_degree / 180;

  return angle_in_radian;
}

function degree_to_radian(angle_in_degree) {
  return Math.PI * angle_in_degree / 180;
}

function say_hello() {
  console.log("Hello, world");
}

Die Deklaration/Definition einer Funktion allein bewirkt noch nichts (so wie let a; offensichtlich nichts bewirkt). Daher müssen Sie die Funktion irgendwo verwenden (aufrufen).

Aber das sollte eigentlich selbsterklärend sein. Wenn Sie das oben definierte say_hello() verwenden wollen, müssen Sie nur folgendes schreiben.

say_hello();

Um den Rückgabewert zu verwenden, können Sie ihn entweder direkt nutzen oder in eine Variable einfügen.

let angle;
angle = degree_to_radian(45);
// Sie können auch wie folgt schreiben:
//   let angle = degree_to_radian(45);

console.log(angle);

In diesem Fall können Sie auch wie folgt schreiben:

console.log(degree_to_radian(45));

Wenn es als komplettes Programm geschrieben werden, würde es wie folgt aussehen:

function degree_to_radian(angle_in_degree) {
  let angle_in_radian;
  angle_in_radian = Math.PI * angle_in_degree / 180;

  return angle_in_radian;
}

let angle = degree_to_radian(45);
console.log(angle);

function test() {
  console.log("test");
}

test();
test(1);	// dieses Argument ist bedeutungslos,
		// führt aber nicht zu einem Fehler
test(1, 2);

Variablen müssen mit let deklariert werden, bevor sie zum ersten Mal verwendet wurden. Aber in JavaScript kann eine Funktion vor oder nach ihrer ersten Verwendung deklariert / definiert werden. Das bedeutet, dass die beiden folgenden Schreibweisen völlig richtig sind.

function say_hello() {
  console.log("Hello, world");
}

say_hello();

say_hello();

function say_hello() {
  console.log("Hello, world");
}

Einer der Vorteile des Schreibens einer Reihe von Anweisungen als eine Funktion besteht darin, dass es einfach ist, die Funktion zu verbessern.

Nehmen wir zum Beispiel an, dass eine Funktion namens sum10() wie folgt geschrieben wurde.

function sum10(num_from) {
  let sum;

  sum = num_from + (num_from + 1) + (num_from + 2)
    + (num_from + 3) + (num_from + 4) + (num_from + 5)
    + (num_from + 6) + (num_from + 7) + (num_from + 8)
    + (num_from + 9);

  return sum;
}

console.log(sum10(10));
console.log(sum10(100));

Bei genauerem Hinsehen werden Sie jedoch feststellen, dass sie sich wie folgt formulieren lässt:

function sum10(num_from) {
  let sum = 10 * num_from + 45;
  return sum;
}

console.log(sum10(10));
console.log(sum10(100));

Der wichtigste Punkt ist, dass sum10() verbessert wurde, ohne einen anderen Teil des Programms zu ändern. Das obige Beispiel mag nicht sehr aussagekräftig erscheinen, da es nur als Beispiel diente, aber es ist eine häufige Situation.

Um sie jedoch zu verbessern, ohne etwas anderes als die Funktion zu ändern, müssen das Argument und der Rückgabewert gleich bleiben. Darauf folgt:

Dies ist jedoch nur ein Ideal. Die Entscheidung, welche Argumente und Rückgabewert zu verwenden sind, ist weitgehend eine Frage der Erfahrung. Wenn Sie eine Funktion verbessern, werden Sie oft auch die Argumente ändern wollen. Am Anfang sollten Sie nicht zu viel darüber nachdenken, sondern sie einfach unbeschwert ändern und sich allmählich daran gewöhnen.

Um deutlich zu machen, dass es sich um eine Funktion (und nicht um eine Variable) handelt, wird sie manchmal als func() mit Klammern nach dem Funktionsnamen geschrieben.

Anstatt beispielsweise zu sagen Im obigen Beispiel haben wir eine Funktion namens sum10 erstellt , könnten wir einfach sagen Im obigen Beispiel haben wir sum10() erstellt . Beachten Sie, dass dies die Argumente auslässt, es bedeutet nicht, dass es sich um eine Funktion handelt, die keine Argumente benötigt.

Bisher haben wir besprochen, wie Sie selbst neue Funktionen erstellen können. In diesem Abschnitt werden einige der Funktionen vorgestellt, die in JavaScript von Anfang an zur Verfügung stehen.

Die console.log(), die Sie schon verwendet haben, ist eine der Funktionen¹, die von Anfang an in JavaScript enthalten sind.

Es gibt noch viele weitere, aber wir werden hier nur auf mathematische Funktionen eingehen.

JavaScript bietet eine Vielzahl von mathematischen Funktionen. Für e-Funktion verwenden Sie Math.exp(x). Vergessen Sie nicht, Math. hinzuzufügen. Zum Beispiel

let a = Math.exp(0.5);
console.log(a);

wird $\mathrm{e}^{1/2}$ berechnen und anzeigen.

Analog dazu verwenden Sie Math.sin(x) für Sinus-Funktion. Beachten Sie, dass die Argumente der trigonometrischen Funktionen im Bogenmaß (Radian) angegeben werden. Wie bereits erwähnt, können Sie für $\pi$ die vordefinierte Konstante Math.PI verwenden.

let a = Math.sin(Math.PI / 3);	// sin 60°
console.log(a);

Die Quadratwurzel ist Math.sqrt(x). Der Logarithmus zur Basis e ist Math.log(), und der Logarithmus zur Basis 10 ist Math.log10().

Der Betrag von $x$ kann mit Math.abs(x) ermittelt werden.

Weitere Informationen finden Sie unter Static method auf die Seite https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math (Was die statischen Methoden sind, geht über den Rahmen dieses Artikels hinaus).

sum = 10012 + 10103 + 10014;

sollte

sum = 10012 + 10013 + 10014;

geschrieben werden (die zweite Zahl ist 10013, nicht 10103). Natürlich ist an beidem mathematisch nichts auszusetzen, aber es ist nicht das, was der/die Programmierer/in beabsichtigt hat.

Diese Art von funktioniert und sieht richtig aus, ist aber falsch -Fehler ist sehr schwer zu finden. Es ist sehr wichtig, solcher Fehler möglichst zu vermeiden (und so zu schreiben, dass es schwer ist, Fehler zu machen, bzw. dass sie leicht zu finden sind, wenn man sie doch macht).

In diesem Abschnitt haben Sie etwas über Funktionen gelernt.

• Die Deklaration und Definition einer Funktion wird wie folgt geschrieben.

  function functionname(arg1, arg2, ...) {
    // Schreiben Sie hier den Prozess
  }
  

  • arg1, arg2, … werden als Argumente bezeichnet und können nur innerhalb dieser Funktion verwendet werden. (Sie können sie nennen, wie Sie wollen.)

  • Mit return können Sie den Rückgabewert zurückgeben.

• Außerdem gibt es eine Reihe von Funktionen, die von JavaScript bereitgestellt werden.

• Es gibt viele Dinge, die man beim Schreiben von Funktionen beachten muss, und ich habe schon viel darüber geschrieben, aber schreiben und probieren Sie Programme, ohne zu viel nachzudenken, bis Sie sich daran gewöhnt haben. Wenn Sie sich mit dem Schreiben von Programmen etwas besser auskennen, sollten Sie diese Seite noch einmal lesen und darüber nachdenken, was Sie beim Schreiben einer Funktion beachten müssen.