====== Beispiel-Programme in Rust ======

  * [[https://doc.rust-lang.org/stable/rust-by-example|Rust-Beispiele]]
  * [[https://docs.rs/postgres/|PostgreSQL-Abfrage]]
  * [[https://docs.rs/mysql/|MySQL-Abfrage]]


===== meine Kode-Beispiele =====


==== Hallo Welt ====

<file rust Hallo_Welt.rs>
// Hallo Welt
fn main()
{
    println!("Hallo, Welt!")
}
</file>

  > 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 zählen ====

<file rust hoch_zaehlen.rs>
// hoch zählen
//
// https://doc.rust-lang.org/book/iterators.html
//

fn main() {
        for x in 0..10 {
                println!("{}", x);
        }
}
</file>

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


==== Variable ====

<file rust 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);
}
</file>

  > rustc Variable.rs
  > ./Variable
  1
  2


==== if ====

<file rust 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 :(");
        }
}
</file>

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


==== for ====

<file rust 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]);
    }
}
</file>


==== while ====

<file rust 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;
                }
        }
}
</file>

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


==== Datei lesen ====

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

<file rust 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!("################################################################################");
}
</file>


==== Argumente ====

  * [[http://stackoverflow.com/questions/15619320/how-to-access-command-line-parameters-in-rust]]
  * [[https://doc.rust-lang.org/std/index.html|Crate std - The Rust Standard Library - use std::]]


=== Argumente: Beispiel 1 ===

<file rust 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]);
    }
}
</file>

  > 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


=== Argumente: Beispiel 2 ===

<file rust 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);
    }
}
</file>

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


=== Argumente: Beispiel 3 ===

<file rust 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]);
                }
        }
}
</file>

  > 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


==== Read from stdin ====

[[https://www.programming-idioms.org/idiom/120/read-integer-from-stdin/1906/rust|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();


==== Stdio ====

[[https://doc.rust-lang.org/std/process/struct.Stdio.html|Struct std::process::Stdio]]


===== was ich noch mit Rust lernen möchte/muß =====

FIXME

  * 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