Uvodni vodnik za začetnike v Rust: Od igre do programiranja, hitro spoznavanje ekosistema Rust\n\nRust se hitro razvija in ni le programski jezik, temveč tudi dinamičen ekosistem. Od iger preživetja do visoko zmogljivega sistemskega programiranja, Rust je prisoten povsod. Ta članek bo izhajal iz razprav na X/Twitterju in ponudil hiter uvodni vodnik za začetnike v Rust, ki bo zajemal primere uporabe Rust, učne vire in nekaj uporabnih orodij.\n\n## I. Kaj je Rust? Zakaj se ga splača učiti?\n\nRust je sistemski programski jezik, ki se osredotoča na varnost, hitrost in sočasnost. Zasnovan je za reševanje pogostih težav z varnostjo pomnilnika v C in C++, hkrati pa zagotavlja primerljivo ali celo višjo zmogljivost kot ti jeziki.\n\nPrednosti Rust:\n\n* Varnost pomnilnika: Rustov sistem lastništva in preverjevalnik posojanja preprečujeta težave, kot so ničelni kazalci in dirke podatkov, že v času prevajanja.\n* Visoka zmogljivost: Rust se prevede v učinkovito strojno kodo in ima močne zmožnosti abstrakcije z ničelnimi stroški.\n* Varnost sočasnosti: Rustov tipski sistem zagotavlja varnost sočasne kode in preprečuje dirke podatkov.\n* Prečna platforma: Rust podpira različne operacijske sisteme in arhitekture, vključno z Windows, Linux, macOS, WebAssembly itd.\n* Aktivna skupnost: Rust ima živahno skupnost, ki ponuja bogato zbirko knjižnic, orodij in podpore.\n\nPrimeri uporabe Rust:\n\n* Operacijski sistemi in vgrajeni sistemi: Zaradi visoke zmogljivosti in varnosti je Rust zelo primeren za razvoj jeder operacijskih sistemov, gonilnikov in programske opreme za vgrajene naprave.\n* WebAssembly (Wasm): Rust se lahko prevede v Wasm, kar omogoča izvajanje visoko zmogljive kode v brskalniku.\n* Orodja ukazne vrstice: Rust ponuja zmogljiva ogrodja za razvoj orodij ukazne vrstice, kot sta clap in structopt.\n* Mrežno programiranje: Rustova knjižnica tokio ponuja asinhrono izvajalno okolje, ki olajša pisanje visoko zmogljivih omrežnih aplikacij.\n* Razvoj iger: Čeprav ni tako razširjen kot C++, Rust pridobiva na veljavi na področju razvoja iger. Na primer, odprtokodna igra preživetja Rust je sama razvita z uporabo Unity motorja in C#, vendar se lahko del logike na strani strežnika optimizira z Rust za izboljšanje zmogljivosti.\n\n## II. Od igre Rust do programskega jezika Rust\n\nRazprava na X/Twitterju je omenila igro preživetja Rust, ki je tesno povezana s programskim jezikom Rust. Čeprav imata enako ime, sta različni stvari. Igra Rust je spletna igra preživetja za več igralcev, medtem ko je Rust programski jezik, ki se uporablja za gradnjo različne programske opreme.\n\nIgra Rust:\n\n* Je spletna igra preživetja za več igralcev, kjer morajo igralci preživeti v divjini, graditi baze in komunicirati z drugimi igralci.\n* Je razvita z uporabo Unity motorja in C#.\n* Jo je mogoče kupiti na Steamu in pogosto ima promocijske akcije.\n\nProgramski jezik Rust:\n\n* Se uporablja za razvoj različne programske opreme, vključno z operacijskimi sistemi, brskalniškimi motorji, spletnimi strežniki, igrami itd.\n* Je odprtokoden in prečno platformski.\n* Ima močan tipski sistem in varnostne funkcije pomnilnika.\n\nČe ste igralec igre Rust in se želite naučiti programskega jezika Rust, lahko razmislite o naslednjih korakih:\n\n1. Namestite orodja Rust: Prenesite in namestite rustup, ki je orodje za upravljanje različic Rust.

2. Naučite se osnov Rust: Preberite uradni vadnik \Vzpostavitev razvojnega okolja Rust je zelo preprosta, saj morate namestiti samo rustup. rustup bo samodejno namestil prevajalnik Rust, standardno knjižnico in druga potrebna orodja.

Koraki:

1. Prenesite rustup: Obiščite , in prenesite ustrezen namestitveni program rustup za vaš operacijski sistem.
2. Zaženite namestitveni program: Sledite navodilom namestitvenega programa.
3. Konfigurirajte spremenljivke okolja: rustup bo samodejno konfiguriral spremenljivke okolja, lahko pa jih konfigurirate tudi ročno.
4. Preverite namestitev: Odprite terminal in zaženite rustc --version in cargo --version. Če se pravilno prikaže številka različice, to pomeni, da je namestitev uspešna.

Primer kode:

rustc --version  # Prikaz različice prevajalnika Rust
cargo --version  # Prikaz različice upravitelja paketov Cargo

4. Hiter uvod v osnovno sintakso Rust

Sledi nekaj osnovne sintakse Rust, ki vam lahko pomaga pri hitrem začetku:

• Deklaracija spremenljivk:

  let x = 5;          // Nespremenljiva spremenljivka
  let mut y = 10;     // Spremenljiva spremenljivka
  const PI: f64 = 3.1415926; // Konstanta
  

• Podatkovni tipi:

  • Celo število: i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, isize, usize

  • Število s plavajočo vejico: f32, f64

  • Bool: bool (true, false)

  • Znak: char (Unicode znak)

  • Niz: String, &str

  • Tuple: (i32, f64, char)

  • Polje: [i32; 5]

  • Rezina: &[i32]

  • Struktura:

    struct Point {
        x: i32,
        y: i32,
    }
    

  • Enum:

    enum Color {
        Red,
        Green,
        Blue,
    }
    

• Funkcije:

  fn add(x: i32, y: i32) -> i32 {
      x + y
  }
  

• Kontrolni tok:

  • Stavek if:

    if x > 5 {
        println!("x is greater than 5");
    } else if x == 5 {
        println!("x is equal to 5");
    } else {
        println!("x is less than 5");
    }
    

  • Zanka loop:

    loop {
        println!("This will loop forever");
        break; // Izhod iz zanke
    }
    ```## Tri: Osnovni koncepti
    
    

• Spremenljivke in nespremenljivost:

  let x = 5; // Nespremenljiva spremenljivka
  let mut y = 10; // Spremenljiva spremenljivka
  y = 20; // Spremenimo vrednost y
  println!("Vrednost y je: {}", y);
  

  // let se uporablja za deklaracijo spremenljivk. mut ključna beseda omogoča, da je spremenljivka spremenljiva.

• Podatkovni tipi:

  • Celostna števila: i32, u32, i64, u64 itd. (i pomeni predznačeno, u pomeni nepredznačeno, številka pa število bitov)
  • Števila s plavajočo vejico: f32, f64
  • Boolean: bool (true ali false)
  • Znak: char (Unicode znak)
  • Tuple: (i32, f64, char) (zbirka vrednosti različnih tipov)
  • Array: [i32; 5] (zbirka vrednosti istega tipa, fiksne dolžine)
  • Slice: &[i32] (referenca na zaporedni del array-a)

  let a: i32 = 10;
  let b: f64 = 3.14;
  let c: bool = true;
  let d: char = 'a';
  let e: (i32, f64, char) = (1, 2.0, 'a');
  let f: [i32; 5] = [1, 2, 3, 4, 5];
  let g: &[i32] = &f[1..3]; // Slice, ki se nanaša na elemente 2 in 3 array-a f
  

  // Rust je statično tipiziran jezik, vendar lahko pogosto izpelje tip spremenljivke.

• Funkcije:

  fn add(x: i32, y: i32) -> i32 {
      x + y
  }
  
  let result = add(5, 3);
  println!("Rezultat je: {}", result);
  

  // fn se uporablja za definiranje funkcij. -> označuje tip povratne vrednosti.

• Lastništvo (Ownership), Izposoja (Borrowing) in Življenjska doba (Lifetimes):

  • Lastništvo: Vsaka vrednost v Rustu ima spremenljivko, ki je njen lastnik. Ko lastnik gre izven obsega, se vrednost spusti (sprosti).
  • Izposoja: Omogoča več referenc na isto podatkovno vrednost brez prenosa lastništva. Reference so lahko spremenljive (&mut) ali nespremenljive (&).
  • Življenjska doba: Zagotavlja, da reference ne preživijo podatkov, na katere se nanašajo.

  fn main() {
      let s1 = String::from("hello");
      let s2 = &s1; // Nespremenljiva izposoja
      println!("s1 je: {}, s2 je: {}", s1, s2);
  
      let mut s3 = String::from("hello");
      let s4 = &mut s3; // Spremenljiva izposoja
      s4.push_str(", world!");
      println!("s3 je: {}, s4 je: {}", s3, s4);
  }
  

  // Lastništvo in izposoja sta ključna koncepta v Rustu, ki zagotavljata varnost pomnilnika brez smetnjaka (garbage collector).

Štiri: Kontrolni tok

• if/else pogojne izjave:

  let number = 7;
  
  if number < 5 {
      println!("pogoj je bil resničen");
  } else {
      println!("pogoj je bil neresničen");
  }
  

• loop zanke:

  loop {
      println!("spet!");
      break; // Izhod iz zanke
  }
  

• while zanke:

  let mut i = 0;
  while i < 5 {
      println!("Vrednost i je: {}", i);
      i += 1;
  }
  

• for zanke:

  let a = [10, 20, 30, 40, 50];
  
  for element in a.iter() {
      println!("vrednost je: {}", element);
  }
  

  // iter() ustvari iterator, ki omogoča iteriranje po elementih array-a.

Pet: Strukture in Enumeracije

• Strukture (Structs):

  struct User {
      username: String,
      email: String,
      sign_in_count: u64,
      active: bool,
  }
  
  let user1 = User {
      email: String::from("someone@example.com"),
      username: String::from("someusername123"),
      active: true,
      sign_in_count: 1,
  };
  

  // Strukture se uporabljajo za definiranje lastnih podatkovnih tipov.

• Enumeracije (Enums):

  enum IpAddrKind {
      V4(String),
      V6(String),
  }
  
  let home = IpAddrKind::V4(String::from("127.0.0.1"));
  let loopback = IpAddrKind::V6(String::from("::1"));
  

  // Enumeracije omogočajo definiranje tipa, ki je lahko ena od več variant.

Šest: Ravnanje z napakami

• Result tip:

  use std::fs::File;
  use std::io::ErrorKind;
  
  fn main() {
      let f = File::open("hello.txt");
  
      let f = match f {
          Ok(file) => file,
          Err(error) => match error.kind() {
              ErrorKind::NotFound => match File::create("hello.txt") {
                  Ok(fc) => fc,
                  Err(e) => panic!("Problem pri ustvarjanju datoteke: {:?}", e),
              },
              other_error => {
                  panic!("Problem pri odpiranju datoteke: {:?}", other_error)
              }
          },
      };
  }
  

Pet: Uporabna orodja in učni viri

• Cargo: Rustov upravitelj paketov in orodje za gradnjo, ki se uporablja za upravljanje odvisnosti, gradnjo projektov in izvajanje testov.
• Rust Analyzer: Zmogljiv Rust jezikovni strežnik, ki ponuja dopolnjevanje kode, preverjanje sintakse, refaktoriranje itd. Priporočljivo je, da v VS Code namestite ustrezen vtičnik.
• Clippy: Orodje za statično analizo Rust kode, ki lahko preveri potencialne težave v kodi in ponudi predloge za izboljšave.
• crates.io: Rustovo skladišče paketov, podobno npm (JavaScript) ali PyPI (Python).
• Uradna dokumentacija: Vsebuje popolno dokumentacijo jezika Rust.
• Rust by Example: Ponuja veliko primerov kode Rust.
• The Rust Programming Language (The Book): Uradna vadnica za Rust, močno priporočljiva za branje.
• Rustlings: Interaktivno orodje za učenje Rust, ki se uči Rust z reševanjem serije vaj.
• Spletni tečaji: Na platformah, kot sta Udemy in Coursera, je veliko spletnih tečajev o Rustu.

Šest: Smeri za poglobljeno učenje

• Asinhrono programiranje (async/await): Uporaba tokio ali async-std za pisanje visoko zmogljivih sočasnih programov.
• WebAssembly (Wasm): Prevajanje kode Rust v Wasm za izvajanje v brskalniku.
• Razvoj vgrajenih sistemov: Uporaba Rust za razvoj programske opreme za vgrajene sisteme.
• Razvoj veriženja blokov (Blockchain): Uporaba Rust za razvoj aplikacij veriženja blokov, na primer razvoj pametnih pogodb za Solano.

Sedem: PovzetekRust je programski jezik, ki je poln izzivov, a tudi izjemno dragocen. Ponuja močno varnost in zmogljivost ter ima aktivno skupnost. Upam, da vam bo ta uvod pomagal hitro začeti z Rustom in začeti vaše potovanje programiranja v Rustu. Začnite z igro Rust in raziščite skrivnosti programskega jezika Rust, odkrili boste popolnoma nov svet.