Rost -Befehlszeilenargumente

Befehlszeilenargumente beziehen sich auf eine Reihe von Werten oder Angaben, die an den Namen eines Terminalprogramms übergeben werden. Diese Argumente können daher das Verhalten des Programms wie im Quellcode definierten Programms ändern.

Sie können beispielsweise das Verzeichnis übergeben, das Sie an den Befehl LS auflisten möchten. Daher wird der Weg zum Verzeichnis als Argument für den LS -Befehl bezeichnet.

Dieser Artikel wird die Grundlagen des Annehmens und Parsing -Befehlszeilenargumente in der Rust -Programmiersprache unter Verwendung des Env -Moduls aus der Standardbibliothek durchführen.

Setup & Imports

Der erste Schritt besteht darin, ein Verzeichnis zu erstellen, um unseren Quellcode zu speichern. Lassen Sie uns zum Einfachheit halber ein Rostpaket mit Fracht erstellen wie:

$ Cargo New Rust_Arguments

Benennen Sie Ihr Projekt in einen beliebigen Namen um, den Sie für richtig halten.

Navigieren Sie als nächstes in das Quellverzeichnis und öffnen Sie die Haupt.RS -Datei mit Ihrem bevorzugten Texteditor.

$ CD Rust_Arguments/SRC && vim Main.Rs

Der zweite Schritt besteht darin, die erforderlichen Module zu importieren. Wir werden das Env-Modul aus der Standardbibliothek verwenden, um Befehlszeilenargumente für diesen Artikel zu analysieren.

Das Env -Modul bietet eine Funktion für die Arbeit mit Umgebungsvariablen, Argumenten usw. Um es zu verwenden, importieren Sie es mit:

Verwenden Sie std :: env;

Argumentvektor

In der Hauptfunktion müssen wir einen Vektor von Zeichenfolgen erstellen, der die Argumente enthält, die wir an das Programm übergeben werden.

Wir können dies tun, indem wir die folgende Zeile hinzufügen:

lass args: vec = en :: args ().sammeln();

Der obige Code verwendet die Sammelmethode, um das an die Argumente übergebene Argument zu iterieren und dem Vektor hinzuzufügen. Der Vektor ist vom VEC in unserem Fall vom VEC -Zeichenfolgen. Dies liegt daran, dass Rost die Art der Vektorsammlung nicht schließen kann.

Argumente drucken

Jetzt, da wir Befehlsargumente akzeptieren und in einen Vektor speichern können, versuchen Sie es mit dem Drucken. Wir können dies mit der ITER -Funktion tun, wie unten gezeigt:

Verwenden Sie std :: env;
fn main ()
lass args: vec = en :: args ().sammeln();
für arg in args.iter ()
println!("", arg);

Die ITER -Funktion wird über jedes an das Programm übergebene Argument iteriert und drucken Sie es aus. Wenn wir den obigen Code ausführen, sollten wir eine Ausgabe als:

Das Programm gibt den Namen der ausführbaren Datei zurück. Rost behandelt den Namen der ausführbaren Datei als erstes Argument. Daher ist das Argument am Index 0 im Argumentvektor der Weg zum Namen des Programms.

Dies ist ein häufiges Merkmal in anderen Programmiersprachen, einschließlich C, Python, Go usw.

Wenn wir nach dem Namen des Programms andere Argumente vorlegen.

Zum Beispiel:

Frachtlauf Argument1 Argument2 Argument3… Argumentn

Beachten Sie, dass das obige Beispiel 5 Argumente an das Programm übergeben. Das Ergebnis ist wie gezeigt:

Ziel \ Debug \ sust_cmd_args.exe
Argument1
Argument2
Argument3
…
argumentn

Wie Sie sehen können, druckt das Programm alle übergebenen Argumente zurück.

Zugriff auf und sparen Argumente

Bisher haben wir nur die Argumente aus dem Programm gedruckt. Obwohl es zeigt, wie Argumentvektoren funktionieren, tut es nicht wirklich viel.

Wir können auf jedes Argument auf eine Variable zugreifen und speichern, um unser Programm zu erweitern.

Um auf ein Argument zuzugreifen, können wir den Index als:

Verwenden Sie std :: env;
fn main ()
lass args: vec = en :: args ().sammeln();
println!("", args [1]);

Im obigen Beispiel greifen wir mit Index 1 auf das erste Argument zu. Das Ergebnis ist wie gezeigt:

Frachtlauf Hi!

Wir können das Argument in eine Variable speichern wie:

Verwenden Sie std :: env;
fn main ()
lass args: vec = en :: args ().sammeln();
Sei Greet = & Args [1];
Wenn Greet == "Hi"
println!("Hallo zurück!");
anders
println!("Wir akzeptieren nur Grüße!"))

Im obigen Programm akzeptieren wir, um das erste Argument zu speichern und es in einer Variablen zu speichern. Wir verwenden dann seinen Wert in einem if… sonst ein Block, um eine Aktion auszuführen.

Wir können den obigen Code als:

$ Cargo laufen Hallo

Das Programm sollte zurückgeben, „Hallo zurück!" als:

Wenn wir ein anderes Argument verabschieden, das nicht gleich „Hallo“ ist, haben wir den anderen Block ausgeführt wie:

$ fracht laufen tschüss

Abschluss

Fantastisch! Wir haben ein Programm, das damit akzeptieren, analysieren, sparen und Argumente. Üben Sie weiter, um mehr zu lernen.