*Funktionen
Wozu sind Funktionen gut?
Funktionen gehören zu den elementaren Bestandteilen von Programmiersprachen. In Rust ist das nicht anders. Funktionen helfen einem, Code der öfters verwendet wird, wiederzuverwerten, ohne immer alles wieder von vorne schreiben zu müssen. Sie sollen einem helfen, die Logik einer Aufgabe zu spiegeln und mit verschiedenen Kontrollmechanismen, Fehler zu vermeiden. Die ganze Zeit über, hatten wir es bereits mit einer Funktion zu tun, vermutlich unbemerkt. Die main-Funktion. Daraus lässt sich zumindest ein gewisser gültiger Syntax ableiten.
fn funktionsname(){
...Inhalt der Funktion}
Im übrigen sollten Funktionen nicht innerhalb der main()-Funktion selbst geschrieben werden, sondern je nach Vorliebe, ober- oder unterhalb. Das hilft einem mehr Überblick zu behalten. Das eine möchte ich schonmal vorausschicken. Zum einen gibt es die Funktionen außerhalb der main, und den Funktionsaufruf(das ist keine Funktion) innerhalb der main, oder einen Funktionsaufruf innerhalb einer anderen Funktion. Verschiedene Programmteile, die an vollkommen unterschiedlicher Stelle stehen können, werden miteinander interagieren. Keine Ahnung warum, das hat ich immer fasziniert.
Funktionen bestehen aus einigen Bestandteilen. Um nicht mit der Tür ins Haus zu fallen, arbeiten wir sie Schritt für Schritt durch. Nehmen wir als Erstes, einfach mal eine Funktion, die einen Text zurück gibt.
println!("Ich bin der Text der Funktion.");
}
fn main (){
text();
}
Ausgabe
Oder hier, um zu zeigen, dass eine Funktion, Elemente aufnehmen und wiedergeben kann.
fn text1(){
println!("Ich bin der Text der 2ten.Funktion.");
let a = 5;
let b= 7;
let c = a*b;
println!("{}",c);
}
fn main (){
text1();
}
Ausgabe
Um das besser zu verdeutlichen. Immer wenn die Funktion aufgerufen wird, steht diese im vollem Umfang zur Verfügung. Sie lässt sich, wie in diesem Beispiel gezeigt, auch als eine Art Sammelbehälter verwenden, obwohl es dafür bessere Methoden gibt. Jetzt gehen wir mal etwas ins Eingemachte. Ich sagte ja, Funktionen verwenden Kontrollmechanismen, um die Richtigkeit des Codes zu verifzieren. Oder besser noch, sie verweigern den Dienst per Compilerfehler, sollte etwas nicht passen. Naja, das ist erstmal nichts Besonderes. Doch das wird es, wenn ich euch sage, dass ihr diese Mechanismen selbst kontrolliert. Die Funktion ist die Kontrollinstanz über den Funktionsaufruf. Das ist insofern wichtig, weil es einen dazu anhält, besser zu überlegen, was man denn überhaupt tun will. Kommt es zu einem Fehler, lässt es sich nach ein wenig Übung besser nachvollziehen, was denn falsch läuft. Und zwar geht es darum, was die Funktion vom Funktionsaufruf erwartet und umgekehrt.
Eine Funktion hat neben dem Funktionskörper (innerhalb der geschweiften Klammern) auch Parameter (innerhalb) und einen -> Rückgabewert, der genau mit so einem gezeigten Pfeil eingeleitet wird. Die Parameter geben an, welche Datentypen über den Funktionsaufruf erwartet werden, der Rückgabetyp, welchen Datentyp die Funktion selbst zurück geben soll. Die Parameter haben einen Variablennamen und zwingend eine Typannotation. Der Rückgabewert wird nach dem -> Pfeil einfach nur als Datentyp angegeben. Die Parametervariablen und die Namen der Variablen, die für den Funktionsaufruf gedacht sind, müssen nicht den selben Namen haben. Versuchen wir mal eine einfache Funktion, die 2 Zahlen multipliziert.
fn multiply(a:i32, b:i32)->i32
{
let result=a*b;
println!("{} x {} = {}",a,b,result);
result//Rückgabewert
}
fn main (){
let x=15; //entspricht a aus der Funktion
let y=20;//entspricht b aus der Funktion
multiply(x,y); //die beiden Parameterwerte
}
Ausgabe
In diesem Beispiel sind a und b in der Funktion multiply als Parameter verwendet worden. Per Annotation haben wir ihnen einen Typ i32 verpasst. Der Rückgabetyp -> ist ebenfalls ein i32. Bei der Rückgabe (hier als result definiert) gibt es eine Besonderheit. In vielen Programmiersprachen gibt es das Schlüsselwort return. Das kann man in Rust ebenfalls verwenden, ist aber nicht üblich. Es wäre in diesem Beispiel
return result;
gewesen. Allerdings zeichnet sich der Return-Wert in Rust durch die Returnvariable, ohne Semikolon aus. Also, einfach nur
result
Das wars fürs Erste von den Funktionen. Auf sie trifft man immer wieder.