Eine Einführung in Rust für Entwickler
Rust ist eine moderne, systemnahe Programmiersprache, fokussiert auf Sicherheit, Geschwindigkeit und Parallelität ohne dabei auf einen Garbage Collector zu setzen.
Sicherheit, Geschwindigkeit und Parallelität
in einer Sprache, perfekt für Systemprogrammierung und WebAssembly.
Mit rustup schnell und einfach installiert
rustup
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Typen können explizit oder durch Kontextinferenz angegeben werden.
let logical: bool = true; let a_float: f64 = 1.0; // Regular annotation let an_integer = 5i32; // Suffix annotation let default_float = 3.0; // `f64` let default_integer = 7; // `i32` let mut inferred_type = 12; // Type inferred from another line inferred_type = 4294967296i64; // mutable value can be changed println!("1000 as a u8 is : {}", 1000 as u8); // type casting
Immutability wird bevorzugt, Variablen sind standardmäßig unveränderlich.
let x = 5; // Unveränderlich let mut y = 5; // Veränderlich let mut mutable = 12; // Mutable `i32` mutable = 21; // Error! The type of a variable can't be changed. mutable = true; // Variables can be overwritten with shadowing. let mutable = true;
fn some_fn() { () } fn main() { let _a: () = some_fn(); println!("This function returns and you can see this line."); }
Funktionen können Tupel als Argumente oder Rückgabewerte nutzen.
fn reverse(pair: (i32, bool)) -> (bool, i32) { // `let` can be used to bind the members of a tuple to variables. let (int_param, bool_param) = pair; (bool_param, int_param) }
Arrays speichern Objekte desselben Typs T in kontinuierlichem Speicher.
T
// Fixed-size array (type signature is superfluous). let arr: [i32; 5] = [1,2,3,4,5]; // Ein Slice des Arrays, das vom 1. bis zum 3. Element reicht (exklusiv) let slice = &arr[1..3];
Slices sind ähnlich, aber ihre Länge ist zur Kompilierzeit nicht bekannt.
Strukturen können einfach aus den Primitiven erstellt werden
struct Person { name: String, age: u8, } // Erstellen einer Instanz von `Person` let person = Person { name: String::from("Max Mustermann"), age: 30, }; println!("Name: {}", person.name);
Aufzählungen können aus unterschiedlichen Typen erstellt werden. Jedes Element muss unterschiedlich und unabhängig sein.
enum WebEvent { // either be 'unit-like' PageLoad, PageUnload, // like tuple structs KeyPress(char), Paste(String), // or c-like structures Click { x: i64, y: i64 } } let pressed = WebEvent::KeyPress('x');
ähnelt anderen Sprachen. keine Klammern um die Bedingung.
let n = 5; if n < 0 { println!("{} ist negativ", n); } else if n > 0 && n < 10 { println!("{} liegt zwischen 0 und 10", n); } else { println!("{} ist positiv oder null", n); }
Operationen wiederholen, bis sie erfolgreich sind. Mit break kann ein Wert zurückgegeben werden.
let mut counter = 0; let result = loop { counter += 1; if counter == 10 { break counter * 2; } };
Fehler werden explizit mit Result und Option Typen behandelt.
Result
Option
match read_file("config.txt") { Ok(content) => println!("Inhalt: {}", content), Err(e) => println!("Fehler beim Lesen: {:?}", e), }
Eine Crate ist eine Kompilationseinheit in Rust.
// import extern crate rary use rary; fn main() { rary::public_function(); // Error! `private_function` is private rary::private_function(); }
Das offizielle Rust-Paketverwaltungswerkzeug. Es unterstützt:
cargo new foo # binary oder cargo new --lib bar # library
// Projektstruktur └── foo ├── Cargo.toml └── src └── main.rs
Die Cargo.toml ist die Konfigurationsdatei für Cargo.
[package] name = "foo" version = "0.1.0" authors = ["unknown"] [dependencies]
fn main() { println!("Hello World!"); }
Unit- und Integrationstests nativ
Unit Tests zum Modul gespeichert; Integration Tests in eigenen Ordner
foo ├── Cargo.toml ├── src │ └── main.rs │ └── main.test.rs └── tests └── my_test.rs
Starte alle Tests mit cargo test
cargo test
Beispiel Test
#[cfg(test)] mod tests { // Import the necessary modules use std::fs::OpenOptions; use std::io::Write; // This test writes to a file #[test] fn test_file() { // Opens the file ferris.txt or creates one if it doesn't exist. let mut file = OpenOptions::new() .append(true) .create(true) .open("ferris.txt") .expect("Failed to open ferris.txt"); // Print "Ferris" 5 times. for _ in 0..5 { file.write_all("Ferris\n".as_bytes()) .expect("Could not write to ferris.txt"); } } }
Nutz das Rust Buch, Rustlings, und rustup.rs, um tiefer in Rust einzusteigen.
Welche Fragen haben sich gesammelt?
Lasst uns diskutieren.
WieErWill.dev/vcard.vcf