Да ли сте програмер који размишља о учењу Rust-a? Овај текст ће вам помоћи у одлуци, представљајући кључне карактеристике Rust-a, једног од најпопуларнијих програмских језика за системско програмирање.
У овом чланку, детаљно ћемо истражити програмски језик Rust, фокусирајући се на његове особине као што су систем типова, заштита меморије и концепт власништва. Такође ћемо понудити списак корисних ресурса који вам могу олакшати процес учења Rust-a.
Кренимо!
Шта је Rust?
Rust је системски програмски језик који је првобитно био лични пројекат Грејдона Хоара, програмера, још 2006. године. За мање од десет година, развио се у један од водећих избора за системско програмирање и сродне примене. Просечна плата Rust програмера износи око 120 хиљада долара.
Дакле, ако размишљате о преласку са C++ на Rust, или једноставно желите да научите нови језик, учење Rust-a може бити одлична опција! Према истраживању StackOverflow Developer, Rust је проглашен за најомиљенији програмски језик – и то седам година узастопно.
Извор слике: StackOverflow
Rust комбинује брзину ниско-нивоских програмских језика, као што су C и C++, са сигурношћу високо-нивоских програмских језика, као што је Python.
Од великих пројеката као што су Dropbox и Firefox, до WebAssembly-a и уграђеног програмирања, Rust се широко примењује у свим областима развоја софтвера. Rust такође нуди интегрисану подршку за управљање пакетима кроз Cargo.
Cargo: менаџер пакета за Rust
Cargo је менаџер пакета који се користи у Rust-у. Можете га користити за инсталирање пакета из crates.io, регистра пакета за Rust. Осим што омогућава претрагу, инсталацију и управљање пакетима, Cargo такође функционише као покретач тестова, генератор документације и систем за прављење.
Сада када имате кратак преглед Rust-a, погледајмо детаљније неке од карактеристика које га издвајају као системски програмски језик са широком применом.
Јасне поруке о грешкама
Као програмер почетник, сигурно ћете се сусретати са грешкама и трошити доста времена на отклањање истих у свом коду. Користићете поруке о грешкама и упозорења која даје компајлер, како бисте решили те проблеме. Јасне поруке вам могу значајно помоћи да брже отклањате грешке.
Пример поруке о грешци
Када ваш код не прође успешно компилацију, Rust пружа детаљне поруке о грешкама, које објашњавају шта треба да се исправи у коду, и где се проблем налази.
У овом примеру, променљива `num2` је дефинисана унутар функције `inner()`, те је стога ограничена на њен опсег. Ако покушате да јој приступите ван функције, компајлер ће пријавити грешку:
fn main() {
let num1 = 10;
fn inner(){
let num2 = 9;
}
println!("The value of num2 is: {}", num2);
}
Порука о грешци даје прецизне информације о томе шта треба да се поправи.
error[E0425]: cannot find value `num2` in this scope
--> src/main.rs:6:42
|
6 | println!("The value of num2 is: {}", num2);
| ^^^^ help: a local variable with a similar name exists: `num1`
Упозорења током компилације
Компајлер такође нуди корисна упозорења у вези са потенцијалним проблемима у коду. Када дефинишете променљиве, а не користите их у остатку програма, Rust ће приказати упозорење, као што је приказано у наставку:
fn main() {
let num1 = 10;
let num2 = 9;
println!("The value of num1 is: {}", num1);
}
Овде је променљива `num2` декларисана, али се никада не користи.
warning: unused variable: `num2`
--> src/main.rs:3:9
|
3 | let num2 = 9;
| ^^^^ help: if this is intentional, prefix it with an underscore: `_num2`
|
Јако типизиран језик
Још један разлог због којег бисте требали размотрити Rust за своје пројекте је његов систем типова. Rust је јако типизиран језик, што значи да не дозвољава имплицитну конверзију типа. Имплицитна конверзија типа је када језик аутоматски претвара вредност из једног типа података у други.
На пример, Python код у следећој ћелији ће се покренути без грешака. То је зато што у Python-у, број различит од нуле има вредност `True`, те стога, `if` наредба ради без проблема – иако је број 10 цео број, а не Boolean.
num1 = 10
if num1:
num2 = 9
print(f"num2 is {num2}")
# Output: num2 is 9
С друге стране, Rust не дозвољава имплицитне конверзије типова. Дакле, следећи код ће дати грешку:
fn main() {
let num1 = 10;
if num1{
let num2 = 9;
}
}
Грешка указује на неподударање типова, где се очекивала Boolean вредност, а пронађен је цео број.
error[E0308]: mismatched types
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ expected `bool`, found integer
Безбедност меморије
Безбедност меморије је још једна кључна карактеристика Rust-a која га чини привлачним програмерима. У наставку следи кратак преглед како то функционише.
Променљиве морају бити иницијализоване пре употребе
У Rust-у, све променљиве морају бити иницијализоване пре него што се могу користити. У језицима као што је C, следећи код, где `num` није иницијализован, ће се компајлирати и покренути без грешака. Вредност неиницијализоване променљиве је нека нежељена вредност.
#include <stdio.h>
int main(void) {
int num;
printf("The value of num is %d", num);
return 0;
}
// Output: The value of num is 0
Ако покушате да урадите нешто слично у Rust-у, добићете грешку у времену компилације. Дакле, Rust нема концепт сакупљања смећа.
fn main() {
let num:i32;
println!("The value of num is: {}",num);
}
error[E0381]: used binding `num` isn't initialized
--> src/main.rs:3:40
|
2 | let num:i32;
| --- binding declared here but left uninitialized
3 | println!("The value of num is: {}",num);
| ^^^ `num` used here but it isn't initialized
|
Безбедност меморије у време компилације
Rust обезбеђује сигурност меморије у време компилације. Погледајмо једноставан пример. Овде, иако условна наредба `if` има логичку вредност `true`, што значи да ће вредност `num` увек бити 100, добијамо грешку када покушамо да одштампамо вредност `num`.
fn main() {
let num:i32;
if true{
num = 100;
}
println!("The value of num is: {}", num);
}
То је зато што се условна евалуација дешава у време извршавања, а компајлер не може гарантовати да `num` има вредност у време компилације.
error[E0381]: used binding `num` is possibly-uninitialized
--> src/main.rs:6:41
|
2 | let num:i32;
| --- binding declared here but left uninitialized
3 | if true{
| ---- if this `if` condition is `false`, `num` is not initialized
4 | num = 100;
5 | }
| - an `else` arm might be missing here, initializing `num`
6 | println!("The value of num is: {}", num);
| ^^^ `num` used here but it is possibly-uninitialized
Ако боље погледате поруку о грешци, видећете да са наредбом `else`, можемо осигурати да ће `num` имати вредност. Дакле, следећи код ће радити без грешака. Јер на тај начин компајлер може да утврди да ће `num` имати вредност – у време компилације – и нема грешака.
fn main() {
let num:i32;
if true{
num = 100;
}
else{
num = 50;
}
println!("The value of num is: {}", num);
}
The value of num is: 100
Непроменљивост променљивих
Такође је важно напоменути да су променљиве у Rust-у подразумевано непроменљиве. То значи да као програмер не морате да бринете да ћете случајно преписати вредност одређене променљиве. Ево примера:
fn main() {
let num1 = 10;
num1 = 5;
println!("The value of num1 is: {}", num1);
}
Пошто је `num1` иницијализован на 10, када покушате да му доделите вредност 5, добијате поруку о грешци која гласи „не може се два пута доделити непроменљивој променљивој `num1`“.
error[E0384]: cannot assign twice to immutable variable `num1`
--> src/main.rs:3:5
|
2 | let num1 = 10;
| ----
| |
| first assignment to `num1`
| help: consider making this binding mutable: `mut num1`
3 | num1 = 5;
| ^^^^^^^^ cannot assign twice to immutable variable
Власништво и позајмљивање
Власништво осигурава безбедност меморије. Функционално, власништво у Rust-у се може сумирати на следећи начин:
Сваки објекат треба да има једног и само једног власника. Када власник изађе из опсега, објекат се уништава.
Узмимо једноставан пример. Овде иницијализујемо стринг `str1` и затим премештамо његову вредност у `str2`. Пошто сваки објекат може имати само једног власника, објекат `str1` се уништава чим се његова вредност премести у `str2`.
fn main() {
let str1 = String::from("Rust");
let str2 = str1;
println!("The value of str1 is: {}", str1);
}
error[E0382]: borrow of moved value: `str1`
--> src/main.rs:4:42
|
2 | let str1 = String::from("Rust");
| ---- move occurs because `str1` has type `String`, which does not implement the `Copy` trait
3 | let str2 = str1;
| ---- value moved here
4 | println!("The value of str1 is: {}", str1);
| ^^^^ value borrowed here after move
Иако ово делује интуитивно, за боље разумевање и цењење начина на који власништво функционише, корисно је научити концепте позајмљивања и референци.
Брз развој
До сада смо размотрили неколико корисних карактеристика програмског језика Rust. Да резимирамо:
- Rust је оптимизован и за брзину и за безбедност.
- Има уграђен алат за управљање пакетима и систем за прављење.
- Такође има богату стандардну библиотеку.
У суштини, Rust нуди све што је потребно једном програмеру. Дакле, са Rust-ом, можете брзо развијати апликације са минималним отклањањем грешака и бржим израдама.
Развој на више платформи
Са Rust-ом можете бирати да развијате на платформи по вашем избору. Rust подржава најчешће платформе: Linux, macOS и Windows.
Развој апликација је генерално једноставан, јер можете компајлирати Rust изворни код у извршну датотеку без зависности од других алата за прављење и спољних компајлера.
Заједница која пружа подршку значајно олакшава ваш пут учења. Rust има огромну корисничку базу која из године у годину расте.
Популарност Rust-а у анкети за програмере StackOverflow указује на то да постоји велика заједница корисника, са бројним искусним програмерима који су спремни да поделе своје знање и стручност.
Поред званичне документације, постоји и сајт за документацију коју креирају корисници, као и форум за дискусију. Такође можете проверити Rust subreddits и LinkedIn групе за релевантне дискусије.
Ресурси за учење за почетак са Rust-ом
У овом одељку ћемо навести неколико корисних ресурса који ће вам помоћи да почнете са Rust-ом. Ово није потпуна листа, али укључује неке препоручене туторијале, курсеве и књиге које ће вам помоћи на вашем путу учења.
#1. Rust By Example
Rust By Example ће вас научити Rust основама и стандардним библиотекама кроз низ примера које можете да кодирате у онлајн уређивачу.
Теме које се обрађују укључују crates, Cargo (алат за управљање пакетима у Rust-у), генерике, особине, руковање грешкама и још много тога.
#2. Rustlings
Rustlings је још један званични ресурс за учење програмског језика Rust. Сличан је Rust By Example. Међутим, морате подесити локално развојно окружење, клонирати пример репо-а и решавати једноставне проблеме како бисте научили концепте.
#3. Exercism Rust Track
Rust Track на Exercism-у има преко 100 вежби које ће вам помоћи да научите и тестирате своје разумевање Rust-а. Exercism је бесплатна платформа где можете добити менторство од искусних програмера, поред проласка кроз вежбе.
#4. Ultimate Rust Crash Course
Ultimate Rust Crash Course, који држи Натхан Стоцкс на Udemy-у, покрива следеће:
- Основе Rust програмирања
- Систем модула у Rust-у
- Типове података и ток контроле
- Референце и позајмљивање
- Структуре, особине и колекције
#5. Ultimate Rust 2: Intermediate Concepts
Ultimate Rust 2 је наставак курса Ultimate Rust Crash Course и покрива следеће теме:
- Затварања
- Итераторе
- Руковање грешкама
- Јединичне и интеграционе тестове
- Логирање, вишенитни рад и канале
#6. Rust lang: Комплетан водич за почетнике 2023
Овај Udemy курс, који предаје Каталин Стефан, је свеобухватан курс о Rust програмирању. Неке од тема које се обрађују укључују:
- Основе Rust-а
- Типове података, контролне структуре
- Функције, особине
- Управљање меморијом
- Конкурентност
#7. Programming Rust: Fast, Safe Systems Development
Programming Rust, од издавача O’Reilly, је популарна књига о Rust програмирању која ће вас научити следеће:
- Основне типове података
- Власништво и позајмљивање
- Асинхроно програмирање
- Брзе апликације са више нити
- Затварања, итераторе
- Колекције
#8. Програмски језик Rust, 2. издање
Програмски језик Rust је написан од стране познатих сарадника Rust заједнице. Ова књига покрива све што треба да знате о Rust-у, укључујући:
- Власништво и позајмљивање
- Генерике, особине
- Паметне показиваче, вишенитни рад
- Тестирање и руковање грешкама
#9. Комплетан референтни водич за програмирање Rust
Комплетан референтни водич за програмирање Rust, од издавача Packt, покрива следеће:
- Имплементацију структура података у Rust-у
- Писање компоненти за вишекратну употребу и тестирање у Rust-у
- Дизајнирање алгоритама за апликације са више нити
- Примене Rust-а у WebAssembly-u, умрежавању и апликацијама командне линије
#10. Креативни пројекти за Rust програмере
Ако сте искусан програмер који учи Rust, онда ће израда неколико пројеката у вашем интересу бити довољна да стекнете солидно разумевање језика. Креативни пројекти за Rust програмере од Packt-а је књига која учи Rust кроз примену на пројекте као што су:
- Изградња RESTful веб сервиса
- 2D игре са
- Развој веб апликација помоћу WebAssembly-a
- Емулатори машинског језика
- и још!
Закључак
Овај чланак је представио преглед Rust-а као системског програмског језика, укључујући карактеристике као што су безбедност меморије, побољшано управљање пакетима и још много тога. Такође смо навели ресурсе за учење који ће вам помоћи да почнете да користите Rust.
Као следећи корак, можете одабрати један или више наведених ресурса за учење, како бисте савладали основе Rust-а. Срећно у Rust програмирању!
Такође можете истражити неке од најбољих Rust сервер хостинг провајдера.