Rust er eit moderne systemprogrammeringsspråk som er designa for ytelse, tryggleik og samtidighet. Det gir brukarar kraftige språkfunksjonar samtidig som det strevar etter å eliminere vanlege programmeringsfeil, som nullpeikar-derefereringar og dataraser. Rust legg vekt på nullkostnadsabstraksjonar, som gjer det mogleg for utviklarar å skrive høgnivåkode utan å ofre ytelse. Det er spesielt godt eigna for oppgåver der lågnivåkontroll av maskinvare og minnehandsaming er nødvendig, som systemprogrammering, webassembly og å lage høgtytande applikasjonar.
Rust blei fødd i 2006 av Graydon Hoare ved Mozilla Research. Språket sitt første formål var å ta tak i utfordringane med å utvikle trygg samtidige program og å lage eit meir påliteleg alternativ til eksisterande systemprogrammeringsspråk. I 2010 blei den første offentlege versjonen av Rust lansert, og det fekk raskt merksemd for sin innovative tilnærming til minnesikkerheit og samtidighet.
Rust hentar inspirasjon frå fleire programmeringsspråk, som C++ for sin ytelsesorienterte design og funksjonelle programmeringsspråk for sin vekt på immutabilitet og kraftige abstraksjonar. Designet reflekterer også prinsipp frå språk som Haskell, spesielt i sitt robuste typesystem og mønsterpassingsfunksjonar.
Sidan starten har Rust modna til eit breitt anerkjent språk, med eit sterkt utviklarfellesskap og eit voksande bibliotekøkosystem. Språket har fått offisiell støtte frå Mozilla og har fått fotfeste i ulike domener, inkludert webutvikling, innebygde system og spelutvikling. Lanseringa av Rust 1.0 i 2015 markerte eit viktig milepæl, som stadfesta stabiliteten og beredskapen for produksjonsbruk. Rust Foundation, etablert i 2021, støttar den vidare utviklinga og styringa av språket.
Rust sitt unike eigarskapsmodell gjer det mogleg for utviklarar å handtere minne utan ein søppelryttar. Kvar variabel i Rust har ein einaste eigar, og eigarskap kan bli overført, eller "lånt", gjennom referansar. Denne funksjonen hjelper til med å sikre minnesikkerheit ved å håndheve strenge låne-reglar.
fn main() {
let s1 = String::from("Hello");
let s2 = &s1; // Låner s1
println!("{}", s2);
}
Mønsterpassning i Rust gjer det mogleg for utviklarar å destrukturere datatypar og handtere kompleks kontrollflyt sømløst. match-setninga gir ein kraftig måte å forgreine logikk basert på verdimønster.
fn main() {
let number = 4;
match number {
1 => println!("Ein"),
2 => println!("To"),
_ => println!("Annan"),
}
}
Rust nyttar typeinferens, som gjer at kompilatoren kan dedusere variabeltypar automatisk, noko som forenklar koden og aukar lesbarheita.
fn main() {
let x = 5; // Kompilatoren infererer at x er av typen i32
}
Trekk er liknande grensesnitt i andre språk og gjer det mogleg med polymorfisme. Dei definerer delt åtferd som typar kan implementere.
trait Speak {
fn speak(&self);
}
struct Dog;
impl Speak for Dog {
fn speak(&self) {
println!("Voff!");
}
}
Rust sine Option og Result typar gir robust feilhandsaming og null-sikker programmeringsparadigmer, som gjer det mogleg for utviklarar å uttrykke moglegheita for fravær eller feil eksplisitt.
fn divide(x: f64, y: f64) -> Option<f64> {
if y == 0.0 {
None
} else {
Some(x / y)
}
}
Rust støttar fryktlaus samtidighet gjennom sitt eigarskapssystem, som gjer det mogleg for fleire trådar å operere på data med minimal risiko for dataraser.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("Hallo frå ein tråd!");
});
handle.join().unwrap();
}
Rust sitt makrosystem gjer det mogleg for kodegenerering, noko som gjer det mogleg å skrive tilpassa syntaktiske konstruksjonar som kan bli gjenbrukt over heile kodebasen.
macro_rules! say_hello {
() => {
println!("Hallo!");
};
}
fn main() {
say_hello!();
}
Lukkingar i Rust er anonyme funksjonar som kan fange variablar frå sitt miljø, noko som gjer dei fleksible for funksjonelle programmeringsparadigmer.
fn main() {
let add = |a, b| a + b;
println!("{}", add(5, 7));
}
Rust nyttar eit modulsystem for å organisere kode og kontrollere synlegheit. Krater er pakkar med Rust-kode som kan delast og gjenbrukast.
mod my_module {
pub fn hello() {
println!("Hallo frå my_module!");
}
}
fn main() {
my_module::hello();
}
Rust har innebygde dokumentasjonsfunksjonar, og Rustdoc-verktøyet genererer automatisk dokumentasjon frå kommentarar i kildekoden.
/// Denne funksjonen legg til to tal.
///
/// # Eksempel
///
/// ```
/// let result = add(2, 3);
/// assert_eq!(result, 5);
/// ```
fn add(a: i32, b: i32) -> i32 {
a + b
}
Rust har eit rikt sett med utviklarverktøy, inkludert sin pakkeforvaltar, Cargo, som let deg handtere avhengigheiter, bygge og publisere bibliotek og applikasjonar. Rust sitt standardbibliotek gir rike kjøretidsstøtte for ulike oppgåver.
Fleire IDEar og editorar støttar Rust-utvikling, inkludert:
For å lage eit nytt Rust-prosjekt kan utviklarar bruke Cargo med følgjande kommando:
cargo new my_project
Denne kommandoen genererer ein ny katalog som inneheld ei grunnleggjande Rust-prosjektstruktur. For å bygge prosjektet, naviger til prosjektkatalogen og kjør:
cargo build
Rust blir nytta på tvers av ulike domener på grunn av sine ytelses- og tryggleiksfunksjonar. Nøkkelapplikasjonar inkluderer:
Rust blir ofte samanlikna med andre systemprogrammeringsspråk på grunn av sin vekt på ytelse og tryggleik. Her er nokre samanlikningar:
Å oversette Rust-kode til andre språk kan vere utfordrande på grunn av sin unike eigarskapsmodell og avanserte funksjonar. Likevel er det nokre verktøy som let deg gjennomføre kilde-til-kilde oversettingar, som: