Све што треба да знате да почнете да пишете Руст

Од свог објављивања 2015. године, Руст је стекао популарност као један од омиљених програмских језика програмера. Руст нуди одличне перформансе и безбедносне карактеристике са интуитивном и сажетом синтаксом која језик чини пожељним.

Руст је погодан за прављење различитих програма, укључујући веб апликације, алате командне линије и мрежне услуге. Руст укључује многе функције које очекујете од модерног програмског језика, као што су конкурентност, закључивање типа и још много тога.

Почетак рада са Руст-ом

Руст је вишеплатформски програмски језик који ради на већини оперативних система. Да бисте започели са Рустом, идите до званичника Руст вебсите и инсталирајте жељену верзију за ваш оперативни систем.

Када инсталирате Руст, можете почети да пишете програме у Руст датотекама помоћу а .рс проширење. Руст је свестран и лак за учење. Биће вам то једноставно ако имате претходно искуство у програмирању.

Променљиве и константе у Русту

Руст је веома изражајан и постоји више начина да се декларишу променљиве. Можете користити дозволити кључна реч за декларисање променљивих.

Ево како можете декларисати променљиве у Русту:

дозволити а: Низ;
дозволити б: и32;
дозволити ц: () = ();

Тхе а и б променљиве су стринг и цео број, респективно. Тхе ц променљива је тип јединице Руст која делује као чувар места за функције и изразе.

Након декларације опционог типа података, можете декларисати и иницијализовати променљиве са вредностима користећи знак једнакости.

фнглавни(){
дозволити старост: Низ = Низ::од("пет година");
дозволити старост = 5; // еквивалент лет аге: и32 = 5;
принтлн!("{}", старост);
}

Програм декларише два старости променљиве пре штампања са принтлн! макро. Први старости променљива одређује тип података, а друга не.

Не морате да наведете тип података променљиве када је декларишете. Руст компајлер закључује тип из типа података вредности у време компајлирања.

Такође можете декларисати константе у Русту помоћу конст кључна реч на сличан начин као што је декларисана променљива:

конст старост: &стр = "пет година";

Не можете да мењате вредност променљиве коју декларишете као константу.

Руст пружа функционалност за коментаре у једном реду и блокове. Можете користити двоструке косе црте (//) за коментаре у једном реду:

фнглавни() {
// Ово је коментар на линији
дозволити к = 5; // Овај коментар објашњава сврху променљиве `к`
}

За коментаре у више редова (блок коментаре), користите косу црту унапред праћену звездицом (/*) и затворите блок звездицом праћеном косом цртом (*/):

фнглавни() {
/*
 Ово је блок коментар који обухвата више редова.
 Често се користи за описивање већег блока кода.
 */
дозволити к = 5;
}

Ваши коментари треба да буду концизни и јасни.

Низови у Русту

Низови су колекција елемената фиксне величине истог типа података. Руст подразумевано додељује низове на стеку.

Ево како можете декларисати низове у Русту:

фнглавни() {
дозволити бројеви = [1, 2, 3, 4, 5];
}

Тхе бројевима низ садржи пет ставки. Можете да приступите вредности на локацији у низу користећи њен индекс:

фнглавни() {
дозволити бројеви = [1, 2, 3, 4, 5];
дозволити к = бројеви[3];
принтлн!("{}", Икс)
}

Тхе главни функција штампа Икс променљива која приступа четвртом елементу низа.

Вектори у Русту

Руст обезбеђује векторе за прикривање ограничења низа. Вектори су динамичке величине; могу да расту и да се смањују по потреби.

Ево како можете да прогласите векторе у Русту:

фнглавни() {
дозволити мој_вец: Вец<и32> = вец![1, 2, 3, 4, 5];
дозволити к = ми_вец[3];
принтлн!("{}", Икс)
}

Тхе ми_вец вектор је вектор 32-битних целих бројева. Тхе Икс променљива приступа четвртом елементу вектора, а главни функција штампа вредност на конзоли.

Рустове условне изјаве

Условни искази су један од Рустове контролне структуре за доношење одлука у програмима. Можете користити ако и друго кључне речи за доношење одлука у вашим програмима.

Ево једног ако изјава која штампа стринг на конзоли на основу једнакости два цела броја.

фнглавни() {
дозволити а: и32 = 12;
ако а == 12 {
принтлн!("а једнако дванаест");
 }
}

Тхе главни функција штампа стринг са принтлн! макро пошто је променљива једнака 12.

Можете користити друго кључна реч за решавање случајева у којима је ако изјава оцењује нетачно:

фнглавни() {
дозволити а: и32 = 12;
ако а == 123 {
принтлн!("а једнако дванаест");
 } друго {
принтлн!("а није једнако дванаест");
 }
}

У овом примеру, друго израз се покреће јер вредност а није једнака 123.

Наредбе подударања можете декларисати са меч кључна реч за сложене кондиционале:

фнглавни() {
дозволити старост: и32 = 7;
меч старост {
1 => принтлн!("један"),
2 => принтлн!("два"),
3 => принтлн!("три"),
 _ => принтлн!("нула"),
 }
}

Тхе главни функција одговара старости променљива у случајевима у меч наредбу и извршава израз који одговара вредности. Доња црта (_) је подразумевана изјава која се покреће ако постоји подударање за вредност.

Лоопс ин Руст

Руст обезбеђује петље за задатке који се понављају. Руст има три главне врсте петљи: петља, док, и за петље.

Тхе петља кључна реч ствара бесконачну петљу која се покреће све док не наиђе на кључну реч бреак:

фнглавни() {
петља {
принтлн!(„штампа се више пута док се не наиђе на наредбу бреак.“);
пауза;
 }
}

Тхе док петља је згодна када желите да поновите блок кода све док се услов процењује на тачно:

фнглавни() {
дозволитимут цоунт = 0;
док цоунт < 5 {
принтлн!(„Број је {}“, цоунт);
 цоунт += 1;
 }
}

А за петља је добра за понављање преко колекције ставки, као што је низ:

фнглавни() {
дозволити бројеви = [1, 2, 3, 4, 5];
за предмет ин нумберс.итер() {
принтлн!(„Тренутна ставка је {}“, ставка);
 }
}

Ово за петља се понавља кроз бројевима низ и штампа сваку ставку на конзоли.

Декларисање и позивање Руст функција

Користити фн кључна реч за прогласити Руст функцију, а затим име функције, листа параметара и тип повратка (ако постоји).

Ево како можете декларисати функцију са параметрима и типом повратка:

фндодати(а: и32, б: и32) -> и32 {
повратак а + б;
}

Тхе додати функција узима два 32-битна цела броја и враћа 32-битни цео број, збир два параметра.

Да бисте позвали функцију са другог места у вашем коду, једноставно наведите име и аргументе (ако их има):

фнглавни() {
дозволити резултат = додај(2, 3);
принтлн!("2 + 3 = {}", резултат);
}

Тхе резултат променљива садржи резултат позивања додати функција. Тхе главни функција штампа резултат на конзоли користећи принтлн! макро.

Структуре у Руст

Руст обезбеђује структуре за дефинисање прилагођених типова података које групишу повезане вредности. Структуре су нацрти за креирање објеката са одређеним својствима.

Ево како можете декларисати структуру:

струцтОсоба {
 име: Низ,
 старост: у32,
 је_мушко: боол,
}

Тхе Особа струцт има три поља: стринг, неозначени 32-битни цео број и логички.

Након што дефинишете структуру, можете креирати њене инстанце у другим деловима вашег програма:

фнглавни() {
дозволити особа1 = Особа {
 име: Низ::од("Кендис Флин"),
 старост: 16,
 је_мушко: лажно,
 };
}

Тхе особа1 променљива је инстанца Особа струцт. Приликом инстанцирања, можете доделити вредности пољима структуре. Можете креирати колико год желите инстанци структуре.

Можете имплементирати ООП концепте у Руст-у

Руст је флексибилан и можете имплементирати ООП концепте у Руст-у са уграђеним структурама података као што су структуре.

Користићете структуре као алтернативу класама. Са Руст-овом структуром, можете дефинисати нацрт за тип и имплементирати различите ООП концепте са функционалностима које Руст пружа на структурама.