Ugrás a tartalomhoz

Rust (programozási nyelv)

Ellenőrzött
A Wikipédiából, a szabad enciklopédiából
Rust

Paradigma
Jellemző kiterjesztésrs
Megjelent2006
TervezőGraydon Hoare
Fejlesztő
  • Mozilla
  • Graydon Hoare
  • Rust Foundation
Utolsó kiadás1.82.0 (stabil verzió, 2024. október 17.)[1]
Hatással volt rá
Licenc
  • Apache Licenc 2.0
  • MIT-licenc
Weboldal

A Rust egy programozási nyelv. Különlegességét az adja, hogy

  1. teljeskörűen a biztonságos programozásra törekszik,
  2. ugyanakkor lehetőséget ad „unsafe { ... }” blokkok forráskódban való elhelyezésére, amely kulcsszó ebben a blokkban kikapcsolja Rust „védőhálóját”,
  3. egyúttal könnyen integrálható a meglévő C-ben vagy más nyelven írt szoftverkomponensekkel.

Ezáltal a Rust biztonságos programozást tesz lehetővé, ugyanakkor a hardverközeli programozáshoz elengedhetetlen nem biztonságos megoldásokat szintén támogatja.

Története

[szerkesztés]

Graydon Hoare kezdte el a nyelv fejlesztését 2006-ban, majd 2009-től a Mozilla is érdekelté vált a nyelv fejlesztésében, amit 2010-ben mutatott be. Mérföldkövek:

  • 2012: első alpha kiadás
  • 2015: Rust-1.0, ami a „Rust 2015 Edition”
  • 2018: Rust-1.31, ami a „Rust 2018 Edition”
  • 2021: Rust-1.56, ami a „Rust 2021 Edition”
  • 2024: Rust-1.82, ami a „Rust 2024 Edition” – várható kiadás, aktív tervezés alatt[2][3]

A Rust nyelv dinamikusan fejlődik. A fejlesztés során a fordító új stabil verziója 6 hetente jelenik meg. Az új verziókban gyakran jelentős újdonságok vannak.

Tulajdonsága

[szerkesztés]

A Rust programozási nyelv[4] alapvetően a C-re és a C++-ra épít, ugyanakkor nem implementál minden C++ -paradigmát és számos más nyelvből is vesz át ötleteket. Statikusan típusos és fordított nyelv.

A hangsúly a típushelyességen, memóriakezelésen, párhuzamosságon és a teljesítményen van. Összetett memória modellt alkalmaz, ami lehetővé teszi a hatékony adatszerkezetek és biztonságos konkurens minták használatát, illetve tiltja az érvénytelen memória hozzáféréseket amik szegmentációs hibákhoz vezethetnek. Rendszerprogramozásra tervezték.

Támogatja a multi-paradigma programozást, procedurális, funkcionális és objektumorientált módon. Néhány tulajdonsága:

  • Típuskikövetkeztetés: a típusok megadások a deklarációkban opcionális általában
  • Biztonságos task alapú konkurencia kezelés: task-okat alkalmaz a párhuzamosság megvalósításához, a köztük lévő kommunikációt pedig üzenetekkel valósítja meg és nem megosztott memóriával.
  • Magasabb rendű függvények. hatékony és flexibilis closure-k biztosítják
  • Mintaillesztés és algebrai típusok: minta illesztés a felsorolási típusoknál (hatékonyabban, mint C-ben), az algebrai típusok hasonlóak a funkcionális nyelvekben lévőkhöz
  • Polimorfizmus, típusváltozós függvények és típusok, típusosztályok és objektumorientált stílusú interfészek

Példakód

[szerkesztés]

Metódus

[szerkesztés]

Alábbi egyszerű példában téglalap struktúrát definiálunk (szélesség, magasság), majd implementálunk rá egy area metódust, amit meghívva visszakapjuk a téglalap területét.

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // A new() metódus hívása látja el a konstruktor szerepét.
    // Nem kötelező new() metódust készíteni.
    fn new(w: u32, h: u32) -> Self {
       Self { width: w, height: h }
    }

    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle { width: 3, height: 2 };
    let rect2 = Rectangle { width: 4, height: 5 };
    let rect3 = Rectangle::new(10, 20);            // ha van new() metódus

    println!("Area of rect1: {}", rect1.area());
    println!("Area of rect2: {}", rect2.area());
    println!("Area of rect3: {}", rect3.area());
}

A Rust-nak nincs nyelvi szinten konstruktora, viszont szokás new() metódust készíteni, amit a rect3-nál látható módon lehet használni. Bővebben: https://www.rust-lang.org/learn

Iterátor

[szerkesztés]

Az alábbi példakód egy szövegből az ismétlődő szavakat eltávolítja. Ciklus helyett a Python nyelvhez hasonlóan iterátor és adaptereinek felhasználásával tömörebb, átláthatóbb forráskód készíthető:

use std::collections::HashSet;

fn remove_dup_words(s: &str) -> String {
    let mut wordlist: HashSet<&str> = HashSet::new();

    let v: Vec<&str> = s
        .split_whitespace()
        .filter(|w| wordlist.insert(w))
        .collect();
    v.join(" ")
}

fn main() {
    let res = remove_dup_words("víz árvíz víz víz ár árvíz");
    println!("{}", res); // víz árvíz ár
}

A példában használt HashSet::insert() leírása itt látható.

Az iménti példa itertools csomag felhasználásával is megoldható:

use itertools::Itertools;

fn main() {
    let s = "víz árvíz víz víz ár árvíz";
    let res = s.split_whitespace().unique().join(" ");
    println!("{}", res); // víz árvíz ár
}

A Cargo a Rust programozási nyelvhez készült igen hatékony csomagkezelő.[5] Segítségével

  • létrehozhatunk projektet: cargo new teszt
  • fordíthatunk programot: cargo build
  • futtathatunk (fordít + futtat): cargo run
  • futtathatunk unit tesztet: cargo test
  • benchmarkolhatunk: cargo bench
  • törölhetjük a fordítási munkamappákat: cargo clean
  • Cargo.toml állomány [dependencies] részébe beírhatjuk a fordításkor a crates.io-ról letöltendő csomag nevét akár konkrét verziószámmal együtt, netán saját git repóból letöltendő csomagot, továbbá ebben az állományban sok egyéb dolgot beállíthatunk.

Kódtisztaság

[szerkesztés]
  • Egységes kódkinézet: rustfmt *.rs vagy cargo fmt[6]
  • Olyan gyakori hibák feltárása, amelyre van elegánsabb Rust kifejezés: cargo clippy[7]

Jegyzetek

[szerkesztés]