Rust Basic Syntax

Variable, Basistypen, Funktionen, Kommentare und Steuerroutinen, diese sind fast in jedem Programmiersprache vorhandene Programmierkonzepte.

Diese grundlegenden Konzepte sind in jedem Rust-Programm vorhanden, und das frühzeitige Lernen davon wird Ihnen helfen, Rust so schnell wie möglich zu erlernen.

Variable

Es muss zunächst erklärt werden, dass Rust ein stark typisiertes Programmiersprache ist, aber über die Fähigkeit verfügt, Variabletypen automatisch zu erkennen. Dies kann leicht zu Verwirrung mit schwach typisierten Programmiersprachen führen.

Um eine Variable zu deklarieren, muss der Schlüssel "let" verwendet werden. Zum Beispiel:

let a =　123;

Entwickler, die nur JavaScript gelernt haben, sind diesem Satz sehr sensibel, während Entwickler, die nur C-Sprache gelernt haben, diesen Satz nicht verstehen.

Nach dieser Deklarationszeile sind die folgenden drei Zeilen verboten:

a = "abc";
a =　4.56;　
a =　456;

Der Fehler in der ersten Zeile liegt darin, dass "a" als 123 In Zukunft wird "a" als ganzzahliges Zahlensystem festgelegt und es kann keine Werte des Typs String zugewiesen werden.

Der Fehler in der zweiten Zeile liegt darin, dass bei der automatischen Konvertierung der Genauigkeit verloren geht, Rust erlaubt keine automatischen Datenkonvertierungen mit Genauigkeitsverlust.

Der Fehler im dritten Zeilen liegt darin, dass "a" keine veränderliche Variable ist.

Die ersten beiden Fehler sind leicht zu verstehen, aber was bedeutet der dritte? Ist "a" nicht eine Variable?

Das führt uns zu der Designentscheidung von Rust für die Sicherheit bei hoher Konnektivität: Der Wert einer Variable wird auf Sprachebene so wenig wie möglich geändert. Daher ist der Wert von "a" unveränderlich. Dies bedeutet jedoch nicht, dass "a" keine "Variable" (im Englischen "variable") ist. Die offizielle Dokumentation nennt solche Variablen "unveränderliche Variablen".

Wenn ein Teil unseres Programms unter der Annahme läuft, dass ein Wert niemals geändert wird, während ein anderes Teil unseres Codes den Wert ändert, könnte der erste Teil möglicherweise nicht wie beabsichtigt funktionieren. Fehler, die durch diese Ursachen verursacht werden, sind schwer nachträglich zu finden. Dies ist der Grund, warum Rust diese Mechanismen in der Sprache entworfen hat.

Natürlich, um eine Variable "veränderlich" (mutable) zu machen, reicht ein "mut"-Schlüssel.

let mut a =　123;
a =　456;

This program is correct.

Difference between Constants and Immutable Variables

Since immutable variables are immutable, aren't they constants? Why are they called variables?

There is still a difference between variables and constants. In Rust, the following program is legal:

let a =　123;
let a =　456;

But it is not legal if a is a constant:

const a: i32　=　123;
let a =　456;

Variable values can be 'rebound', but they cannot be changed privately before rebinding, which ensures that the compiler can fully infer the program logic after each 'binding'. Although Rust has the function of automatic type judgment, in some cases, declaring the type is more convenient:

let a: u64　=　123;

Here, a is declared as unsigned 64 Bit integer variables, if not declared with a type, will be automatically judged as signed. 32 Bit integer variables, which have a significant impact on the value range of a.

Shadowing

The concept of shadowing is different from the 'override' or 'overload' in other object-oriented languages. Shadowing is what is referred to as 'rebinding' mentioned earlier, and the quotation marks are used to substitute for the concept without introducing it at the time.

Shadowing refers to the mechanism by which variable names can be reused:

fn main() {
　　　　let x =　5;
　　　　let x = x　+　1;
　　　　let x = x　*　2;
　　　　println!("The value of x is: {}", x);
}

The runtime result of this program is:

The value of x is:　12

Shadowing and assignment of mutable variables are not the same concept. Shadowing refers to the mechanism of reusing the same name to represent another variable entity, which can change in type, mutability, and value. However, assignment of mutable variables can only occur in terms of value changes.

let mut s = "123";
s = s.len();

This program will cause an error: You cannot assign an integer value to a string variable.