💡 Hint:
To show the presentation in Fullscreen press "F".
→
or
Space
: Next page
←
: Previous page
ESC
: Show overview
?
: show help
RusTorial
Eine Einführung in Rust für Entwickler
<h2 id="was-ist-rust">Was ist Rust?</h2><p>Rust ist eine moderne, systemnahe Programmiersprache, fokussiert auf <br/><code>Sicherheit, Geschwindigkeit und Parallelität</code><br/> ohne dabei auf einen Garbage Collector zu setzen.</p>
<h2 id="warum-rust">Warum Rust?</h2><ul> <li><strong>Zero-Cost Abstractions</strong>,</li> <li><strong>Memory Safety</strong> und</li> <li><strong>Concurrency</strong></li> </ul><p>in einer Sprache, perfekt für Systemprogrammierung und WebAssembly.</p>
<h3 id="installation">Installation</h3><p>Mit <code>rustup</code> schnell und einfach installiert</p><pre><code class="language-bash">curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh </code></pre><br/><small>hier Beispiel für Linux; mehr Infos auf <a href="https://www.rustup.rs">rustup.rs</a></small>
<h3 id="in-rustup-dabei">In RustUp dabei</h3><ul> <li><strong>Cargo</strong>: Build-System und Package-Manager</li> <li><strong>Test</strong>: Integrierte Testwerkzeuge</li> <li><strong>Clippy</strong>: Linting-Werkzeug</li> <li><strong>Rustfmt</strong>: Formatierer für Rust-Code</li> <li><strong>Doc</strong>: Automatische Dokumentation</li> </ul>
<h3 id="primitiven--typen">Primitiven & Typen</h3><p>Typen können explizit oder durch Kontextinferenz angegeben werden.</p><pre><code class="language-rust">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 </code></pre>
<h3 id="mutables-und-immutables">Mutables und Immutables</h3><p>Immutability wird bevorzugt, Variablen sind standardmäßig unveränderlich.</p><pre><code class="language-rust">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; </code></pre>
<h3 id="funktionen">Funktionen</h3><pre><code class="language-rust">fn some_fn() { () } fn main() { let _a: () = some_fn(); println!("This function returns and you can see this line."); } </code></pre>
<h3 id="tupel">Tupel</h3><p>Funktionen können Tupel als Argumente oder Rückgabewerte nutzen.</p><pre><code class="language-rust">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) } </code></pre>
<h3 id="arrays-und-slices">Arrays und Slices</h3><p>Arrays speichern Objekte desselben Typs <code>T</code> in kontinuierlichem Speicher.</p><pre><code class="language-rust">// 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]; </code></pre><p>Slices sind ähnlich, aber ihre Länge ist zur Kompilierzeit nicht bekannt.</p>
<h3 id="structs">Structs</h3><p>Strukturen können einfach aus den Primitiven erstellt werden</p><pre><code class="language-rust">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); </code></pre>
<h3 id="enums">Enums</h3><p>Aufzählungen können aus unterschiedlichen Typen erstellt werden. Jedes Element muss unterschiedlich und unabhängig sein.</p><pre><code class="language-rust">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'); </code></pre>
<h3 id="kontrollstrukturen">Kontrollstrukturen</h3><ul> <li>if/else</li> <li>loop</li> <li>while</li> <li>for and range</li> <li>match</li> <li>if let, let-else & while let</li> </ul>
<h3 id="ifelse">If/Else</h3><p>ähnelt anderen Sprachen. keine Klammern um die Bedingung.</p><pre><code class="language-rust">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); } </code></pre>
<h3 id="schleifen">Schleifen</h3><p>Operationen wiederholen, bis sie erfolgreich sind. Mit break kann ein Wert zurückgegeben werden.</p><pre><code class="language-rust">let mut counter = 0; let result = loop { counter += 1; if counter == 10 { break counter * 2; } }; </code></pre>
<h3 id="error-handling">Error Handling</h3><p>Fehler werden explizit mit <code>Result</code> und <code>Option</code> Typen behandelt.</p><pre><code class="language-rust">match read_file("config.txt") { Ok(content) => println!("Inhalt: {}", content), Err(e) => println!("Fehler beim Lesen: {:?}", e), } </code></pre>
<h3 id="crates">Crates</h3><p>Eine Crate ist eine Kompilationseinheit in Rust.</p><pre><code class="language-rust">// import extern crate rary use rary; fn main() { rary::public_function(); // Error! `private_function` is private rary::private_function(); } </code></pre>
<h3 id="cargo">Cargo</h3><p>Das offizielle Rust-Paketverwaltungswerkzeug. <br/>Es unterstützt:</p><ul> <li>Abhängigkeitsmanagement</li> <li>Einbindung von Unit Tests</li> <li>Benchmarks</li> </ul>
<h3 id="projekt-mit-cargo-starten">Projekt mit Cargo starten</h3><pre><code class="language-bash">cargo new foo # binary oder cargo new --lib bar # library </code></pre><pre><code class="language-bash">// Projektstruktur └── foo ├── Cargo.toml └── src └── main.rs </code></pre>
<h3 id="cargo-init-projekt">Cargo Init Projekt</h3><p>Die Cargo.toml ist die Konfigurationsdatei für Cargo.</p><pre><code class="language-toml">[package] name = "foo" version = "0.1.0" authors = ["unknown"] [dependencies] </code></pre><pre><code class="language-rust">fn main() { println!("Hello World!"); } </code></pre>
<h3 id="testing-12">Testing 1/2</h3><p>Unit- und Integrationstests nativ</p><p>Unit Tests zum Modul gespeichert; Integration Tests in eigenen Ordner</p><pre><code class="language-bash">foo ├── Cargo.toml ├── src │ └── main.rs │ └── main.test.rs └── tests └── my_test.rs </code></pre><p>Starte alle Tests mit <code>cargo test</code></p>
<h3 id="testing-22">Testing 2/2</h3><p>Beispiel Test</p><pre><code class="language-rust">#[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"); } } } </code></pre>
<h3 id="ressourcen-und-community">Ressourcen und Community</h3><p>Nutz das Rust Buch, Rustlings, und rustup.rs, um tiefer in Rust einzusteigen.</p><ul> <li><a href="https://www.rust-lang.org/" rel="nofollow">Rust Webseite<span> 🔗</span></a></li> <li><a href="https://doc.rust-lang.org/stable/rust-by-example/index.html" rel="nofollow">Rust by Example<span> 🔗</span></a></li> <li><a href="https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA" rel="nofollow">Rust Video Tutorials<span> 🔗</span></a></li> </ul>
<h3 id="fragen-und-diskussion">Fragen und Diskussion</h3><p>Welche Fragen haben sich gesammelt?</p><p>Lasst uns diskutieren.</p><br/>
Zeit für eure Fragen
& Diskussionen
WieErWill.dev/vcard.vcf
WieErWill.dev
