process::exit în Rust

use std::process;

pub fn exit(code: i32) -> !

Ce face process::exit

process::exit(cod) încheie procesul pe loc. Codul de ieșire ajunge la sistemul de operare: 0 înseamnă succes, orice altă valoare înseamnă o eroare. Scripturile shell ($?) și programele care te pornesc citesc acest cod.

Atenție: exit nu mai rulează destructorii (Drop) variabilelor încă vii, deci un BufWriter neîmpins (flush) își poate pierde datele. Tipul returnat ! înseamnă că funcția nu se întoarce niciodată.

Varianta mai curată pentru erori: main returnează Result<(), E>. La Err, Rust afișează Error: ... (cu {:?}) și iese cu codul 1, după ce a curățat totul. Pentru coduri anume poți returna std::process::ExitCode.

Parametri

Parametru	Descriere
code	Codul de ieșire. Pe Linux și macOS contează doar ultimii 8 biți (0-255).

Ce returnează

Nu se întoarce (!).

Exemple

Exemplul 1: Ieșire cu succes înainte de final

După exit(0), ultimul println! nu se mai execută.

use std::process;

fn main() {
    let comenzi = ["start", "stop", "restart"];
    for c in comenzi {
        println!("execut: {c}");
        if c == "stop" {
            println!("Am primit stop, ies.");
            process::exit(0);
        }
    }
    println!("acest rând nu apare");
}

Rezultat

execut: start
execut: stop
Am primit stop, ies.

Exemplul 2: Cod de eroare pentru shell

Mesajul de eroare merge pe ieșirea de eroare (eprintln!), iar codul 2 este citit de shell. Rezultatul este cel din terminal, după cargo run; echo $?.

use std::env;
use std::process;

fn main() {
    let argumente: Vec<String> = env::args().collect();
    if argumente.len() < 2 {
        eprintln!("Eroare: lipsește fișierul de intrare (folosire: program <fisier>)");
        process::exit(2);
    }
    println!("Procesez {}", argumente[1]);
}

Rezultat (programul se oprește cu codul 2)

Eroare: lipsește fișierul de intrare (folosire: program <fisier>)
2

Exemplul 3: main care returnează Result

La eroare, Rust afișează Error: urmat de eroare în format Debug și iese cu codul 1.

use std::fs;
use std::io;

fn main() -> Result<(), io::Error> {
    println!("Citesc setările...");
    let text = fs::read_to_string("setari.txt")?;
    println!("{text}");
    Ok(())
}

Rezultat (programul se oprește cu codul 1)

Citesc setările...
Error: Os { code: 2, kind: NotFound, message: "No such file or directory" }

Greșeli frecvente

• Apelezi exit când ai date nescrise într-un BufWriter sau fișiere temporare de șters: destructorii nu mai rulează. Fă flush() înainte sau returnează din main.
• Folosești exit(1) din adâncul programului în loc să returnezi o eroare. Codul devine greu de testat; păstrează exit pentru main.
• Folosești coduri negative sau peste 255: pe Linux și macOS se păstrează doar ultimii 8 biți (exit(256) devine 0).

Comenzi înrudite

• panic::catch_unwind: Rulează o funcție și prinde panica ei, returnând Err în loc să oprească programul.
• Error: Trait-ul comun al tuturor tipurilor de eroare: o eroare se poate afișa (Display, Debug) și poate avea o cauză.
• env::args: Argumentele din linia de comandă cu care a fost pornit programul; primul este numele programului.
• Command::status: Rulează programul, îl lasă să scrie direct în terminal și returnează doar felul în care s-a terminat.