Salt la conținutul principal
Modulul 1 · Lecția 2 din 22/14 în curs~10 min
Lecții din modul (2/2)

Tipuri primitive

Rust este un limbaj tastat static, ceea ce înseamnă că trebuie să cunoască tipul tuturor variabilelor în momentul compilării. De obicei, compilatorul poate deduce tipul pe baza valorii atribuite, dar uneori este necesar sau util să îl specificați manual.

Tipurile primitive din Rust sunt împărțite în două categorii principale: scalari (valoare unică) și compuși (grup de valori).

Tipuri scalare

Tipurile scalare reprezintă o singură valoare. Rust are patru tipuri scalare fundamentale:

  1. Numere întregi: numere întregi. Acestea pot fi semnate (i8, i16, i32, i64, i128, isizeLINE,TECTED_INLINE_5,PROTECTED,PROTECTED_INLINE) sau u16, u32, u64, u128, usize). Tipul implicit este i32.
  2. Floating-point: numere cu zecimale. Acestea pot fi f32 sau f64 (precizie dublă, implicită).
  3. Booleans: Reprezentați adevărul logic cu true sau false (tastați bool).
  4. Caractere: o singură valoare scalară Unicode cuprinsă între ghilimele simple (tip char), de exemplu, 'a', 'ℤ' sau emoji '😻'.

Exemplu de adnotare de tip explicit:

Rust
let x: i64 = 42;
let y: f64 = 3.1415;
let is_rust_awesome: bool = true;
let heart_emoji: char = '❤';

Tipuri compuse

Tipurile compuse pot grupa mai multe valori într-un singur tip. Rugina are două tipuri principale de compuși primitivi:

Tupluri

Un tuplu grupează valori de diferite tipuri într-o colecție de dimensiuni fixe:

Rust
let person: (String, i32) = (String::from("Alice"), 30);

// Destructuring to extract values
let (name, age) = person;

// Direct access with index using dot (.)
let name_direct = person.0;
let age_direct = person.1;

Matrice (liste cu dimensiuni fixe)

O matrice grupează mai multe elemente de același tip într-o colecție de dimensiuni fixe stocate pe stivă:

Rust
let numbers = [1, 2, 3, 4, 5]; // Inferred as [i32; 5]
let first = numbers[0]; // Access by index
let third = numbers[2];

Dacă încercați să accesați un index în afara limitelor matricei (de exemplu, numbers[10]), Rust se va prăbuși imediat (în panică) în timpul execuției, în loc să permită accesul neautorizat la memorie.

Comparaţie

CaracteristicatupluMatrice
Tipuri de elementePoate fi diferitTrebuie să fie la fel
DimensiuneFixFix
AccesIndexați prin punct (de ex., .0)Paranteze pătrate (de ex., [0])

Încercați-l singur

Exercițiu#rust.m1.l2.e1
Încercări: 0Se încarcă…

Declarați un tuplu numit statistici care conține vârsta de 30 (întreg) și scorul 95,5 (float). Apoi, tipăriți scorul pe ecran accesând direct al doilea element al tuplului folosind indexul acestuia.

Se încarcă editorul...
Afișează indiciu

Creați tuplu cu `let stats = (30, 95.5);`. Accesați al doilea element folosind `stats.1` în interiorul macro-ului `println!`.

Soluție disponibilă după 3 încercări

Exercițiu#rust.m1.l2.e2
Încercări: 0Se încarcă…

Declarați o matrice numită numere care conțin valori întregi de la 1 la 5. Imprimați al treilea element al matricei (index 2) pe ecran folosind println!.

Se încarcă editorul...
Afișează indiciu

Declarați matricea cu `let numere = [1, 2, 3, 4, 5];` și accesați al treilea element indexându-l cu `[2]`.

Soluție disponibilă după 3 încercări

Exercițiu#rust.m1.l2.e3
Încercări: 0Se încarcă…

Având în vedere tuplul `let point = (10, 20);`, utilizați destructurarea pentru a extrage valorile în două variabile numite `x` și `y`. Apoi, tipăriți suma lui `x` și `y`.

Se încarcă editorul...
Afișează indiciu

Utilizați sintaxa `let (x, y) = point;` pentru a destructura tuplu și apoi însumați variabilele în `println!`.

Soluție disponibilă după 3 încercări