Top 10 Exemples de code de programmation de rouille

La programmation est une question de résolution de problèmes. Il n'y a aucun moyen de devenir un programmeur compétent sans pratiquer et construire des choses. Dans cet article, nous créerons des projets pour vous lancer dans le langage de programmation de la rouille.

Obtenez la plus grande corde

Le premier programme tente de déterminer la plus grande chaîne à partir de deux paires de cordes. L'exemple de code source est comme indiqué ci-dessous:

FN le plus grand<'a>(str1: & 'a str, str2: &' a str) -> & 'a str
Si str1.Len ()> str2.Len ()
str1
autre
str2


fn main ()
Soit str1 = "bonjour";
Soit str2 = "LinuxHint";
Soit le résultat = le plus grand (STR1, STR2);
println!("Le plus grand: ", résultat);

Répertoire de compression dans le tarball

Le deuxième programme comprime le répertoire fourni dans un tarball. L'exemple de code source est comme indiqué:

NOTE: Ce code nécessite une bibliothèque de compression / décompression Flate2.

Utilisez STD :: FS :: Fichier;
Utilisez Flate2 :: Compression;
Utilisez Flate2 :: Write :: gzencoder;
fn main () -> résultat<(), std::io::Error>
Laissez gz = file :: Create ("Archive.le goudron.gz ");
Laissez Encoder = gzencoder :: new (gz, compression :: default ());
Laissez mut Tar = Tar :: Builder :: New (Enc);
// ajouter tous les fichiers dans le répertoire actuel à current_backup
le goudron.APPEND_DIR_ALL ("."," current_backup ")?;
D'accord(());

Décompresser le tarball

Vient ensuite un programme pour décompresser un tarball. Le code source est comme indiqué ci-dessous:

Utilisez STD :: FS :: Fichier;
Utilisez Std :: Path :: PathBuf;
Utilisez Flate2 :: Read :: gzencoder;
Utilisez Tar :: Archive;
Utilisez STD :: ERROR :: ERROR;
fn main () -> résultat<(), Box>
let file = file :: open ("path / to / archive.le goudron.gz ")?;
Let Mut Archive = Archive :: New (gzencoder :: new (fichier));
println!("Extrait:");
archive
.Entrées ()?
.filter_map (| e | e.d'accord())
.Carte (| Entrée Mut | -> Résultat>
Let Path = Entrée.chemin()?.to_owned ();
OK (chemin.to_path_buf ())
)
.filter_map (| e | e.d'accord())
.for_each (| x | println!("> ", x.afficher()));
D'accord(())

Trouver tous les fichiers txt dans un répertoire

Le programme suivant que nous pouvons construire est celui qui trouve tous les fichiers TXT dans un répertoire: le code est fourni ci-dessous:

Utilisez Glob :: Glob;
Utilisez STD :: ERROR :: ERROR;
fn main () -> résultat<(), Box>
Pour un article dans Glob ("** / *.SMS")?
println!("", article?.afficher());

D'accord(())

Générer des nombres aléatoires

Un programme simple pour générer des nombres aléatoires.

Utilisez Rand :: RNG;
fn main ()
Let Mut Range = Rand :: Thread_rng ();
Laissez num: i32 = plage.gen ();
println!("Random: ", n1);

Générateur de mot de passe

Nous pouvons créer un générateur de mots de passe en générant des caractères alphanumériques aléatoires. Le code est comme indiqué:

Utilisez Rand :: RNG;
const charet: & [u8] = b "Abcdefghijklmnopqrstuvwxyz \

abcdefghijklmnopqrstuvwxyz \

0123456789) (* & ^% $ # @!"
const Len: i32 = 25;
fn main ()
Laissez mut rng = rand :: thread_rng ();
Laissez le mot de passe: String = (0… len)
.map (| _ |
Soit idx = rng.Gen_Range (0… Charset.Len ());
Charset [idx] comme char
)
.collecter();
println!("Mot de passe: ", mot de passe);

Lire CSV

Le programme suivant consiste à lire un fichier CSV. Le code est montré:

Utilisez CSV :: ERROR;
fn main () -> résultat<(), Error>
Laissez csv_data = "
101, Edith, Masao, Edith.Masao @ mail.Io, Colombie, docteur
102, Kellen, Yusuk, Kellen.Yusuk @ courrier.Io, Nicaragua, policier
"
Laissez Mut Reader = CSV :: Reader :: From_reader (CSV_DATA.as_bytes ());
Pour Row in Reader.disques ()
Let Row = Row?;
println!(
"id | premier nom: | LastName: | Courriel: | pays: | profession: |",
& Row [0],
& Row [1],
& Row [2],
& Row [3],
& Row [4],
& Row [5],
));

D'accord(())

Nombre de cœurs de processeur

Obtenez le nombre de cœurs CPU logiques dans le programme:

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

Trier le vecteur (i32)

Vous pouvez trier un vecteur comme:

fn main ()
Laissez mut vec = vec![1,23,42,23,45,223,211,122,233,799 123];
vec.trier();
println!("Trié: :? ", vec)

Trier le vecteur (F64)

Vous pouvez également trier un vecteur de valeurs à virgule flottante comme:

fn main ()
Laissez mut vec = vec![23.12, 3.44, 5.55, 34.90, 2.0];
vec.sort_by (| x, y | x.partial_cmp (y).déballer());
println!("Trié: :? ", vec);

Enregistrer le message à la console

Vous pouvez utiliser le journal Création pour créer des messages de journal. Un exemple simple est comme indiqué ci-dessous:

FN LOG (Commande: & Str)
journal :: débogage!("Commande en cours: ", commande);

fn main ()
Env_Logger :: init ();
log ("PS Aux | Grep Bash");
// Exécutez avec la commande:
// Rust_log = Courage de débogage Run

Encoder la base64

Le code ci-dessous montre un programme pour coder une chaîne à la base64.

Utilisez Base64 :: Encode;
Utilisez STD :: ERROR :: ERROR;
fn main () -> résultat<(), Box>
Soit String = B "Bienvenue sur LinuxHint";
Selt Encoded = Encode (String);
println!("Base64: ", encodé);
D'accord(())

Decode Base64

Nous pouvons décoder la chaîne Base64 comme:

Utilisez Base64 :: Decode;
Utilisez Std :: Str;
Utilisez STD :: ERROR :: ERROR;
fn main () -> résultat<(), Box>
Soit B64 = "V2VSY29TZSB0BYBMAW51EGHPBNQ =";
Laissez décoder = & Decode (B64).un peu () […];
println!("Chaîne: :? ", str :: from_utf8 (décodé));
D'accord(())

Convertir l'heure locale en un autre fuseau horaire

Le programme ci-dessous convertit le temps local en fuseau horaire spécifié. Le code est comme indiqué ci-dessous:

Utilisez Chrono :: Prelude :: *;
fn main ()
Laissez local_time = local :: maintenant ();
Laissez UTC = DateTime :::: from_utc (local_time.naive_utc (), utc);
Soit EST = FIXEFOFFSET :: East (5 * 3600);
println!("Heure locale: manger", local_time);
println!("UTC Time Now: ", UTC);
println!("Est l'heure maintenant: ", UTC.avec_timezone (& est));
// Exemple de sortie
// Heure locale: 2022-02-27 14:50:31.014429200 +03: 00 Eat
// Time UTC maintenant: 2022-02-27 11:50:31.014429200 UTC
// heure est maintenant: 2022-02-27 16:50:31.014429200 +05: 00

Distance entre deux points sur Terre

Nous pouvons calculer la distance entre deux points sur Terre en fonction de la longitude et de la latitude comme indiqué dans l'exemple ci-dessous:

const earth_radis: f64 = 6378.1370;
fn main ()
Laissez nairobi_lat_deg = -1.286389_f64;
Laissez nairobi_long_deg = 36.817223_f64;
Soit El_paso_lat_deg = 31.772543_f64;
Soit El_paso_Long_deg = -106.460953_f64;
Laissez nairobi_lat = nairobi_lat_deg.to_radians ();
Soit EL_PASO_LAT = EL_PASO_LAT_DEG.to_radians ();
Soit delta_lat = (nairobi_lat_deg - el_paso_lat_deg).to_radians ();
Soit delta_long = (nairobi_long_deg - el_paso_long_deg).to_radians ();
LET ANGLE_INNER = (Delta_lat / 2.0).péché().Powi (2) +
nairobi_lat.cos () * e_paso_lat.cos () * (delta_long / 2.0).péché().Powi (2);
Soit Central_angle = 2.0 * Angle_inner.SQRT ().un péché();
Let Distance = Earth_radis * Central_angle;
println!("La distance entre Nairobi et El Paso est: ::.2 km ", distance);

Schéma d'URL d'extraction

Nous pouvons extraire l'hôte et le schéma d'une chaîne d'URL fournie comme:

Utilisez url :: url, hôte, parseError;
fn main () -> résultat<(), ParseError>
Soit String = "https: // Linuxhint.com ";
Laissez url = url :: parse (string)?;
Soit Schéma = URL.schème();
Laissez hôte = URL.héberger();
println!("Schéma: ", schéma);
println!("Héberger: :?", héberger);
D'accord(())