Wikipedia

Rust (limbaj de programare)

limbaj de programare
Această pagină (secțiune) necesită o verificare.
De verificat: termanii informatici
Ștergeți eticheta numai după rezolvarea problemelor.
Rust

Rust logo
Extensii fișiere.rs, .rlib
ParadigmăMulti-paradigm, calcul simultan, funcțional, generic, imperativă, structurată
Apărut în7 iulie 2010; acum 13 ani, 9 luni și 8 zile (2010-07-07)
Proiectat deGraydon Hoare
DezvoltatorMozilla
Ultima versiune1.77.2[1]  Modificați la Wikidata
Tipareinference typing[*][[inference typing (automatic detection of the data type of an expression in a programming language)|​]]
nominative typing[*][[nominative typing (major class of type system, in which compatibility and equivalence of data types is determined by explicit declarations and/or the name of the types)|​]]
static typing[*][[static typing (type system paradigm where all type checking is done at compile time)|​]]
strong typing[*][[strong typing (specificity of a programming language's syntax when manipulating types of data)|​]]
linear typing[*][[linear typing (type discipline where every variable is used exactly once)|​]]
Hindley–Milner[*][[Hindley–Milner (type system supporting type inference)|​]]  Modificați la Wikidata
Influențat deAlef,[2] C#,[2] C++,[2] Cyclone,[2][3] Erlang,[2] Haskell,[2] Limbo,[2] Newsqueak,[2] OCaml,[2] Ruby,[2] Scheme,[2] Standard ML,[2] Swift[2][4]
InfluențeCrystal, Elm,[5] Idris,[6] Spark,[7] Swift,[8] Project Verona[9]
PlatformăARM, IA-32, x86-64, MIPS, PowerPC, SPARC, RISC-V[10][11]
Sistem de operareLinux, macOS, Windows, FreeBSD, OpenBSD,[12] Redox, Android, iOS[13]
LicențăMIT or Apache 2.0[14]
Tip MIMEtext/x-rust[15]
text/rust[15][16]  Modificați la Wikidata
Prezență onlinewww.rust-lang.org
Modifică date / text Consultați documentația formatului

Rust este un limbaj de programare[17] axat pe siguranță, în special concurența sigură.[18][19] Rust este similar sintactic cu C++,[20] dar este conceput pentru a oferi o mai bună siguranță a memoriei, menținând în același timp performanțe ridicate.

Rust a fost proiectat inițial de Graydon Hoare la Mozilla Research, cu contribuții de la Dave Herman, Brendan Eich și alții.[21][22] Designerii au perfecționat limbajul în timp ce scriau macheta Servo sau motorul browserului,[23] și compilatorul Rust. Compilatorul este un software gratuit și open-source cu licență dublă sub Licența MIT și Licența Apache 2.0.

Rust a fost „cel mai îndrăgit limbaj de programare” de la Stack Overflow Developer Survey în fiecare an începând cu 2016.[24][25][26][27]

Design modificare

Rustul este destinat să fie un limbaj pentru sisteme foarte concurente și extrem de sigure,[28] și programarea în mare, adică crearea și menținerea de limite care păstrează integritatea sistemului mare.[29] Acest lucru a dus la un set de caracteristici cu accent pe siguranță, controlul dispunerii memoriei și concurență.

Performanța Rust idiomatic modificare

Performanța Rust idiomatic este comparabilă cu performanța idiomatică C ++.[30][31]

Sintaxă modificare

Sintaxa concretă a Rust este similară cu C și C++, cu blocuri de cod delimitate de paranteze cretate și cuvinte cheie de control, cum ar fi if, else, while, și for. Nu toate cuvintele cheie C sau C ++ sunt implementate, însă unele funcții Rust (cum ar fi utilizarea potrivirii cuvintelor cheie pentru potrivirea modelului) vor fi mai puțin familiare cu cele versate în aceste limbi. În ciuda asemănării superficiale cu C și C ++, sintaxa Rust în sens mai profund este mai aproape de cea a familiei ML de limbi și a limbii Haskell. Aproape fiecare parte a unui corp de funcții este o expresie,[32] controlează chiar și operatorii de flux. De exemplu, expresia obișnuită dacă if și locul condiționatului ternar al lui C. O funcție nu trebuie să se termine cu o expresie return: în acest caz, dacă punctul virgulă este omis, ultima expresie din funcție creează valoarea returnare.

Securitatea memoriei modificare

Rust-ul este proiectat să fie în siguranță pentru memorie și, prin urmare, nu permite indicatoarele nule, indicatoarele sau cursele de date în cod sigur.[33][34][35][36] Valorile datelor pot fi inițializate doar printr-un set fix de formulare, care necesită deja inițializarea intrărilor lor.[37] Pentru a reproduce funcția în alte limbi de pointeri, fie valabilă sau NULL, cum ar fi în structurile de date de listă legată sau în arborele binar, biblioteca de bază Rust oferă un tip de opțiune, care poate fi utilizat pentru a testa dacă un pointer are Some valoari sau None. De asemenea, Rust introduce sintaxa suplimentară pentru a gestiona viața de viață, iar compilatorul motivează acest lucru prin intermediul verificatorului său de împrumut.

Gestionarea memoriei modificare

Rust nu utilizează un sistem automat de colectare a gunoiului precum cele utilizate de Go, Java sau .NET Framework. În schimb, memoria și alte resurse sunt gestionate prin convenția de achiziție a resurselor este inițializarea (RAII), cu numărarea de referință opțională. Rust asigură gestionarea deterministă a resurselor, cu cheltuieli generale foarte scăzute. Rugul favorizează, de asemenea, alocarea stivei de valori și nu realizează implicit box.

Există, de asemenea, un concept de referințe (folosind simbolul &), care nu implică numărarea de referințe în timp de rulare. Siguranța utilizării acestor indicatoare este verificată la timp de compilare de către verificatorul împrumutului, prevenind indicatoarele și alte forme de comportament nedefinit.

Proprietate modificare

Rust are un sistem de proprietate în care toate valorile au un proprietar unic, iar sfera valorii este aceeași cu sfera proprietarului.[38][39] Valorile pot fi transmise prin referință imuabilă, folosind &T, prin referință mutabilă, folosind &mut T, sau prin valoare, folosind T. În orice moment, pot fi fie mai multe referințe imuabile, fie o referință mutabilă (o blocare implicită pentru cititori-scriitori). Compilatorul Rust aplică aceste reguli la timp de compilare și, de asemenea, verifică dacă toate referințele sunt valide.

Exemple modificare

Hello World modificare

Iată un simplu „Program Hello, world!” program scris în Rust. println! macro imprimă mesajul la ieșire standard. 

fn main() {
    println!("Hello World!");
}

Funcția factorială modificare

Recursivă modificare 

fn factorial(i: u64) -> u64 {
    match i {
        0 => 1,
        n => n * factorial(n-1)
    }
}

Repetată modificare 

fn factorial(i: u64) -> u64 {
    let mut acc = 1;
    for num in 2..=i {
        acc *= num;
    }
    acc
}

Folosirea iteratoarelor modificare 

fn factorial(i: u64) -> u64 {
    (1..=i).product()
}

Note modificare

  1. ^ Announcing Rust 1.77.2 (în engleză), , accesat în  
  2. ^ a b c d e f g h i j k l m „The Rust Reference: Appendix: Influences”. Accesat în . Rust is not a particularly original language, with design elements coming from a wide range of sources. Some of these are listed below (including elements that have since been removed): SML, OCaml [...] C++ [...] ML Kit, Cyclone [...] Haskell [...] Newsqueak, Alef, Limbo [...] Erlang [...] Ruby [...] Swift [...] Scheme [...] C# [...] 
  3. ^ „Note Research: Type System”. . Accesat în . Papers that have had more or less influence on Rust, or which one might want to consult for inspiration or to understand Rust's background. [...] Region based memory management in Cyclone [...] Safe memory management in Cyclone 
  4. ^ „RFC for 'if let' expression”. Accesat în . 
  5. ^ „Command Optimizations?”. . Accesat în . I just added the outline of a Result library that lets you use richer error messages. It's like Either except the names are more helpful. The names are inspired by Rust's Result library. 
  6. ^ „Idris – Uniqueness Types”. Accesat în . 
  7. ^ Jaloyan, Georges-Axel (). „Safe Pointers in SPARK 2014”. Accesat în . 
  8. ^ Lattner, Chris. „Chris Lattner's Homepage”. Nondot.org. Accesat în . 
  9. ^ „Microsoft opens up Rust-inspired Project Verona programming language on GitHub”. Accesat în . Microsoft recently created a stir after revealing it was taking some ideas from the popular Rust programming language to create a new language for 'safe infrastructure programming' under the banner Project Verona. 
  10. ^ „Rust Platform Support”. Rust Forge. Accesat în . 
  11. ^ „Frequently Asked Questions”. Rust Embedded. Accesat în . 
  12. ^ „OpenBSD ports”. Accesat în . 
  13. ^ „Building and Deploying a Rust library on iOS”. . Accesat în . 
  14. ^ a b Available lexers — Pygments (în engleză), accesat în  
  15. ^ https://gitlab.freedesktop.org/xdg/shared-mime-info/-/commit/f75cbe0d37c990580dbb6f0694b53bc0c914d933, accesat în   Lipsește sau este vid: |title= (ajutor)
  16. ^ „Rust is a systems programming language”. Rust-lang.org. Accesat în . 
  17. ^ Hoare, Graydon (). „Rust is mostly safety”. Graydon2. Dreamwidth Studios. Accesat în . 
  18. ^ „FAQ – The Rust Project”. Rust-lang.org. Arhivat din original la . Accesat în . 
  19. ^ „Rust vs. C++ Comparison”. Accesat în . Rust is syntactically similar to C++, but it provides increased speed and better memory safety 
  20. ^ Noel (). „The Rust Language”. Lambda the Ultimate. Accesat în . 
  21. ^ „Contributors to rust-lang/rust”. GitHub. Accesat în . 
  22. ^ Bright, Peter (). „Samsung teams up with Mozilla to build browser engine for multicore machines”. Ars Technica. Accesat în . 
  23. ^ „Stack Overflow Developer Survey 2016 Results”. Stack Overflow. Accesat în . 
  24. ^ „Stack Overflow Developer Survey 2017”. Stack Overflow. Accesat în . 
  25. ^ „Stack Overflow Developer Survey 2018”. Stack Overflow. Accesat în . 
  26. ^ „Stack Overflow Developer Survey 2019”. Stack Overflow. Accesat în . 
  27. ^ Avram, Abel (). „Interview on Rust, a Systems Programming Language Developed by Mozilla”. InfoQ. Accesat în . GH: A lot of obvious good ideas, known and loved in other languages, haven't made it into widely used systems languages ... There were a lot of good competitors in the late 1970s and early 1980s in that space, and I wanted to revive some of their ideas and give them another go, on the theory that circumstances have changed: the internet is highly concurrent and highly security-conscious, so the design-tradeoffs that always favor C and C++ (for example) have been shifting. 
  28. ^ „Debian package description: rustc”. 
  29. ^ Walton, Patrick (). „C++ Design Goals in the Context of Rust”. Accesat în . It's impossible to be 'as fast as C' in all cases while remaining safe ... C++ allows all sorts of low-level tricks, mostly involving circumventing the type system, that offer practically unlimited avenues for optimization. In practice, though, C++ programmers restrict themselves to a few tools for the vast majority of the code they write, including stack-allocated variables owned by one function and passed by alias, uniquely owned objects (often used with auto_ptr or the C++0x unique_ptr), and reference counting via shared_ptr or COM. One of the goals of Rust's type system is to support these patterns exactly as C++ does, but to enforce their safe usage. In this way, the goal is to be competitive with the vast majority of idiomatic C++ in performance, while remaining memory-safe ... 
  30. ^ „How Fast Is Rust?”. The Rust Programming Language FAQ. Accesat în . 
  31. ^ „rust/src/grammar/parser-lalr.y”. . Accesat în . 
  32. ^ Rosenblatt, Seth (). „Samsung joins Mozilla's quest for Rust”. Arhivat din original la . Accesat în . [Brendan Eich] noted that every year browsers fall victim to hacking in the annual Pwn2Own contest at the CanSecWest conference. "There's no free memory reads" in Rust, he said, but there are in C++. Those problems "lead to a lot of browser vulnerabilities" and would be solved by Rust, which is a self-compiling language. 
  33. ^ Brown, Neil (). „A taste of Rust”. Accesat în . ... Other more complex data structures could clearly be implemented to allow greater levels of sharing, while making sure the interface is composed only of owned and managed references, and thus is safe from unplanned concurrent access and from dangling pointer errors. 
  34. ^ „'unsafe' – The Rust Programming Language”. 
  35. ^ „Data Races and Race Conditions”. 
  36. ^ „The Rust Language FAQ”. static.rust-lang.org. . Arhivat din original la . Accesat în . 
  37. ^ Klabnik, Steve; Nichols, Carol (iunie 2018). „Chapter 4: Understanding Ownership”. The Rust Programming Language (în engleză). San Francisco, California: No Starch Press. p. 44. ISBN 978-1-593-27828-1. Accesat în . 
  38. ^ „The Rust Programming Language: What is Ownership”. Rust-lang.org (în engleză). Accesat în . 

Legături externe modificare

Adus de la https://ro.wikipedia.org/w/index.php?title=Rust_(limbaj_de_programare)&oldid=16122870