Rust (llenguatge de programació)

De Viquipèdia
Salta a la navegació Salta a la cerca
Infotaula de llenguatge de programacióRust
Rust programming language black logo.svg
Tipus llenguatge de programació procedural, llenguatge de programació funcional, llenguatge de programació multiparadigma, llenguatge de programació imperatiu, llenguatge de programació de sistemes, programari lliure, compiled language Tradueix i llenguatge de programació
Data de creació 2006, juliol 2010, 2009 i 2010
Desenvolupador Mozilla i Graydon Hoare
Epònim Uredinal
Darrera versió estable 1.34.0 ()
Llenguatge de programació Rust
Influenciat per Alef, C++, C♯, Camlp4 Tradueix, Common Lisp Tradueix, Cyclone, Erlang, Haskell, Hermes, Limbo, Napier88, Newsqueak, OCaml, Racket, NIL, Ruby, Sather, Scheme, ML Estàndard, Swift, Python, Clean i C
Sistema operatiu multiplataforma, Linux, macOS, Microsoft Windows, FreeBSD, iOS, Android i WebAssembly
Extensió dels fitxers rs i rlib
Codi font Codi font
Llicència Llicència Apache, versió 2.0 i Llicència MIT
Etiqueta d'Stack Exchange Etiqueta
Pàgina web Web oficial
Modifica les dades a Wikidata

Rust en ciència de la computació, és un llenguatge de programació dinàmic d'alt nivell dissenyat per ser segur, concurrent i pràctic. Rust és sintàcticament similar al llenguatge C++, però es caracteritza per una major seguretat de gestió de memòria. Rust és de tipus codi obert i va ser concebut per Graydon Hoare amb el suport de l'empresa Mozila l'any 2006.[1][2][3]

Característiques[modifica]

  • Sintaxi similar a  C i C++.
  • Seguretat en manegament de memòria.
  • Tipus i polimorfisme.

Aquest petit programa dibuixa la cadena "Hello, world!" a la sortida estàndard :

fn main() {
    println!("Hello, world!");
}

Operacions amb matrius (arrays) :

use std::mem;


// This function borrows a slice

fn analyze_slice(slice: &[i32]) {
    println!("first element of the slice: {}", slice[0]);
    println!("the slice has {} elements", slice.len());
}

fn main() {
    // Fixed-size array (type signature is superfluous)
    let xs: [i32; 5] = [1, 2, 3, 4, 5];
    // All elements can be initialized to the same value
    let ys: [i32; 500] = [0; 500];
    // Indexing starts at 0
    println!("first element of the array: {}", xs[0]);
    println!("second element of the array: {}", xs[1]);

    // `len` returns the size of the array
    println!("array size: {}", xs.len());

    // Arrays are stack allocated
    println!("array occupies {} bytes", mem::size_of_val(&xs));

    // Arrays can be automatically borrowed as slices

    println!("borrow the whole array as a slice");
    analyze_slice(&xs);

    // Slices can point to a section of an array
    println!("borrow a section of the array as a slice");

    analyze_slice(&ys[1 .. 4]);

    // Out of bound indexing yields a panic
    println!("{}", xs[5]);

}

Referències[modifica]

  1. «Rust Documentation · The Rust Programming Language» (en anglès). https://www.rust-lang.org.+[Consulta: 9 octubre 2017].
  2. «The Rust programming language» (en anglès). https://developer.mozilla.org.+[Consulta: 9 octubre 2017].
  3. «How Rust Compares to Other Programming Languages - The New Stack» (en anglès). The New Stack, 02-05-2016.