Vše, co potřebujete vědět, abyste mohli začít psát Rust

Od svého vydání v roce 2015 si Rust získal popularitu jako jeden z oblíbených programovacích jazyků vývojářů. Rust nabízí vynikající výkon a bezpečnostní funkce s intuitivní a stručnou syntaxí, díky které je jazyk žádoucí.

Rust je vhodný pro vytváření různých programů, včetně webových aplikací, nástrojů příkazového řádku a síťových služeb. Rust obsahuje mnoho funkcí, které očekáváte od moderního programovacího jazyka, jako je souběžnost, odvození typu a další.

Začínáme s Rustem

Rust je multiplatformní programovací jazyk, který běží na většině operačních systémů. Chcete-li začít s Rustem, zamiřte k úředníkovi Webové stránky Rust a nainstalujte preferovanou verzi pro váš operační systém.

Jakmile nainstalujete Rust, můžete začít psát programy do souborů Rust s a .rs rozšíření. Rust je univerzální a snadno se učí. Zjistíte, že je to jednoduché, pokud máte předchozí zkušenosti s programováním.

Proměnné a konstanty v rezu

Rust je vysoce expresivní a existuje několik způsobů, jak deklarovat proměnné. Můžete použít nechat klíčové slovo pro deklaraci proměnných.

Zde je návod, jak můžete deklarovat proměnné v Rustu:

nechat A: Tětiva;
nechat b: i32;
nechat c: () = ();

The A a b proměnné jsou řetězec a celé číslo. The C proměnná je typ jednotky Rust, který funguje jako zástupný symbol pro funkce a výrazy.

Po volitelné deklaraci datového typu můžete deklarovat a inicializovat proměnné s hodnotami pomocí znaménka rovná se.

fnhlavní(){
nechat stáří: Tětiva = Tětiva::z("pět let starý");
nechat věk = 5; // ekvivalent let věku: i32 = 5;
println!("{}", věk);
}

Program deklaruje dvě stáří proměnných před tiskem pomocí println! makro. První stáří proměnná určuje typ dat a druhá ne.

Při deklaraci proměnné nemusíte zadávat datový typ. Kompilátor Rust odvodí typ z datového typu hodnoty v době kompilace.

Můžete také deklarovat konstanty v Rustu pomocí konst klíčové slovo podobným způsobem jako při deklarování proměnných:

konst věk: &str = "pět let starý";

Nemůžete upravit hodnotu proměnné, kterou deklarujete jako konstantu.

Rust poskytuje funkce pro jednořádkové a blokové komentáře. Můžete použít dvojitá lomítka (//) pro jednořádkové komentáře:

fnhlavní() {
// Toto je řádkový komentář
nechat x = 5; // Tento komentář vysvětluje účel proměnné `x`
}

Pro víceřádkové komentáře (blokové komentáře) použijte lomítko následované hvězdičkou (/*) a zavřete blok hvězdičkou následovanou lomítkem (*/):

fnhlavní() {
/*
 Toto je blokový komentář, který zahrnuje více řádků.
 Často se používá k popisu většího bloku kódu.
 */
nechat x = 5;
}

Vaše komentáře by měly být stručné a přímé.

Pole v Rustu

Pole jsou kolekce prvků s pevnou velikostí stejného datového typu. Rust standardně alokuje pole na zásobníku.

Zde je návod, jak můžete deklarovat pole v Rustu:

fnhlavní() {
nechat čísla = [1, 2, 3, 4, 5];
}

The čísla pole obsahuje pět položek. K hodnotě můžete přistupovat na místě v poli pomocí jeho indexu:

fnhlavní() {
nechat čísla = [1, 2, 3, 4, 5];
nechat x = čísla[3];
println!("{}", X)
}

The hlavní funkce vytiskne X proměnná, která přistupuje ke čtvrtému prvku pole.

vektory v rzi

Rust poskytuje vektory pro zakrytí omezení pole. Velikosti vektorů jsou dynamicky; mohou růst a zmenšovat se podle potřeby.

Zde je návod, jak můžete deklarovat vektory v Rustu:

fnhlavní() {
nechat my_vec: Vec<i32> = vec![1, 2, 3, 4, 5];
nechat x = můj_vec[3];
println!("{}", X)
}

The můj_vec vector je vektor 32bitových celých čísel. The X proměnná přistupuje ke čtvrtému prvku vektoru a hlavní funkce vypíše hodnotu do konzole.

Rustova podmíněná prohlášení

Podmíněné příkazy jsou jedním z Řídicí struktury rzi pro rozhodování v programech. Můžete použít -li a jiný klíčová slova pro rozhodování ve vašich programech.

Zde je -li příkaz, který vypíše do konzole řetězec na základě rovnosti dvou celých čísel.

fnhlavní() {
nechat A: i32 = 12;
-li a == 12 {
println!("a rovná se dvanáct");
 }
}

The hlavní funkce vypíše řetězec s println! makro, protože proměnná se rovná 12.

Můžete použít jiný klíčové slovo pro řešení případů, kdy -li příkaz vyhodnotí nepravdu:

fnhlavní() {
nechat A: i32 = 12;
-li a == 123 {
println!("a rovná se dvanáct");
 } jiný {
println!("a nerovná se dvanáct");
 }
}

V tomto příkladu je jiný příkaz se spustí, protože hodnota a není rovna 123.

Můžete deklarovat shodu prohlášení s zápas klíčové slovo pro složité podmínky:

fnhlavní() {
nechat stáří: i32 = 7;
zápas věk {
1 => println!("jeden"),
2 => println!("dva"),
3 => println!("tři"),
 _ => println!("nula"),
 }
}

The hlavní funkce odpovídá stáří variabilní k případům v zápas a provede výraz, který odpovídá hodnotě. Podtržítko (_) je výchozí příkaz, který se spustí, pokud existuje shoda s hodnotou.

Smyčky v rzi

Rust poskytuje smyčky pro opakující se úkoly. Rust má tři hlavní typy smyček: smyčka, zatímco, a pro smyčky.

The smyčka klíčové slovo vytvoří nekonečnou smyčku, která běží, dokud nenarazí na klíčové slovo break:

fnhlavní() {
smyčka {
println!("tiskne se opakovaně, dokud nenarazíte na příkaz break.");
přestávka;
 }
}

The zatímco smyčka je užitečná, když chcete opakovat blok kódu, pokud je podmínka vyhodnocena jako pravdivá:

fnhlavní() {
nechatmut počítat = 0;
zatímco počítat < 5 {
println!("Počet je {}", počet);
 počítat += 1;
 }
}

A pro smyčka je dobrá pro iteraci přes kolekci položek, jako je pole:

fnhlavní() {
nechat čísla = [1, 2, 3, 4, 5];
pro položka v čísla.iter() {
println!("Aktuální položka je {}", položka);
 }
}

Tento pro smyčka iteruje přes čísla pole a vytiskne každou položku do konzoly.

Deklarace a volání funkcí Rust

Použijte fn klíčové slovo pro deklarovat funkci Rust, za kterým následuje název funkce, seznam parametrů a návratový typ (pokud existuje).

Zde je návod, jak můžete deklarovat funkci s parametry a návratovým typem:

fnpřidat(A: i32, b: i32) -> i32 {
vrátit se a + b;
}

The přidat funkce vezme dvě 32bitová celá čísla a vrátí 32bitové celé číslo, součet dvou parametrů.

Chcete-li volat funkci z jiného místa v kódu, jednoduše zadejte název a argumenty (pokud existují):

fnhlavní() {
nechat výsledek = přidat(2, 3);
println!("2 + 3 = {}", výsledek);
}

The výsledek proměnná obsahuje výsledek volání přidat funkce. The hlavní funkce vytiskne výsledek do konzole pomocí println! makro.

Konstrukce v rzi

Rust poskytuje struktury pro definování vlastních datových typů, které seskupují související hodnoty. Struktury jsou plány pro vytváření objektů se specifickými vlastnostmi.

Zde je návod, jak můžete deklarovat strukturu:

strukturovatOsoba {
 název: Tětiva,
 stáří: u32,
 is_male: bool,
}

The Osoba struct má tři pole: řetězec, 32bitové celé číslo bez znaménka a boolean.

Po definování struktury můžete vytvořit její instance v jiných částech vašeho programu:

fnhlavní() {
nechat osoba1 = Osoba {
 název: Tětiva::z("Candace Flynn"),
 stáří: 16,
 is_male: Nepravdivé,
 };
}

The osoba1 proměnná je instancí třídy Osoba strukturovat. Při vytváření instance můžete přiřadit hodnoty polím struct. Můžete vytvořit tolik instancí struktury, kolik chcete.

Můžete implementovat koncepty OOP v Rustu

Rust je flexibilní a koncepty OOP můžete implementovat v Rustu s vestavěnými datovými strukturami, jako jsou struktury.

Struktury použijete jako alternativu tříd. Pomocí Rust's struct můžete definovat plán pro typ a implementovat různé koncepty OOP s funkcemi, které Rust poskytuje na strukturách.