• Rust-Beispiele
• PostgreSQL-Abfrage
• MySQL-Abfrage

Hallo_Welt.rs

// Hallo Welt
fn main()
{
    println!("Hallo, Welt!")
}

> rustc Hallo_Welt.rs
> ls -lha
total 606
drwxr-xr-x    2 fritz  fritz     4B Apr 17 13:03 .
drwx------  137 fritz  fritz   459B Apr 17 13:05 ..
-rwxr-xr-x    1 fritz  fritz   392K Apr 17 13:03 hallo_welt
-rw-r--r--    1 fritz  fritz    43B Apr 17 13:03 hallo_welt.rs

> ./Hallo_Welt
Hallo, Welt!

hoch_zaehlen.rs

// hoch zählen
//
// https://doc.rust-lang.org/book/iterators.html
//
 
fn main() {
        for x in 0..10 {
                println!("{}", x);
        }
}

> rustc hoch_zaehlen.rs
> ./hoch_zaehlen
0
1
2
3
4
5
6
7
8
9

Variable.rs

// Variable
//
// https://doc.rust-lang.org/std/fmt/
//
 
fn main() {
        // damit "a" verändert werden kann, muss "mut" davor gestellt werden
        let mut a = 1;
        println!("{}", a);
        a = 2;
        println!("{}", a);
}

> rustc Variable.rs
> ./Variable
1
2

if.rs

// if
//
// https://doc.rust-lang.org/book/if.html
//
 
fn main() {
        let x = 5;
 
        if x == 5 {
                println!("x is five!");
        } else if x == 6 {
                println!("x is six!");
        } else {
                println!("x is not five or six :(");
        }
}

> rustc if.rs
> ./if
x is five!

for-Schleife.rs

use std::env;
 
fn main() {
    let vector: Vec<String> = env::args().collect();
 
    let l = vector.len();
    println!("Es sind {} Elemente im Vektor.", l);
 
    for i in 0..l {
        println!("Das {}. Vektorelement: {}", i, &vector[i]);
    }
}

while.rs

// while
//
// https://doc.rust-lang.org/book/while-loops.html
//
 
fn main()
{
 
        let mut x = 5; // mut x: u32
        let mut done = false; // mut done: bool
 
        while !done {
                x += x - 3;
 
                println!("{}", x);
 
                if x % 5 == 0 {
                        done = true;
                }
        }
}

> rustc while.rs
> ./while
7
11
19
35

https://stackoverflow.com/questions/25106554/why-doesnt-println-work-in-rust-unit-tests

datei_lesen.rs

use std::fs::File;
use std::io::prelude::*;
use std::path::Path;
 
fn read_file(path: &Path) {
    let mut file = File::open(path).unwrap();
    let mut contents = String::new();
    file.read_to_string(&mut contents).unwrap();
    println!("{}", contents);
}
 
fn main() {
    let path = &Path::new("/tmp/test.txt");
    println!("--------------------------------------------------------------------------------");
    println!("path: {:?}", path);
    println!("================================================================================");
    read_file(path);
    println!("################################################################################");
}

• http://stackoverflow.com/questions/15619320/how-to-access-command-line-parameters-in-rust
• Crate std - The Rust Standard Library - use std::

argv_0.rs

//
// Argumente: Beispiel 1
//
// An easy way to deal with the result of args is to convert it to a Vec:
 
use std::env;
 
fn main() {
    let args: Vec<_> = env::args().collect();
    if args.len() > 1 {
        println!("mein Aufruf lautet {}", args[0]);
        println!("das erste Argumente lautet {}", args[1]);
        println!("das zweite Argumente lautet {}", args[2]);
    }
}

> rustc argv_0.rs
> ./argv_0 1 2 3 4 A B C d
mein Aufruf lautet ./argv_0
das erste Argumente lautet 1
das zweite Argumente lautet 2

argv_1.rs

//
// Argumente: Beispiel 2
//
// You can use the whole standard iterator toolbox to work with these arguments.
// For example, to retrieve only the first argument:
 
use std::env;
 
fn main() {
    if let Some(arg0) = env::args().nth(0) {
        println!("Argument 0 {}", arg0);
    }
    println!("--------------------------------------------------------------------------------");
    if let Some(arg1) = env::args().nth(1) {
        println!("Argument 1 {}", arg1);
    }
}

> rustc argv_1.rs
> ./argv_1 1 2 3 4 A B C d
Argument 0 ./argv_1
--------------------------------------------------------------------------------
Argument 1 1

argv_alle_0.rs

//
// Argumente: Beispiel 3
//
 
use std::env;
 
fn main() {
        let args: Vec<_> = env::args().collect();
 
        if args.len() > 1 {
                let p = args.len(); // mut x: u32
                let i = 1;
 
                //println!("das erste Argumente lautet {}", args[1]);
 
                for x in i..p {
                        println!("das {}-te Argumente lautet {}", x, args[x]);
                }
        }
}

> rustc argv_alle_0.rs
> ./argv_alle_0 1 2 3 4 A B C d
das 1-te Argumente lautet 1
das 2-te Argumente lautet 2
das 3-te Argumente lautet 3
das 4-te Argumente lautet 4
das 5-te Argumente lautet A
das 6-te Argumente lautet B
das 7-te Argumente lautet C
das 8-te Argumente lautet d

Idiom #120 Read integer from stdin

fn get_input() -> String {
    let mut buffer = String::new();
    std::io::stdin().read_line(&mut buffer).expect("Failed");
    buffer
}

let n = get_input().trim().parse::<i64>().unwrap();

Struct std::process::Stdio

• Dateien-/Verzeichnissoperationen
  • öffnen
  • anlegen
  • überschreiben
  • löschen
• Verzweigungen
  • if-then-else
• Schleifen
  • while
  • for (Zählschleife)
• Argumente/Parameter an der CLI übergeben
• arbeiten mit Arrays
• eigene Funktionen erstellen