Top 10 przykładów kodu programowania rdzy

Programowanie polega na rozwiązywaniu problemów. Nie ma mowy, żebyś mógł zostać biegłym programistą bez praktykowania i budowania rzeczy. W tym artykule utworzymy projekty, aby zacząć w języku programowania rdzy.

Uzyskaj największy ciąg

Pierwszy program próbuje określić największy ciąg z dwóch par ciągu. Przykładowy kod źródłowy jest jak pokazano poniżej:

FN największy<'a>(str1: & 'a str, str2: &' a str) -> & 'a str
Jeśli STR1.len ()> str2.len ()
str1
w przeciwnym razie
str2


fn main ()
niech str1 = "hello";
let str2 = "Linuxhint";
Niech wynik = największy (STR1, STR2);
println!(„Największy: ”, wynik);

Direccipress Directory do Tarball

Drugi program kompresuje dostarczony katalog w tarbball. Przykład kodu źródłowego jest taki jak pokazano:

NOTATKA: Ten kod wymaga biblioteki kompresji/dekompresji Flate2.

Użyj STD :: FS :: Plik;
Użyj flate2 :: kompresja;
Użyj flate2 :: napisz :: gzencoder;
fn main () -> wynik<(), std::io::Error>
Let Gz = File :: „Archive Archive.smoła.gz ");
Let encoder = gzencoder :: new (gz, kompresja :: default ());
Niech Mut Tar = TAR :: Builder :: New (Enc);
// Dodaj wszystkie pliki w bieżącym katalogu do Current_backup
smoła.append_dir_all (”.„,„ Current_backup ”)?;
OK(());

Dekompresuj Tarball

Dalej jest program dekompresji Tarball. Kod źródłowy jest jak pokazano poniżej:

Użyj STD :: FS :: Plik;
Użyj std :: ścieżka :: ścieżka;
Użyj flate2 :: read :: gzencoder;
Użyj TAR :: Archive;
Użyj std :: error :: error;
fn main () -> wynik<(), Box>
niech plik = plik :: „ścieżka/do/archiwum.smoła.GZ ")?;
Let Mut Archive = Archive :: new (gzencoder :: new (plik));
println!(„Wyodrębnione:”);
archiwum
.wpisy ()?
.Filter_map (| e | e.OK())
.mapa (| wpis mut | -> wynik>
Niech ścieżka = wejście.ścieżka()?.to_owned ();
OK (ścieżka.to_path_buf ())
)
.Filter_map (| e | e.OK())
.For_each (| x | println!("> ", x.wyświetlacz()));
OK(())

Znajdź wszystkie pliki TXT w katalogu

Następny program, który możemy zbudować, to taki, który znajduje wszystkie pliki TXT w katalogu: kod jest podany poniżej:

Użyj globu :: glob;
Użyj std :: error :: error;
fn main () -> wynik<(), Box>
dla pozycji na świecie ("**/*.tekst")?
println!("", przedmiot?.wyświetlacz());

OK(())

Wygeneruj liczby losowe

Prosty program generowania liczb losowych.

Użyj rand :: rng;
fn main ()
Let Mut Range = rand :: Thread_rng ();
Niech num: i32 = zakres.gen ();
println!(„Random: ”, n1);

Generator hasła

Możemy utworzyć generator haseł, generując losowe znaki alfanumeryczne. Kod jest tak, jak pokazano:

Użyj rand :: rng;
const Charset: & [u8] = b "abcdEfghijklmnopqrstuvwxyz \

ABCDEFGHIJKLMNOPQRSTU VWXYZ\

0123456789) (*i^%$#@!";
const len: i32 = 25;
fn main ()
niech mut rng = rand :: Thread_rng ();
Niech hasło: string = (0… len)
.mapa (| _ |
Niech idx = rng.gen_range (0….len ());
Charset [idx] jako char
)
.zbierać();
println!(„Hasło: ”, hasło);

Przeczytaj CSV

Następnym programem jest odczytanie pliku CSV. Kod jest pokazany:

Użyj CSV :: błąd;
fn main () -> wynik<(), Error>
Niech csv_data = "
101, Edith, Masao, [email protected], Kolumbia, lekarz
102, Kellen, Yusuk, [email protected], Nikaragua, policjant
";
Let Mut Reader = CSV :: Reader :: From_Reader (csv_data.as_bytes ());
dla wiersza w czytelniku.Records ()
Niech wiersz = wiersz?;
println!(
„Id | FirstName: | LastName: | e -mail: | kraj: | zawód: |",
& Row [0],
& Row [1],
i rząd [2],
& Row [3],
& Row [4],
i rząd [5],
);

OK(())

Liczba rdzeni procesora

Uzyskaj liczbę logicznych rdzeni procesora w programie:

fn main ()
println!(„CPU Rdzenia: ”, num_cpus :: get ());

Sort wektor (i32)

Możesz sortować wektor jako:

fn main ()
Niech MUT VEC = VEC![1 23,42,23,45 223,211,122 233,799,123];
VEC.sortować();
println!(„Sortowane: :? ", VEC)

Sort wektor (F64)

Możesz także sortować wektor wartości zmiennoprzecinkowych jako:

fn main ()
Niech MUT VEC = VEC![23.12, 3.44, 5.55, 34.90, 2.0];
VEC.sort_by (| x, y | x.parial_cmp (y).odwijać się());
println!(„Sortowane: :? ", vec);

Komunikat dziennika do konsoli

Możesz użyć dziennika Utwórz, aby tworzyć komunikaty dziennika. Prosty przykład jest pokazany poniżej:

log fn (polecenie: & str)
Log :: Debug!(„Uruchamianie polecenia: ”, polecenie);

fn main ()
env_logger :: init ();
log („ps aux | grep bash”);
// Uruchom z poleceniem:
// rust_log = debugowanie ładunków

Ekoduj Base64

Poniższy kod pokazuje program kodujący ciąg do Base64.

Użyj Base64 :: Encode;
Użyj std :: error :: error;
fn main () -> wynik<(), Box>
Niech String = B "Welcome to Linuxhint";
let enkoded = enkode (string);
println!(„Base64: ”, zakodowany);
OK(())

Dekodować bazę 64

Możemy zdekodować ciąg Base64 jako:

Użyj Base64 :: Decode;
Użyj std :: str;
Użyj std :: error :: error;
fn main () -> wynik<(), Box>
niech b64 = "v2vsy29tzsb0bybmaw51eghpbnq =";
Niech dekodowane = i dekoduj (B64).rozpad () […];
println!("Strunowy: :? ", str :: from_utf8 (dekodowany));
OK(())

Konwertuj czas lokalny na inną strefę czasową

Poniższy program przekształca czas lokalny w określoną strefę czasową. Kod jest jak pokazano poniżej:

Użyj Chrono :: Prelude ::*;
fn main ()
niech lokalny_time = local :: now ();
LET UTC = DATETIME :::: from_utc (local_time.naive_utc (), utc);
niech est = stałąfort :: East (5 * 3600);
println!(„Czas lokalny: eat”, local_time);
println!(„UTC Time Now: ”, UTC);
println!("Est czas teraz: ", UTC.z_timezone (i est));
// Przykładowe dane wyjściowe
// Czas lokalny: 2022-02-27 14:50:31.014429200 +03: 00 Eat
// UTC Czas teraz: 2022-02-27 11:50:31.014429200 UTC
// est czas teraz: 2022-02-27 16:50:31.014429200 +05: 00

Odległość między dwoma punktami na Ziemi

Możemy obliczyć odległość między dwoma punktami na Ziemi na podstawie długości geograficznej i szerokości geograficznej, jak pokazano w poniższym przykładzie:

const earth_radis: f64 = 6378.1370;
fn main ()
Niech nairobi_lat_deg = -1.286389_f64;
Niech nairobi_long_deg = 36.817223_f64;
Niech EL_PASO_LAT_DEG = 31.772543_f64;
Niech EL_PASO_LONG_DEG = -106.460953_f64;
Niech nairobi_lat = nairobi_lat_deg.to_radians ();
Niech EL_PASO_LAT = EL_PASO_LAT_DEG.to_radians ();
Niech delta_lat = (nairobi_lat_deg - el_paso_lat_deg).to_radians ();
Niech delta_long = (nairobi_long_deg - el_paso_long_deg).to_radians ();
Let Angle_inner = (delta_lat / 2.0).grzech().Powi (2) +
Nairobi_lat.cos () * el_paso_lat.cos () * (delta_long / 2.0).grzech().Powi (2);
Niech Central_angle = 2.0 * Angle_inner.sqrt ().jak w();
niech dystans = earth_radis * Central_angle;
println!(„Odległość między Nairobi i El Paso to: :.2 km ", odległość);

Wyodrębnij Schemat URL

Możemy wyodrębnić hosta i schemat z dostarczonego ciągu adresu URL jako:

Użyj URL :: url, host, parseerror;
fn main () -> wynik<(), ParseError>
LET STRING = "https: // Linuxhint.com ";
let url = url :: parse (ciąg)?;
Niech schemat = URL.schemat();
Niech host = URL.gospodarz();
println!(„Schemat: ”, schemat);
println!("Gospodarz: :?", gospodarz);
OK(())