[[oktatas:programozás:rust|< Rust]]

====== Rust nyelv ======

  * **Szerző:** Sallai András
  * Copyright (c) Sallai András, 2020
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC Attribution-Share Alike 4.0 International]]
  * Web: https://szit.hu

===== Helló Világ =====

<code rust hello.rs>
fn main() {
    println!("Helló Világ!");
}
</code>

Fordítás:
  rustc hello.rs

Futtatás:
  ./hello

A ! azt jelenti, hogy a println nem függvény, hanem makró. 
A makrók újabb kódokat hoznak létre, fordításkor. 
===== Megjegyzések =====

<code rust megjegyzes.rs>
// egy soros megjegyzés

/*
több
soros 
megjegyzés
*/

</code>


===== Kivitel =====

Kiíratás sortörés nélkül:
<code rust>
print!("alma");
</code>

A rust nyelven nem íratható ki önmagában egy szám literálist. 

<del>println!(35)</del>

Csak így:
<code rust>
println!("{}", 35);
</code>

Tájékoztató szöveget is megadhatunk a kiírt értékről:
<code rust>
println!("Szám: {}", 35);
</code>


Több literális kiíratása:
<code rust>
println!("{1} és {0}", 25, 47);
</code>


Kifejezés kiértékelése:
<code rust>

fn main() {
	println!("{}", 3*4)
}
</code>

Új sor kiíratása:
<code rust>
println!();
</code>

Hibaüzenet kiírása:
<code rust>
eprintln!("Hiba! ...");
</code>

Hibaüzenet sortörés nélkül:
<code rust>
eprint!("Hiba! ...");
</code>
===== Primitív típusok =====

Egészek:
^  Hossz  ^  Előjeles  ^  Előjel \\ nélkül  |
| 8 bites   |  i8   | u8   |
| 16 bites  |  i16  | u16  |
| 32 bites  |  i32  | u32  |
| 64 bites  |  i64  | u64  |
| 128 bites  |  i128  |  u128  |


Egész literális:


| decimális  |  23_123  |
| hexadecimális  |  0xfe  |
| oktális  |  0o75  |
| bináris  |  0b1111_0000  |
| bájt (csak u8)  |  b'A'  |





Valós számok:
  * f32
  * f64


<code rust>
let szam1 = 3.0;       //f64
let szam2: f32 = 3.0   // f32
</code>



Logikai típus:
  * bool

<code rust>
let van = true;
let nincs = true;
</code>



Karakter:  
  * char

<code>
let c = 'a';
</code>

Összetett típusok:
  * Tuple
  * Array

Tuple:
<code rust>
let tup: (f32, u8, i32) = (5.48, 3, 600)
</code>

Tömb:
<code rust>
let tomb: [5, 8, 2, 4, 1];
</code>

A Rust statikusan tipizált nyelv, ami azt jelenti, hogy
fordítási időben ismernie kell a változók típusát,
azonban a fordító általában érték és a használat
alapján dönti el, milyen típust akarunk használni.

Készítsünk egy "a" nevű változót:
<code rust>
let a = 35;
</code>

Az "a" változó értéke alapértelmezetten i32.

Valós szám esetén:
<code rust>
let a = 35.5;
</code>

Alapértelmezett f64.

A típus explicit megadása:
<code rust>
let a: i64 = 834983434;
</code>

A maximálisan tárolható legnagyobb szám kiíratása:
<code rust>
println!("Max i32: {}", std::i32::MAX);
</code>


Logikai típus megadása:
<code rust>
let aktiv: bool = true;
</code>

A logika típus kifejezéssel is kaphat értéket:
<code rust>
let nagyobb: bool = a > 30; 
</code>


Karakterek:
<code rust>
let karakter1 = 'a' 
let karakter2 = '\u{7a7a}';
</code>

===== Változóhasználat =====

A változók tartalmazhatnak primitív és referencia típusokat.
A változók alapértelmezetten nem megváltoztathatók (immutable).

<code rust>
fn main() {
    let kor = 35;
    println!("{}", kor);
}
</code>

Mivel alapértelmezetten nem változtatható meg egy változó értéke,
ha beírjuk kor = 36, akkor hibát ad a fordító:
<code rust>
fn main() {
    let kor = 35;
    //A következő utasítás hibát ad:
    //kor = 36;
    println!("{}", kor);
}
</code>

Megváltoztathatóvá tehetjük a mut kulcsszóval:
<code rust>
fn main() {
    let mut kor = 35;
    println!("{}", kor);
    kor = 36;
    println!("{}", kor);
}
</code>

Viszont hibát kapunk, ha az első println!() utasítás hiányzik, mivel 
fel sem használtuk a kor változó értékét, és máris megváltoztatjuk.

Többes értékadás:
<code rust>
let (nev, kor) = ("Nagy János", 38);
println!("Név: {}", nev);
println!("Kor: {}", kor);
</code>




===== Nevesített állandók =====

Állandók a const kulcsszóval hozhatók létre, és kötelezően nagybetűsek.
<code rust>
const ID: i32 = 001;
println!("azonosító: {}", ID);
</code>



===== Formázott kivitel =====

Szöveg kiírása:
<code rust>
fn main() {
	println!("{} származik {}", "Szolnokról", "Laci")
}
</code>


Pozicionális argumentum:
<code rust>
fn main() {
	println!("{0} {1}ról származik és {0} szereti {2}t", 
        "Laci", "Szolnok", "Mari")
}
</code>

Elnevezett argumentumok:
<code rust>
fn main() {
	println!(
            "{nev} szeret {jatek}t játszani", 
            nev = "Laci", 
            jatek = "Póker"
        );
}
</code>


Írassuk ki a 10 számot bináris, hexadecimális és oktális alakban:
<code rust>
println!("bináris: {:b} Hex: {:x} Oktális: {:o}", 10, 10, 10);
</code>

Bármit kiírathatunk, például hibakövetés céljából:
<code rust>
println!("{:?}", ("alma", 35, true));
</code>

A kiíratás eredménye:
  ("alma", 35, true)

Másik példa:
<code rust>
fn main() {    
    let a = true;
    let b = 35;
    let c = 35.6;
    println!("{:?}", (a, b, c))
}
</code>

Kimenet:
  (true, 35, 35.6)


===== Matematikai modul =====

===== Véletlen szám =====

===== Operátorok =====

===== Konvertálás =====

===== Bevitel =====


===== Szelekció =====

<code rust>
fn main() {
    let kor = 35;
    if kor > 21 {
        println!("Felnőtt");
    }
}
</code>


<code rust>
fn main() {
    let kor = 35;
    if kor > 21 {
        println!("Felnőtt");
    } else {
        println!("Gyerek")
    }
}
</code>

Logikai típus használata:
<code rust>
fn main() {
    let felnott: bool = true;
    if felnott {
        println!("Felnőtt");
    } else {
        println!("Gyerek")
    }
}
</code>

Két állítás:
<code rust>
fn main() {
    let van_diplomaja: bool = true;
    let van_jogositvanya: bool = true;
    if van_diplomaja && van_jogositvanya {
        println!("Felvéve");
    } else {
        println!("Sajnos, nem nyert")
    }
}
</code>

Két állítás vagy kapcsolattal:

<code rust>
fn main() {
    let van_haza = true;
    let van_kocsija = false;
    if van_haza || van_kocsija {
        println!("Nyerő");
    } else {
        println!("Nem nyerő");
    }
}
</code>



Több elágazás:
<code rust>
fn main() {
    let kor = 25;
    if kor < 1 {
        println!("Csecsemő");
    } else if kor > 1 && kor <= 6 {
        println!("Kisgyermek");
    } else if kor > 6 && kor <= 12 {
        println!("Gyermek");
    } else if kor > 12 && kor <= 16 {
        println!("Serdülő");
    } else if kor > 16 && kor <= 20 {
        println!("Ifjú");
    } else if kor > 20 && kor <= 30 {
        println!("Fiatal");
    } else {
        println!("Öregedés...");
    }
}
</code>

==== Rövidített if ====

<code rust>
fn main() {
    let fizetes = 2800000;
    let megfelel = if fizetes > 1000000 { true } else { false };
    println!("{}", megfelel);
}
</code>

===== Iteráció =====
==== Loop ====

<code rust>
fn main() {
    let mut szamlalo = 0;
    
    loop {
        println!("{}", szamlalo);
        szamlalo += 1;
        if szamlalo == 10 {
            break;
        }
    }
}
</code>

==== While ====

<code rust>
fn main() {
    let mut szamlalo = 0;
    
    while szamlalo < 10 {
        println!("{}", szamlalo);
        szamlalo += 1;
    }
}
</code>

==== for range ====

<code rust>
fn main() {
   
    for i in 0..9 {
        println!("{}", i)
    }
}
</code>

===== Tömb =====

A tömb azonos típusú értékeket tartalmazó adatszerkezet.

<code rust>
fn main() {
    let szamok: [i32; 6] = [ 3, 4, 2, 8, 1, 5];
    println!("{:?}", szamok);
    println!("Első érték: {}", szamok[0]);
}
</code>

Egy elem új értékadásához szükség van a "mut" módosítóra.

<code rust>
fn main() {
    let mut szamok: [i32; 6] = [ 3, 4, 2, 8, 1, 5];
    szamok[0] = 25;
    println!("{:?}", szamok);    
}
</code>

Hossz:
<code rust>
println!("{:?}", szamok.len());
</code>

A veremben elfoglalt hely:
<code rust>
println!("{:?}", std::mem::size_of_val(&szamok));
</code>

==== Darab ====

<code rust>
fn main() {
    let szamok: [i32; 6] = [ 3, 4, 2, 8, 1, 5];
    let darab: &[i32] = &szamok[0..3];
    println!("{:?}", darab);    
}
</code>

==== Tömb másik tömbből ====

<code rust>
fn main() {
    let tomb1 = [8, 2, 5];
    let tomb2 = tomb1;
    println!("{:?}", (tomb1, tomb2));
}
</code>

===== Tuple =====

<code rust>

fn main() {
    let dolgozo: (&str, &str, i32) = ("Nagy János", "Miskolc", 3280000);

    println!("Név: {}\nTelepülés: {}\nFizetés: {}", 
        dolgozo.0, dolgozo.1, dolgozo.2);
}
</code>

===== Vektor =====

<code rust vektor.rs>
fn main() {
    let mut szamok: Vec<i32> = vec![ 3, 4, 2, 8, 1, 5];
    
    //Összes elem kiírása
    println!("{:?}", szamok);
    
    //Egy elemre hivatkozás
    println!("{}", szamok[0]);
    
    //Hozzáadunk egy elemet:
    szamok.push(37);
    szamok.push(25);
    
    println!("{:?}", szamok);
    
    szamok.pop();
    println!("{:?}", szamok);
}
</code>

Vektor bejárása:
<code rust>
fn main() {
    let szamok: Vec<i32> = vec![ 3, 4, 2, 8, 1, 5];
    
    for elem in szamok.iter() {
        println!("{}", elem);
    } 
}
</code>

Bejárás és értékek változtatása:
<code rust>
fn main() {
    let mut szamok: Vec<i32> = vec![ 3, 4, 2, 8, 1, 5];
    
    for elem in szamok.iter_mut() {        
        *elem += 4;
    }
    println!("{:?}", szamok)
}
</code>

Hivatkozás átadása:
<code rust>
fn main() {
    let vektor1 = vec![8, 3, 7];
    let vektor2 = &vektor1;
    println!("{:?}", (&vektor1, vektor2));
}
</code>

===== Struktúra =====

<code rust struktura.rs>

struct Dolgozo<'a> {
    //Az 'a egy lifetime 
    nev: &'a str,
    kor: u8,
    fizetes: f64,
}

fn main() {
    let janos = Dolgozo {
        nev: "Nagy János",
        kor: 35,
        fizetes: 3850000.0,
    };

    println!("Név: {}\nKor: {}\nFizetés: {}",  
        janos.nev, janos.kor, janos.fizetes);
}
</code>

Mutable:
<code rust valto.rs>
struct Dolgozo<'a> {
    //Az 'a egy lifetime 
    nev: &'a str,
    kor: u8,
    fizetes: f64,
}

fn main() {
    let mut janos = Dolgozo {
        nev: "Nagy János",
        kor: 35,
        fizetes: 3850000.0,
    };
    
    janos.kor = 36;

    println!("Név: {}\nKor: {}\nFizetés: {}",  
        janos.nev, janos.kor, janos.fizetes);
}
</code>

==== Tuple struktúra ====

<code rust tuplestrukt.rs>
struct Dolgozo<'a>(&'a str, u8, f64);
fn main() {
    let mut janos = Dolgozo("Nagy János", 36, 3850000.0);
    janos.1 = 37;
    println!("Név: {}\nKor: {}\nFizetés: {}", janos.0, janos.1, janos.2);
}
</code>

==== A sturktúra ====

<code rust a.rs>
struct Dolgozo {
    nev: String,
    telepules: String
}

impl Dolgozo {
    fn new(atvett_nev: &str, atvett_telepules: &str) -> Dolgozo {
        Dolgozo {
            nev: atvett_nev.to_string(),
            telepules: atvett_telepules.to_string()
        }
    }
}

fn main() {
    let janos = Dolgozo::new("Nagy János", "Szolnok");
    println!("Név: {}\nTelepülés: {}", janos.nev, janos.telepules);
}

</code>

Beállítható név:
<code rust a.rs>
struct Dolgozo {
    nev: String,
    telepules: String
}

impl Dolgozo {
    fn new(atvett_nev: &str, atvett_telepules: &str) -> Dolgozo {
        Dolgozo {
            nev: atvett_nev.to_string(),
            telepules: atvett_telepules.to_string()
        }
    }
    
    fn set_nev(&mut self, atvett_nev: &str) {
        self.nev = atvett_nev.to_string();
    }
}

fn main() {
    let mut janos = Dolgozo::new("Nagy János", "Szolnok");
    janos.set_nev("Kiss Béla");
    println!("Név: {}\nTelepülés: {}", janos.nev, janos.telepules);
}
</code>

Átalakítás tuple formára:
<code rust totuple.rs>
struct Dolgozo {
    nev: String,
    telepules: String
}

impl Dolgozo {
    fn new(atvett_nev: &str, atvett_telepules: &str) -> Dolgozo {
        Dolgozo {
            nev: atvett_nev.to_string(),
            telepules: atvett_telepules.to_string()
        }
    }
    
    fn set_nev(&mut self, atvett_nev: &str) {
        self.nev = atvett_nev.to_string();
    }
    
    fn to_tuple(self) -> (String, String) {
        (self.nev, self.telepules)
    }
}

fn main() {
    let mut janos = Dolgozo::new("Nagy János", "Szolnok");
    janos.set_nev("Kiss Béla");
    println!("Név: {}\nTelepülés: {}", janos.nev, janos.telepules);
    println!("{:?}", janos.to_tuple());
    
}
</code>

===== Enum =====

<code rust enum.rs>

enum Mozgas {
    Fel,
    Le,
    Balra,
    Jobbra
}

fn avatar_mozgatas(m: Mozgas) {
    match m {
        Mozgas::Fel => println!("Mozgás fel"),
        Mozgas::Le => println!("Mozgás le"),
        Mozgas::Balra => println!("Mozgás balra"),
        Mozgas::Jobbra => println!("Mozgás jobbra"),
    }
}

fn main() {
    let avatar1 = Mozgas::Balra;
    let avatar2 = Mozgas::Jobbra;
    let avatar3 = Mozgas::Fel;
    let avatar4 = Mozgas::Le;
    
    avatar_mozgatas(avatar1);
    avatar_mozgatas(avatar2);
    avatar_mozgatas(avatar3);
    avatar_mozgatas(avatar4);    
}

</code>

===== String kezelés =====

Primitív str egy fix hosszúságú string valahol a memóriában, 
ami nem változtatható (immutable).

<code rust>
fn main() {
    let nev = "Nagy János";
    println!("{}", nev);
}
</code>

A String növelhető, halomterületen (heap-ben) tárolt adatstruktúra. 

<code rust>
fn main() {
    let nev = String::from("Nagy János");
    println!("{}", nev);
}
</code>

==== Hossz ====

<code rust>
fn main() {
    let nev = String::from("Nagy János");
    let hossz = nev.len();
    println!("{}", hossz);
}
</code>

==== Hozzáfűzés ====
A szoveg változó elé tesszük a mut módosítót, majd hozzáfűzünk egy karaktersorozatot,
és egy betűt.

<code rust>
fn main() {
    let mut szoveg = String::from("Nagy János");
    szoveg.push_str(" neve");
    szoveg.push('t');
    println!("{}", szoveg);
}
</code>

==== Kapacitás bájtban ====

<code rust>
fn main() {
    let szoveg = String::from("Nagy János");
    println!("{}", szoveg.capacity());
}
</code>

==== Üres ====

<code rust>
println!("{}", szoveg.is_empty());
</code>

==== Tartalmazás ====

<code rust>
fn main() {
    let szoveg = String::from("Nagy János");
    println!("{}", szoveg.contains("János"));  
}
</code>

Az eredmény egy logikai típus.

==== Csere ====

<code rust>
fn main() {
    let szoveg = String::from("Nagy János");
    println!("{}", szoveg.replace("Nagy", "Kiss"));  
}
</code>

==== Darabolás ====

Darabolás whitespace karakterek mentén:

<code rust>
fn main() {
    let szoveg = String::from("Nagy János");
    for szo in szoveg.split_whitespace() {
        println!("{}", szo);  
    }
}
</code>

==== Létrehozás kapacitással ====

<code rust>
fn main() {
    let mut szoveg = String::with_capacity(10);
    szoveg.push('a');
    szoveg.push('b');
    println!("{}", szoveg)
}
</code>

==== Assert teszt ====

<code rust>
fn main() {
    let mut szoveg = String::with_capacity(10);
    szoveg.push('a');
    szoveg.push('b');
    println!("{}", szoveg);
    assert_eq!(2, szoveg.len());
    assert_eq!(10, szoveg.capacity());
}
</code>

===== Függvény =====

Egyszerű függvény:

<code rust nevjegy.rs>

fn main() {
    nevjegy();
}

fn nevjegy() {
    println!("-----------------------");    
    println!("      Nagy János");    
    println!("       Szolnok");    
    println!("-----------------------");
}
</code>


Egy paraméter:
<code rust dupla.rs>
fn main() {
    println!("{}", dupla(35));
}

fn dupla(szam: i32) -> i32 {
    return szam * 2;
}
</code>

Két paraméter:
<code rust osszead.rs>

fn main() {
    println!("{}", osszead(35, 40));
}

fn osszead(szam1: i32, szam2: i32) -> i32 {
    return szam1 + szam2;
}
</code>



Szöveges paraméterek:

<code rust>
fn main() {
    nevjegy("Nagy János", "Szolnok");
}

fn nevjegy(nev: &str, telepules: &str) {
    println!("----------------------");
    println!("   {}", nev);    
    println!("   {}", telepules);    
    println!("----------------------");
}
</code>

Closure:
<code rust osszead.rs>
fn main() {
    let osszead = |szam1: i32, szam2: i32| szam1 + szam2;
    println!("{}", osszead(25, 30));
}
</code>

===== A cargo =====

A rust csomaghoz ajánlott a cargo, ami automatikusan feltelepszik.

Használata:
  cargo init


Létrejön egy Cargo fájl:
<code ini>
[package]
name = "hello"
version = "0.1.0"
authors = ["Nagy János <janos@zold.land>"]
edition "2018"

[dependencies]

</code>


<code gitignore .gitignore>
/target
**/*.rs.bk
</code>


<code  rust src/main.rs>
fn main() {
    println!("Hello, world");
}
</code>


Futtatás:
  cargo run

Fordítás:
  cargo build

Release:
  cargo build --release

===== Modul =====

<code rust egyeb.rs>
pub fn nevjegy() {
	println!("Valaki")
}
</code>

<code rust main.rs>
mod egyeb;

fn main() {
	egyeb::nevjegy();
}

</code>

===== CLI =====

Parancssori argumentumok feldolgozása:

<code rust args.rs>
use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    println!("{:?}", args);
}

</code>

Ha cargo-val futtatjuk:
  cargu run valami


Egyik paraméter:
<code rust parameter.rs>
use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    let parameter = args[1].clone();
    println!("Paraméter: {}", parameter);
}
</code>

Paraméter ellenőrzése:
<code rust ellenorzes.rs>
use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();
    let parameter = args[1].clone();
    
    if parameter == "valami" {
        println!("Igen, valami");
    } else if parameter == "mas" {
        println!("Más");
    } else {
        println!("Ismeretlen paraméter!")
    }
}
</code>


===== Forrás =====

  * https://doc.rust-lang.org/book/ (2020)
  * https://www.youtube.com/watch?v=zF34dRivLOw (2020)