Learn Rust Coding · Leçon

Types scalaires

Entiers, nombres flottants, booléens, caractères

Types scalaires est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

What Are Scalar Types?

A scalar type represents a single value. Rust has four primary scalar types:

Integers
Floating-point numbers
Booleans
Characters

fn main() {
    let i = 10;       // integer
    let f = 2.5;      // float
    let b = true;     // bool
    let c = 'R';      // char
    println!("{} {} {} {}", i, f, b, c);
}

Integer Types

Integers come in signed (i) and unsigned (u) variants with fixed sizes: i8, i16, i32, i64, i128, and the same for u.

The default integer type is i32.

fn main() {
    let small: i8 = -120;
    let big: u64 = 18_000_000_000;
    println!("{} {}", small, big);
}

Signed vs Unsigned

Signed integers can be negative; unsigned cannot.

i8 ranges from -128 to 127.
u8 ranges from 0 to 255.

Choose unsigned when a value can never be negative, like a count.

fn main() {
    let temperature: i32 = -15;
    let people: u32 = 250;
    println!("temp {} people {}", temperature, people);
}

Integer Literals

You can write integers in different bases and use underscores for readability.

Decimal: 1_000_000
Hex: 0xff
Octal: 0o77
Binary: 0b1010

fn main() {
    let dec = 1_000;
    let hex = 0xff;
    let bin = 0b1010;
    println!("{} {} {}", dec, hex, bin);
}

Floating-Point Types

Rust has two float types: f32 and f64. The default is f64 because it offers more precision.

Floats follow the IEEE-754 standard.

fn main() {
    let pi: f64 = 3.141592;
    let e: f32 = 2.718;
    println!("pi {} e {}", pi, e);
}

Numeric Operations

Rust supports the usual math operators: +, -, *, /, and % (remainder).

Integer division truncates toward zero.

fn main() {
    let sum = 5 + 10;
    let quotient = 7 / 2;     // 3 (integer)
    let remainder = 7 % 2;    // 1
    let float_div = 7.0 / 2.0; // 3.5
    println!("{} {} {} {}", sum, quotient, remainder, float_div);
}

The Boolean Type

The bool type has exactly two values: true and false.

Booleans are produced by comparisons and used in if conditions.

fn main() {
    let is_active = true;
    let is_bigger = 10 > 3;
    println!("{} {}", is_active, is_bigger);
}

The Character Type

A char represents a single Unicode scalar value and is written with single quotes.

A Rust char is 4 bytes and can hold far more than ASCII — emoji and accented letters included.

fn main() {
    let letter = 'A';
    let symbol = '@';
    let heart = '\u{2764}';
    println!("{} {} {}", letter, symbol, heart);
}

char vs String

Single quotes make a char; double quotes make a string slice (&str).

'a' is a single character.
"a" is a one-character string.

fn main() {
    let c = 'x';
    let s = "x";
    println!("char {} string {}", c, s);
}

Type Conversion with as

Rust does not convert numeric types automatically. Use the as keyword for explicit casts.

Be careful: casting to a smaller type can lose data.

fn main() {
    let x: i32 = 65;
    let y: f64 = x as f64;
    let c = x as u8 as char;
    println!("{} {} {}", x, y, c);
}

Putting Scalars Together

Programs combine scalar types constantly. Here we mix integers, floats, and booleans to make a decision.

fn main() {
    let price: f64 = 19.99;
    let quantity: u32 = 3;
    let total = price * quantity as f64;
    let is_expensive = total > 50.0;
    println!("total {} expensive {}", total, is_expensive);
}

Quick Check

Test your knowledge of Rust scalar literals.

Recap

Rust's four scalar types:

Integers — signed (i32) and unsigned (u32), various sizes.
Floats — f32 and f64, default f64.
bool — true or false.
char — a single Unicode value in single quotes.

Use as for explicit numeric conversions.

fn main() {
    let count: u32 = 42;
    let ratio: f64 = count as f64 / 7.0;
    let ok: bool = ratio > 5.0;
    let grade: char = 'B';
    println!("{} {} {} {}", count, ratio, ok, grade);
}

Questions Fréquemment Posées

La leçon « Types scalaires » est-elle gratuite ?

Oui — le texte complet de « Types scalaires » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Types scalaires » ?

Entiers, nombres flottants, booléens, caractères Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Types scalaires » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Learn Rust Coding