Top 10 esempi di codice di programmazione ruggine

La programmazione riguarda la risoluzione dei problemi. Non è possibile diventare un programmatore abile senza esercitarti e costruire cose. In questo articolo creeremo progetti per iniziare il linguaggio di programmazione Rust.

Ottieni la corda più grande

Il primo programma tenta di determinare la stringa più grande da due coppie di stringhe. Il codice sorgente di esempio è come mostrato di seguito:

fn più grande<'a>(STR1: & 'A STR, STR2: &' A STR) -> & 'A STR
Se str1.len ()> str2.len ()
STR1
altro
STR2


fn main ()
Lascia che str1 = "Hello";
let str2 = "linuxhint";
Sia risultato = più grande (STR1, STR2);
println!("Più grande: ", risultato);

Compress Directory in Tarball

Il secondo programma comprime la directory fornita in un Tarball. L'esempio del codice sorgente è come mostrato:

NOTA: Questo codice richiede FLATE2 Libreria di compressione/decompressione.

Usa std :: fs :: file;
usa flate2 :: compressione;
Usa flate2 :: write :: gzencoder;
fn main () -> risultato<(), std::io::Error>
let gz = file :: create ("archivio.catrame.gz ");
let encoder = gzencoder :: new (gz, compressione :: default ());
let mut tar = tar :: builder :: new (enc);
// Aggiungi tutti i file nella directory corrente a current_backup
catrame.append_dir_all ("."," current_backup ")?;
OK(());

Decomprime il tarball

Il prossimo è un programma per decomprimere un tarball. Il codice sorgente è come mostrato di seguito:

Usa std :: fs :: file;
Usa std :: path :: pathbuf;
Usa flate2 :: leggi :: gzencoder;
Usa Tar :: Archive;
Usa std :: Errore :: Errore;
fn main () -> risultato<(), Box>
let file = file :: open ("percorso/to/archivio.catrame.gz ")?;
Let Mut Archive = Archive :: New (Gzencoder :: new (file));
println!("Estratto:");
archivio
.inserimenti()?
.filter_map (| e | e.OK())
.mappa (| voce mut | -> risultato>
Let Path = Entry.sentiero()?.to_owned ();
OK (percorso.to_path_buf ())
)
.filter_map (| e | e.OK())
.for_each (| x | println!("> ", x.Schermo()));
OK(())

Trova tutti i file TXT in una directory

Il prossimo programma che possiamo costruire è quello che trova tutti i file TXT all'interno di una directory: Il codice è come previsto di seguito:

Usa Glob :: Glob;
Usa std :: Errore :: Errore;
fn main () -> risultato<(), Box>
per l'oggetto in glob ("**/*.TXT")?
println!("", articolo?.Schermo());

OK(())

Generare numeri casuali

Un semplice programma per generare numeri casuali.

Usa rand :: rng;
fn main ()
let mut range = rand :: thread_rng ();
Let Num: i32 = intervallo.gen ();
println!("Casuale: ", n1);

Generatore di password

Possiamo creare un generatore di password generando caratteri alfanumerici casuali. Il codice è come mostrato:

Usa rand :: rng;
const charset: & [u8] = b "abcdefghijklmnopqrsuvwxyz \

ABCDEFGHIJKLMNOPQRSTUVWXYZ \

0123456789) (*&^%$#@!";
const len: i32 = 25;
fn main ()
let mut rng = rand :: thread_rng ();
Let Password: String = (0 ... Len)
.mappa (| _ |
let idx = rng.Gen_Range (0 ... chatset.len ());
Chatset [idx] come char
)
.raccogliere();
println!("Password: ", password);

Leggi CSV

Il prossimo programma è leggere un file CSV. Il codice è mostrato:

Usa CSV :: ERROR;
fn main () -> risultato<(), Error>
let csv_data = "
101, Edith, Masao, [email protected], Colombia, dottore
102, Kellen, Yusuk, [email protected], Nicaragua, agente di polizia
";
let Mut Reader = CSV :: Reader :: From_Reader (CSV_DATA.as_bytes ());
Per riga nel lettore.Records ()
Sia la riga = riga?;
println!(
"Id | FirstName: | lastname: | email: | paese: | professione: |",
& row [0],
& Row [1],
& Row [2],
& Row [3],
& Row [4],
& Row [5],
);

OK(())

Numero di core della CPU

Ottieni il numero di core logici della CPU nel programma:

fn main ()
println!("CPU core: ", num_cpus :: get ());

Ordina vettore (i32)

Puoi ordinare un vettore come:

fn main ()
let mut vec = vec![1,23,42,23,45,223,211,122,233,799,123];
Vec.ordinare();
println!("Smistato: :? ", vec)

Ordina vettore (F64)

Puoi anche ordinare un vettore di valori a punto mobile come:

fn main ()
let mut vec = vec![23.12, 3.44, 5.55, 34.90, 2.0];
Vec.sort_by (| x, y | x.parziale_cmp (y).scartare());
println!("Smistato: :? ", vec);

Registra il messaggio alla console

È possibile utilizzare il registro Crea per creare messaggi di registro. Un semplice esempio è come mostrato di seguito:

fn log (comando: & str)
Log :: Debug!("Comando in esecuzione: ", comando);

fn main ()
env_logger :: init ();
log ("ps aux | grep bash");
// Esegui con il comando:
// Rust_log = debug cargo run

Codifica base64

Il codice seguente mostra un programma per codificare una stringa su Base64.

Usa base64 :: encode;
Usa std :: Errore :: Errore;
fn main () -> risultato<(), Box>
let string = b "benvenuto su linuxhint";
let codificato = encode (string);
println!("Base64: ", codificato);
OK(())

Decodifica Base64

Possiamo decodificare la stringa di base64 come:

Usa base64 :: decodifica;
Usa std :: str;
Usa std :: Errore :: Errore;
fn main () -> risultato<(), Box>
let b64 = "v2vsy29tzsb0bybmaw51eghpbnq =";
let decoded = & decode (B64).unwrap () […];
println!("Corda: :? ", str :: from_utf8 (decodificato));
OK(())

Converti l'ora locale in un'altra fuso orario

Il programma di seguito converte il tempo locale nel fuso orario specificato. Il codice è come mostrato di seguito:

Usa Chrono :: Prelude ::*;
fn main ()
let local_time = local :: ora ();
let utc = datetime :::: from_utc (local_time.naive_utc (), utc);
let EST = Fixoffset :: East (5 * 3600);
println!("Ora locale: eat", local_time);
println!("UTC Time Now: ", UTC);
println!("EST Time Now: ", UTC.with_timezone (& est));
// Esempio di output
// ora locale: 2022-02-27 14:50:31.014429200 +03: 00 EAT
// ora UTC: 2022-02-27 11:50:31.014429200 UTC
// EST TIME ORA: 2022-02-27 16:50:31.014429200 +05: 00

Distanza tra due punti sulla terra

Possiamo calcolare la distanza tra due punti sulla Terra in base alla longitudine e alla latitudine come mostrato nell'esempio seguente:

const earth_radis: f64 = 6378.1370;
fn main ()
let nairobi_lat_deg = -1.286389_F64;
let nairobi_long_deg = 36.817223_F64;
let el_paso_lat_deg = 31.772543_F64;
let el_paso_long_deg = -106.460953_F64;
let nairobi_lat = nairobi_lat_deg.to_radians ();
let el_paso_lat = el_paso_lat_deg.to_radians ();
let Delta_lat = (nairobi_lat_deg - el_paso_lat_deg).to_radians ();
let Delta_long = (nairobi_long_deg - el_paso_long_deg).to_radians ();
let angle_inner = (Delta_lat / 2.0).peccato().Powi (2) +
nairobi_lat.cos () * el_paso_lat.cos () * (Delta_long / 2.0).peccato().Powi (2);
Let Central_angle = 2.0 * Angle_inner.sqrt ().come in();
let Distance = Earth_radis * Central_angle;
println!("La distanza tra Nairobi ed El Paso è: :.2 km ", distanza);

Estrai schema URL

Possiamo estrarre l'host e lo schema da una stringa URL fornita come:

Usa url :: url, host, parseerror;
fn main () -> risultato<(), ParseError>
let string = "https: // linuxhint.com ";
let url = url :: parse (stringa)?;
Let Schema = URL.schema();
let host = url.ospite();
println!("Schema: ", schema);
println!("Ospite: :?", ospite);
OK(())