Rugini | ||
Data primei versiuni | 7 iulie 2010 | |
---|---|---|
Paradigme | Imperativ , funcțional , concurent | |
Autor | Graydon hoare | |
Dezvoltatori | Mozilla | |
Ultima versiune | 1.51.0 (25 martie 2021) | |
Tastare | Puternic , static | |
Influențată de | C ++ , Erlang , Haskell , Scala , OCaml , Scheme , Swift , C # , Alef , Limbo | |
Scris in | Rugini | |
Sistem de operare | Cross-platform | |
Licență | Licență Apache versiunea 2.0 și licență MIT | |
Site-ul web | www.rust-lang.org | |
Extensie de fișier | rs și rlib | |
Rust este omulti- paradigmă compilat limbaj de programare proiectat și dezvoltat de Mozilla Research din 2010. Acestafost proiectat pentru a fi „o,încredere concurente , limbaj practic“,sprijin pur funcțional , modelul de actor , de procedură ,stiluriprogramare.Precum și orientate obiect sub unele aspecte.
În 2020, domeniile sale preferate sunt programarea de sistem, aplicațiile din linia de comandă, aplicațiile web prin WebAssembly , serviciile de rețea și sistemele încorporate.
Ca rezultat al politicii Mozilla, Rust este dezvoltat pe deplin într-un mod deschis (inginerii Mozilla Research își postează ideile și deciziile luate la întâlniri) și solicită feedback și contribuții din partea comunității. Proiectarea limbajului este îmbunătățită treptat prin feedback-ul din partea echipei care lucrează la serverul de redare și pragmatic la scrierea compilatorului. Deși proiectul este finanțat de Mozilla, majoritatea contribuțiilor provin din comunitate.
Rust își propune să fie un limbaj puternic, sigur și productiv.
Limbajul poate oferi în special garanții privind absența erorii de segmentare sau a concurenței de la etapa de compilare. În plus, acest lucru se face fără colectarea gunoiului . Performanța sa este comparabilă cu cea a C sau C ++ în ceea ce privește viteza de execuție.
În cele din urmă, Rust vine cu Cargo , un manager de pachete pentru gestionarea compilării și a dependențelor între pachete. Compilatorul furnizează mesaje de eroare explicite și utile. Există, de asemenea, alte instrumente de editare pentru IDE-uri , precum și o documentație extinsă.
Limbajul s-a dezvoltat dintr-un proiect personal al lui Graydon Hoare, care a început să lucreze la el în 2006. Angajatorul său, Mozilla , a început să participe în 2009 și și-a dezvăluit oficial munca pentru prima dată în 2010. În același an, proiectul a trecut de la inițial. compilatorul folosit (scris în OCaml ) la compilatorul auto-găzduit scris în Rust. Acest compilator, cunoscut sub numele de rustc , a fost compilat cu succes în 2011. Compilatorul auto-găzduit folosește LLVM pentru backend - ul său .
Prima versiune alfa numerotată a compilatorului Rust a apărut în ianuarie 2012.
Prima versiune stabilă de Rust, 1.0, a fost lansată în 2015.
În 2017, Mozilla a anunțat că Rust acceptă compilarea setului de instrucțiuni de arhitectură RISC-V .
Sintaxa limbajului este similar cu C , care constă din blocuri de cod delimitate de bretele și structuri de control , cum ar fi if, else, whileși for.
Semantica lui Rust este însă destul de diferită. Într-adevăr, blocurile și structurile de control sunt expresii, așa cum putem vedea în exemplu:
let x = if n < 10 { n } else { n - 10 };În C, o astfel de operație nu este „inteligibilă” de compilator; fie va fi necesar să încapsulați blocul condițional într-o altă funcție, fie să utilizați un operator ternar int x = (n < 10) ? n : n - 10;.
Utilizarea expresiilor aduce astfel Rust mai aproape de limbaje funcționale precum Haskell sau OCaml .
În majoritatea limbilor, o variabilă este editabilă în mod implicit. Rust inversează această logică concentrându-se pe consistență: cuvântul cheie letimplicit declară variabile imuabile ( variabilă imutabilă în limba engleză) care nu pot fi atribuite o singură dată, dar a căror valoare poate fi setată la timpul de rulare. Este necesar să adăugați cuvântul cheie mutpentru a face o variabilă „modificabilă” sau „modificabilă”: astfel, restricționăm variabilele care sunt de fapt autorizate să se modifice. Tipul variabilelor este dedus ori de câte ori este posibil.
Pentru valorile constante cunoscute la compilare, cuvântul cheie constînlocuiește let. Tipul lor trebuie specificat și trebuie inițializat dintr-o expresie constantă, excluzând rezultatele apelurilor de funcții.
fn main() { // Déclaration de variables let mut a = 5; // a est une variable modifiable let b = a * 2; // b est non modifiable et du même type que a //constantes const c:u32 = 5; // déclaration d'une constante entière non-signée const c:u8 = b - 3; // interdit car `b - 3` n'est pas une expression constante (b non défini à la compilation) const c = 5; //interdit car le type de c n'est pas précisé //altération c = 3; // illégal car c est une constante b = 3; // illégal car b est une variable immuable a = 2; // autorisé car a est déclaré comme "mut" let a = a+5; // autorisé une nouvelle variable a est créée valant 7, //l'ancienne variable a est "couverte" par la nouvelle (shadowing) //vérification des valeurs assert_eq!(a, 5);//faux assert_eq!(b, 10);//vrai }Rugina permite definirea tipurilor de sume (sau enumerări) folosind cuvântul cheie enum. Putem utiliza aceste tipuri de sumă cu filtrarea modelelor , de exemplu folosind cuvântul cheie match.
Exemplu:
// On crée un type « Forme » pour décrire des formes géométriques. enum Forme { Point, // une forme peut être un point, sans données attachées. Rectangle(f64, f64), // une forme peut être un rectangle, caractérisé par les longueurs de ses côtés. Cercle(f64), // une forme peut être un cercle, caractérisé par son rayon. } // Calcule l'aire d'une forme géométrique. fn aire(f: Forme) -> f64 { match f { // Filtrage par motif avec « match » Forme::Point => 0.0, Forme::Cercle(rayon) => 3.14 * rayon * rayon, Forme::Rectangle(cote_a, cote_b) => cote_a * cote_b, } }Unele enumerări fac parte din biblioteca standard, cum ar fi Option , pentru a evita utilizarea indicatorului NULL .
Metaprogramarea activată datorită filtrării modelelorPentru a obține garanții de securitate, Rust folosește conceptele de proprietate (proprietate sau posesie) și împrumut (împrumut).
Astfel, o valoare are întotdeauna un singur proprietar. Dacă valoarea își schimbă calitatea de proprietar, proprietarul anterior nu îl mai poate folosi.
De exemplu :
fn prend_possession(v: Vec<i32>) { // Cette fonction prend possession de son paramètre v et ne la rend pas. println!("{:?}", v); } fn main() { let mut a = vec![1, 2, 3]; // a est le propriétaire du vecteur. let mut b = a; // b est maintenant le propriétaire du vecteur. // pas clair, a.push(4); // erreur de compilation : a n'a plus le droit d'utiliser ce vecteur prend_possession(b); b.push(5); // erreur de compilation : b n'a plus le droit d'utiliser ce vecteur }Pentru a utiliza o valoare în mai multe locuri în același timp, este posibil să împrumutați această valoare prin crearea de referințe .
Este posibil să creați:
În special, nu este posibil să se amestece referințele mutabile și imuabile.
Exemplu:
fn take_reference(v: &Vec<i32>) { // Cette fonction prend une référence vers un vecteur println!("{:?}", v); } fn correct() { let a = vec![1, 2, 3]; let ref_1 = &a; let ref_2 = &a; // On crée plusieurs références immuables vers a que l'on peut passer à des fonctions. // Faire ceci ne serait pas possible si l'on travaillait avec une fonction qui prend // l'ownership de a. take_reference(ref_1); take_reference(ref_2); } fn incorrect() { let mut a = vec![1, 2, 3]; // Ce code ne compile pas. // En effet, on travaille à la fois avec une référence muable vers a (ref_1), // et à la fois avec une référence immuable vers a (ref_2). let ref_1 = &mut a[0]; let ref_2 = &a; println!("{}", *ref_1); take_reference(ref_2); }Rust se bazează pe concepte cunoscute și dovedite (de unde și numele Rust , „ rugina ” în engleză) și nu integrează concepte noi și netestate . Aceste concepte au fost împrumutate din limbaje de programare existente și asamblate într-un singur limbaj:
Rugina este adesea descrisă ca unul dintre potențialii succesori ai C și C ++ (împreună cu D și, într-o măsură mai mică, Go ), în special pentru siguranța și viteza sa - acesta este un obiectiv clar declarat de dezvoltatori.