Wszystko, co musisz wiedzieć, aby zacząć pisać Rust

Od momentu wydania w 2015 roku Rust zyskał popularność jako jeden z ulubionych języków programowania programistów. Rust oferuje doskonałą wydajność i funkcje bezpieczeństwa z intuicyjną i zwięzłą składnią, która czyni ten język pożądanym.

Rust nadaje się do tworzenia różnych programów, w tym aplikacji internetowych, narzędzi wiersza poleceń i usług sieciowych. Rust zawiera wiele funkcji, których można oczekiwać od nowoczesnego języka programowania, takich jak współbieżność, wnioskowanie o typie i wiele innych.

Pierwsze kroki z rdzą

Rust to wieloplatformowy język programowania, który działa na większości systemów operacyjnych. Aby rozpocząć pracę z Rust, udaj się do urzędnika Witryna Rusta i zainstaluj preferowaną wersję dla swojego systemu operacyjnego.

Po zainstalowaniu Rusta możesz zacząć pisać programy w plikach Rusta z rozszerzeniem

rs rozszerzenie. Rust jest wszechstronny i łatwy do nauczenia. Przekonasz się, że jest to proste, jeśli masz wcześniejsze doświadczenie w programowaniu.

Zmienne i stałe w Rust

Rust jest wysoce ekspresyjny i istnieje wiele sposobów deklarowania zmiennych. Możesz użyć pozwalać słowo kluczowe do deklarowania zmiennych.

Oto jak możesz deklarować zmienne w Rust:

pozwalać A: Strunowy;
pozwalać B: i32;
pozwalać do: () = ();

The A I B zmienne są odpowiednio łańcuchem i liczbą całkowitą. The C zmienna jest typem jednostki Rust, która działa jako element zastępczy dla funkcji i wyrażeń.

Po opcjonalnej deklaracji typu danych można zadeklarować i zainicjować zmienne wartościami za pomocą znaku równości.

przypgłówny(){
pozwalać wiek: Strunowy = Strunowy::z(„pięć lat”);
pozwalać wiek = 5; // odpowiednik let age: i32 = 5;
drukuj!("{}", wiek);
}

Program deklaruje dwa wiek zmienne przed drukowaniem za pomocą drukuj! makro. Pierwszy wiek zmienna określa typ danych, a druga nie.

Nie musisz określać typu danych zmiennej podczas jej deklarowania. Kompilator Rusta określa typ na podstawie typu danych wartości w czasie kompilacji.

Możesz także zadeklarować stałe w Rust za pomocą konst słowa kluczowego w podobny sposób jak deklarowanie zmiennych:

konst wiek: &ul = „pięć lat”;

Nie możesz modyfikować wartości zmiennej, którą deklarujesz jako stałą.

Rust zapewnia funkcjonalność komentarzy jednowierszowych i blokowych. Możesz użyć podwójnych ukośników (//) dla komentarzy jednowierszowych:

przypgłówny() {
// To jest komentarz wiersza
pozwalać x = 5; // Ten komentarz wyjaśnia przeznaczenie zmiennej `x`
}

W przypadku komentarzy wielowierszowych (komentarzy blokowych) użyj ukośnika, po którym następuje gwiazdka (/*) i zamknij blok gwiazdką, po której następuje ukośnik (*/):

przypgłówny() {
/*
 To jest komentarz blokowy obejmujący wiele wierszy.
 Jest często używany do opisywania większego bloku kodu.
 */
pozwalać x = 5;
}

Twoje komentarze powinny być zwięzłe i proste.

Tablice w Rust

Tablice to zbiór elementów tego samego typu danych o stałym rozmiarze. Rust domyślnie przydziela tablice na stosie.

Oto jak możesz zadeklarować tablice w Rust:

przypgłówny() {
pozwalać liczby = [1, 2, 3, 4, 5];
}

The liczby tablica zawiera pięć elementów. Możesz uzyskać dostęp do wartości w lokalizacji w tablicy za pomocą jej indeksu:

przypgłówny() {
pozwalać liczby = [1, 2, 3, 4, 5];
pozwalać x = liczby [3];
drukuj!("{}", X)
}

The główny funkcja drukuje X zmienna, która uzyskuje dostęp do czwartego elementu tablicy.

Wektory w Rust

Rust zapewnia wektory, aby zakryć ograniczenia tablicy. Wektory są dopasowywane dynamicznie; mogą rosnąć i kurczyć się w zależności od potrzeb.

Oto jak możesz zadeklarować wektory w Rust:

przypgłówny() {
pozwalać mój_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
pozwalać x = mój_vec[3];
drukuj!("{}", X)
}

The mój_vec wektor jest wektorem 32-bitowych liczb całkowitych. The X zmienna uzyskuje dostęp do czwartego elementu wektora, a główny funkcja drukuje wartość do konsoli.

Instrukcje warunkowe Rusta

Instrukcje warunkowe są jednym z Struktury kontrolne Rusta do podejmowania decyzji w programach. Możesz użyć Jeśli I w przeciwnym razie słów kluczowych do obsługi decyzji w programach.

Oto an Jeśli instrukcja, która wypisuje ciąg znaków na konsoli w oparciu o równość dwóch liczb całkowitych.

przypgłówny() {
pozwalać A: i32 = 12;
Jeśli == 12 {
drukuj!(„a równa się dwanaście”);
 }
}

The główny funkcja drukuje ciąg z drukuj! makro, ponieważ zmienna jest równa 12.

Możesz użyć w przeciwnym razie słowo kluczowe do obsługi przypadków, w których Jeśli instrukcja ocenia false:

przypgłówny() {
pozwalać A: i32 = 12;
Jeśli == 123 {
drukuj!(„a równa się dwanaście”);
 } w przeciwnym razie {
drukuj!(„a nie równa się dwanaście”);
 }
}

W tym przykładzie w przeciwnym razie instrukcja jest wykonywana, ponieważ wartość a nie jest równa 123.

Możesz zadeklarować instrukcje dopasowania za pomocą mecz słowo kluczowe dla złożonych warunków warunkowych:

przypgłówny() {
pozwalać wiek: i32 = 7;
mecz wiek {
1 => drukuj!("jeden"),
2 => drukuj!("dwa"),
3 => drukuj!("trzy"),
 _ => drukuj!("zero"),
 }
}

The główny funkcja pasuje do wiek zmienna do przypadków w mecz instrukcja i wykonuje wyrażenie pasujące do wartości. Znak podkreślenia (_) to domyślna instrukcja, która jest uruchamiana, jeśli istnieje dopasowanie do wartości.

Pętle w Rust

Rust zapewnia pętle dla powtarzalnych zadań. Rust ma trzy główne typy pętli: pętla, chwila, I Do pętle.

The pętla słowo kluczowe tworzy nieskończoną pętlę, która działa, dopóki nie napotka słowa kluczowego break:

przypgłówny() {
pętla {
drukuj!(„drukowane wielokrotnie, dopóki nie zostanie napotkana instrukcja break”.);
przerwa;
 }
}

The chwila pętla jest przydatna, gdy chcesz powtórzyć blok kodu, o ile warunek ma wartość true:

przypgłówny() {
pozwalaćmut liczyć = 0;
chwila liczyć < 5 {
drukuj!(„Liczba wynosi {}”, liczyć);
 liczyć += 1;
 }
}

A Do pętla jest dobra do iteracji po zbiorze elementów, takich jak tablica:

przypgłówny() {
pozwalać liczby = [1, 2, 3, 4, 5];
Do przedmiot W liczby.iter() {
drukuj!(„Bieżący przedmiot to {}”, przedmiot);
 }
}

Ten Do pętla iteruje przez liczby array i wypisuje każdy element na konsoli.

Deklarowanie i wywoływanie funkcji Rusta

Użyj przyp słowo kluczowe do zadeklarować funkcję Rusta, po której następuje nazwa funkcji, lista parametrów i zwracany typ (jeśli istnieje).

Oto jak możesz zadeklarować funkcję z parametrami i zwracanym typem:

przypdodać(A: i32, B: i32) -> i32 {
powrót a + b;
}

The dodać funkcja przyjmuje dwie 32-bitowe liczby całkowite i zwraca 32-bitową liczbę całkowitą, czyli sumę dwóch parametrów.

Aby wywołać funkcję z innego miejsca w kodzie, po prostu podaj nazwę i argumenty (jeśli istnieją):

przypgłówny() {
pozwalać wynik = dodaj(2, 3);
drukuj!("2 + 3 = {}", wynik);
}

The wynik zmienna zawiera wynik wywołania metody dodać funkcjonować. The główny funkcja drukuje wynik na konsoli za pomocą drukuj! makro.

Struktury w rdzy

Rust zapewnia struktury do definiowania niestandardowych typów danych, które grupują powiązane wartości. Struktury to schematy tworzenia obiektów o określonych właściwościach.

Oto jak możesz zadeklarować strukturę:

strukturaOsoba {
 nazwa: Strunowy,
 wiek: u32,
 jest_mężczyzną: bool,
}

The Osoba struct ma trzy pola: łańcuch, 32-bitową liczbę całkowitą bez znaku i wartość logiczną.

Po zdefiniowaniu struktury możesz tworzyć jej instancje w innych częściach programu:

przypgłówny() {
pozwalać osoba1 = osoba {
 nazwa: Strunowy::z(„Candace Flynn”),
 wiek: 16,
 jest_mężczyzną: FAŁSZ,
 };
}

The osoba1 zmienna jest instancją Osoba struktura. Podczas tworzenia instancji można przypisać wartości do pól struktury. Możesz utworzyć dowolną liczbę instancji struktury.

Możesz zaimplementować koncepcje OOP w Rust

Rust jest elastyczny i możesz zaimplementować koncepcje OOP w Rust z wbudowanymi strukturami danych, takimi jak structs.

Będziesz używać struktur jako alternatywy dla klas. Dzięki strukturze Rust możesz zdefiniować plan dla typu i zaimplementować różne koncepcje OOP z funkcjonalnościami, które Rust zapewnia w strukturach.