En aquest tema, aprendrem la sintaxi i l'estructura bàsica de Rust. Ens centrarem en els elements fonamentals que necessitem per escriure programes senzills en Rust.
Continguts
- Comentaris
- Variables i Constants
- Tipus de Dades Bàsics
- Operadors
- Estructura d'un Programa
- Comentaris
Els comentaris són línies de codi que no s'executen i s'utilitzen per explicar el codi. Rust suporta dos tipus de comentaris:
- Comentaris de línia única: Comencen amb
//. - Comentaris de múltiples línies: Comencen amb
/*i acaben amb*/.
- Variables i Constants
Variables
En Rust, les variables són immutables per defecte. Per declarar una variable mutable, utilitzem la paraula clau mut.
fn main() {
let x = 5; // Variable immutable
let mut y = 10; // Variable mutable
y = 15; // Això és vàlid perquè 'y' és mutable
}Constants
Les constants es declaren amb la paraula clau const i sempre han de tenir un tipus explícit.
- Tipus de Dades Bàsics
Rust té diversos tipus de dades bàsics:
- Numèrics:
i8,i16,i32,i64,i128,u8,u16,u32,u64,u128,f32,f64 - Booleans:
bool - Caràcters:
char - Tuples: Agrupen múltiples valors de diferents tipus.
- Arrays: Agrupen múltiples valors del mateix tipus.
Exemples
fn main() {
let a: i32 = 10; // Enter de 32 bits
let b: f64 = 3.14; // Número de coma flotant de 64 bits
let c: bool = true; // Booleà
let d: char = 'R'; // Caràcter
// Tuple
let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup; // Desestructuració de la tuple
// Array
let arr: [i32; 3] = [1, 2, 3];
}
- Operadors
Rust suporta els operadors aritmètics, de comparació i lògics habituals.
Operadors Aritmètics
+(suma)-(resta)*(multiplicació)/(divisió)%(mòdul)
Operadors de Comparació
==(igual a)!=(diferent de)>(més gran que)<(menys que)>=(més gran o igual a)<=(menys o igual a)
Operadors Lògics
&&(i lògic)||(o lògic)!(no lògic)
Exemples
fn main() {
let sum = 5 + 10; // Suma
let difference = 95.5 - 4.3; // Resta
let product = 4 * 30; // Multiplicació
let quotient = 56.7 / 32.2; // Divisió
let remainder = 43 % 5; // Mòdul
let is_equal = 5 == 5; // True
let is_not_equal = 5 != 6; // True
let is_greater = 5 > 3; // True
let is_less = 3 < 5; // True
let is_greater_or_equal = 5 >= 5; // True
let is_less_or_equal = 3 <= 5; // True
let and = true && false; // False
let or = true || false; // True
let not = !true; // False
}
- Estructura d'un Programa
Un programa en Rust es compon de funcions. La funció main és el punt d'entrada del programa.
Exemple de Programa
Explicació
fn main() {}: Defineix la funciómain.println!("Hola, món!");: Crida a la macroprintln!per imprimir un missatge a la consola.
Exercicis Pràctics
Exercici 1
Declara una variable immutable x amb el valor 10 i una variable mutable y amb el valor 20. Canvia el valor de y a 30 i imprimeix ambdues variables.
Solució
Exercici 2
Declara una constant PI amb el valor 3.14 i imprimeix-la.
Solució
Exercici 3
Declara una tuple amb tres elements: un enter, un número de coma flotant i un caràcter. Desestructura la tuple i imprimeix els seus valors.
Solució
fn main() {
let tup: (i32, f64, char) = (42, 3.14, 'R');
let (x, y, z) = tup;
println!("x: {}, y: {}, z: {}", x, y, z);
}Conclusió
En aquesta secció, hem après la sintaxi i l'estructura bàsica de Rust, incloent comentaris, variables, constants, tipus de dades bàsics, operadors i l'estructura d'un programa. Amb aquests coneixements, estem preparats per aprofundir en conceptes més avançats en els següents mòduls.