Rust (programozási nyelv)
Ez a szócikk nem tünteti fel a független forrásokat, amelyeket felhasználtak a készítése során. Emiatt nem tudjuk közvetlenül ellenőrizni, hogy a szócikkben szereplő állítások helytállóak-e. Segíts megbízható forrásokat találni az állításokhoz! Lásd még: A Wikipédia nem az első közlés helye. |
Rust | |
Paradigma |
|
Jellemző kiterjesztés | rs |
Megjelent | 2006 |
Tervező | Graydon Hoare |
Fejlesztő |
|
Utolsó kiadás | 1.82.0 (stabil verzió, 2024. október 17.)[1] |
Hatással volt rá | |
Licenc |
|
Weboldal |
A Rust egy programozási nyelv. Különlegességét az adja, hogy
- teljeskörűen a biztonságos programozásra törekszik,
- 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”,
- 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
}
Cargo
[szerkesztés]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
vagycargo fmt
[6] - Olyan gyakori hibák feltárása, amelyre van elegánsabb Rust kifejezés:
cargo clippy
[7]
Jegyzetek
[szerkesztés]- ↑ Announcing Rust 1.82.0 (angol nyelven), 2024. október 17. (Hozzáférés: 2024. október 17.)
- ↑ https://doc.rust-lang.org/nightly/edition-guide/rust-2024/index.html
- ↑ DRAFT: Async 2024, Github / rust-lang
- ↑ Rust Programming Language
- ↑ The Cargo Book
- ↑ Format Rust code
- ↑ A bunch of lints to catch common mistakes and improve your Rust code