Path în Rust

O cale din sistemul de fișiere, împrumutată (ca &str pentru texte); Path::new transformă un text în &Path.

Sintaxă
use std::path::Path;

pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &Path

Ce face Path

Path este pentru căi ce este str pentru texte: o vedere împrumutată, care nu poate fi modificată. Path::new("documente/iunie.csv") nu creează nimic pe disc și nu verifică dacă fișierul există; doar privește textul ca pe o cale. Varianta deținută și modificabilă este PathBuf (ca String).

Pe un Path ai metode care înțeleg structura căii: file_name(), extension(), parent(), join(), components(), precum și metode care întreabă sistemul: exists(), is_file(), is_dir().

O cale nu este neapărat UTF-8 valid. Pentru afișare folosește cale.display(); pentru text, to_str() (dă Option) sau to_string_lossy().

Parametri

Parametru Descriere
s Textul căii: &str, String, OsStr.

Ce returnează

&Path.

Exemple

Exemplul 1: Părțile unei căi

use std::path::Path;

fn main() {
    let cale = Path::new("documente/rapoarte/vanzari_iunie.csv");

    println!("cale:       {}", cale.display());
    println!("nume:       {:?}", cale.file_name());
    println!("fără ext.:  {:?}", cale.file_stem());
    println!("extensie:   {:?}", cale.extension());
    println!("părinte:    {:?}", cale.parent());
    println!("relativă:   {}", cale.is_relative());

    let parti: Vec<_> = cale.components().map(|c| c.as_os_str().to_string_lossy()).collect();
    println!("componente: {parti:?}");
}

Rezultat

cale:       documente/rapoarte/vanzari_iunie.csv
nume:       Some("vanzari_iunie.csv")
fără ext.:  Some("vanzari_iunie")
extensie:   Some("csv")
părinte:    Some("documente/rapoarte")
relativă:   true
componente: ["documente", "rapoarte", "vanzari_iunie.csv"]

Exemplul 2: Funcții care acceptă orice fel de cale

Cu impl AsRef<Path>, funcția primește &str, String, Path sau PathBuf.

use std::path::{Path, PathBuf};

fn descrie(cale: impl AsRef<Path>) -> String {
    let cale = cale.as_ref();
    format!("{} -> {:?}", cale.display(), cale.extension())
}

fn main() {
    println!("{}", descrie("poza.jpg"));
    println!("{}", descrie(String::from("notite.md")));
    println!("{}", descrie(Path::new("arhiva.tar.gz")));
    println!("{}", descrie(PathBuf::from("Makefile")));
}

Rezultat

poza.jpg -> Some("jpg")
notite.md -> Some("md")
arhiva.tar.gz -> Some("gz")
Makefile -> None

Greșeli frecvente

  • Crezi că Path::new verifică existența fișierului: nu atinge discul. Folosește exists() sau, mai bine, deschide fișierul și tratează eroarea.
  • Lipești căi cu format!("{}/{}", a, b): pe Windows separatorul este \. Folosește join.
  • Afișezi cu {:?} și primești ghilimele și escape-uri. Pentru oameni, folosește {} cu cale.display().

Comenzi înrudite

  • PathBuf: Calea deținută și modificabilă (ca String pentru texte): push adaugă componente, set_extension schimbă extensia.
  • Path::join: Lipește o cale la alta cu separatorul corect al sistemului și returnează un PathBuf nou.
  • Path::extension: extension() dă extensia fișierului (după ultimul punct), file_name() ultima parte a căii, fără directoare.
  • Path::parent: Returnează calea fără ultima componentă (directorul care o conține) sau None pentru rădăcină.
  • Path::exists: Întreabă sistemul dacă la cale există ceva (exists), dacă este un fișier (is_file) sau un director (is_dir).