Rostfunktionen

In diesem Leitfaden wird untersucht, wie Funktionen in der Rost -Programmiersprache erstellt und verwendet werden können. Funktionen sind ein universelles Merkmal in den meisten Programmiersprachen und für jeden Entwickler von grundlegender Bedeutung.

Was ist eine Funktion?

Bevor wir uns mit den Details des Erstellens und der Verwendung einer Funktion befassen, lassen Sie uns aufschlüsseln, was eine Funktion ist und warum sie verwendet werden soll.

Eine Funktion ist nichts anderes als ein oder mehrere Codeblocke, der zusammengefasst ist und eine einzelne Entität ausführt. Funktionen sind in den meisten Programmiersprachen ein starkes Merkmal, da wir es uns ermöglichen, Code in anderen Teilen des Programms in einem lesbaren Muster zu organisieren und zu exportieren.

Inzwischen sind Sie auf die Hauptfunktion in der Rostsprache gestoßen. Die Hauptfunktion ist eine spezielle Art von Funktion, die als Einstiegspunkt für ein Rostprogramm dient.

Lassen Sie uns diskutieren, wie wir Funktionen in Rost erstellen und verwenden können.

Rostfunktionen

Im Folgenden sind die Schritte zu unternehmen, um eine Funktion in Rost zu definieren.

1. Wir beginnen mit dem Schlüsselwort Fn.
2. Als nächstes setzen wir den Namen der Funktion.
3. Ein Paar Klammern und übergibt eine Liste von Parametern.
4. Definieren Sie einen Funktionskörper unter Verwendung von Öffnungs- und Schließen von lockigen Zahnspangen.
5. Schließlich ein Rückgabewert (falls verfügbar).

Wir können den obigen Code in der unten gezeigten Syntax ausdrücken:

fnfunction_name (Parameter)
// Funktionskörper

Die grundlegendste Art der Funktion ist eine, die keine Parameter akzeptiert und einen Rückgabewert enthält. Wir können eine solche Funktion definieren, wie im folgenden Beispiel gezeigt:

fn say_hello ()
println!("Hallo Welt");

Das obige zeigt das grundlegendste Konzept einer Funktionsdefinition. Wir beginnen mit dem Schlüsselwort Fn, gefolgt vom Namen der Funktion, in unserem Fall Say_hello (). Wir öffnen dann den Funktionskörper in einem Paar lockiger Zahnspangen.

Der Funktionskörper enthält nur die Logik dessen, was die Funktion tut. Gelegentlich ruft eine Funktion andere Funktionen auf und verwendet sie.

Eine Funktion aufrufen

Sobald wir eine Funktion deklariert haben, können wir sie verwenden, um die definierten Aktionen auszuführen. Wir verweisen auf den Prozess der Verwendung einer Funktion als Funktionsaufruf oder aufrufen eine Funktion.

In Rost nennen wir eine Funktion, indem wir ihren Namen und ein Paar Klammern angeben. Dies teilt dem Compiler mit, dass wir die in dieser Funktion definierten Anweisungen ausführen möchten.

In unserem Beispiel können wir unsere Funktion in der Hauptfunktion aufrufen, wie im folgenden Beispiel gezeigt:

fn main ()
//! Rufen Sie die Funktion auf
sag Hallo();

/// Funktionserklärung
fn say_hello ()
println!("Hallo Welt");

Funktionsparameter

Einer der Hauptgründe für die Verwendung von Funktionen ist die Übergabe der Parameter. Ein Parameter ist eine spezielle Art von Variable, die wir an die Funktion übergeben und eine Änderung der Logik ermöglichen, die die Funktion verwendet.

Sie können oft die Begriffe Wortparameter und Argument hören, die austauschbar verwendet werden. Obwohl sie einen Unterschied haben, ist es wirklich nichts, um Sie davon abzuhalten, mit Rost Werkzeuge zu bauen.

Um eine Reihe von Funktionsparametern zu definieren, definieren wir zunächst den Parameternamen, gefolgt von seinem Typ in den Funktionsklammern.

Die Syntax ist wie gezeigt:

FN FUNKTION_NAME (Parameter1: data_type)
// Funktionskörper

Hinweis Sie müssen Typanmerkungen für einen Funktionsparameter ausführen.

Nehmen wir die Funktion Say_hello, die wir früher definiert haben.

Wir können:

fn say_hello (name: & str)
println!("Hallo, ", Name);

Im obigen Beispiel definieren wir einen Parameter für die Funktion Say_hello vom Typ & Str. Wir können jetzt einen Namen an die Funktion übergeben, und er wird uns mit dem angegebenen Namen begrüßen.

Um den Parameter während des Funktionsaufrufs zu übergeben, können wir dies tun:

fn main ()
Say_hello ("Sarah!");

fn say_hello (name: & str)
println!("Hallo, ", Name);

Funktionsanweisung und Ausdruck

Wie bereits erwähnt, umfasst eine Funktionsbehörde Codeanweisungen, die eine Aktion ausführen. Wir haben ein definiertes Makro verwendet, um in unserem Beispiel etwas auf den Bildschirm zu drucken. Wir können jedoch eine benutzerdefinierte Logik für unsere Funktionen erstellen.

Nehmen Sie beispielsweise die folgende Funktion, die zwei Ganzzahlen erfordert, und geben Sie das Maximum der beiden zurück:

fnmaximum (x: i32, y: i32)
Sei Mut max = 0;
Wenn x> y
max = x;
anders
max = y;

println!("Max -Wert ist: ", max);

Wir können dann die Funktion aufrufen und die beiden Ganzzahlwerte wie unten gezeigt übergeben:

fn main ()
maximal (100, 50);

Ausführen des obigen Codes sollte gedruckt werden:

Maximaler Wert ist: 100

Funktionsertragswerte

Eine Funktion kann auch einen Wert zurückgeben, der auf der von ihm ausgeführten Logik und den Aktionen basiert. Wir können dann den von der Funktion zurückgegebenen Wert verwenden, um andere Vorgänge auszuführen. Obwohl wir den Rückgabewert in einer Funktion nicht nennen, müssen wir dem Compiler mitteilen, dass wir erwarten, dass die Funktion einen Wert eines bestimmten Typs zurückgibt.

Wir tun dies mit dem Pfeil -> Notation.

Nehmen Sie die Maximum () -Funktion, die wir zuvor definiert haben. Anstatt den maximalen Wert zu drucken, können wir die Funktion den maximalen Wert zurückgeben, und wir können ihn verwenden, um auf andere Teile des Programms zu reagieren.

Um einen Funktionsrückgabe -Typ zu definieren, können wir die Syntax als:

fn Function_name (Parameter: Typ) -> return_type
// Funktionskörper

Betrachten Sie das folgende Beispiel, das die maximale Funktion neu definiert, um einen Rückgabewert zu berücksichtigen:

fn maximum (x: i32, y: i32) -> i32
// Logik

In diesem Fall erwarten wir, dass die Funktion einen i32 -Typ zurückgibt.

Sobald wir einen Funktionsertragstyp definiert haben, müssen wir sicherstellen, dass die Funktion tatsächlich etwas zurückgibt.

Wir können dies mit dem Keyword zurückgeben. Um beispielsweise den Maximalwert aus der obigen Funktion zurückzugeben, können wir dies tun:

fnmaximum (x: i32, y: i32) -> i32
Sei Mut max = 0;
Wenn x> y
max = x;
anders
max = y;

MAX zurückgeben;

Die Funktion sollte den Wert der maximalen Variablen zurückgeben.

Ein anderes Format, mit dem wir einen Wert aus einer Funktion zurückgeben können, besteht darin, den Rückgabewert ohne Semikolon-Terminator anzugeben.

Ein Beispiel ist wie gezeigt:

fnmain ()
Say_hello ("Sarah!");
maximal (100, 50);

fnsay_hello (name: & str)
println!("Hallo, ", Name);

fnmaximum (x: i32, y: i32) -> i32
letMut max = 0;
Wenn x> y
max = x;
anders
max = y;

// Kein Rückgabetastaturword oder Semi-Colon
Max

Das obige Beispiel sollte sich ähnlich wie das Keyword der Rückgabe verhalten.

Wir können dann den von der Funktion zurückgegebenen Wert verwenden, um eine Aktion auszuführen. Zum Beispiel:

fn main ()
println!("Produkt: ", maximal (100, 10) * 2);

Hier nehmen wir den von der maximalen Funktion zurückgegebenen Wert und multiplizieren Sie ihn mit 2.

Abschließend

Für dieses Tutorial haben wir das Konzept der Funktionen untersucht, wie man eine Funktion, Funktionsparameter, Funktionsrückgabewerte und mehr definiert. Funktionen sind ein wichtiges Konzept für die Programmierung, und sie ermöglichen es uns, Code ohne Wiederholung zu organisieren und wiederzuverwenden.

Wir hoffen, Sie haben das Tutorial genossen.

Bis bald!