Вие сте разработчик, който иска да научи Rust? За да ви помогне да решите, тази статия представя някои от функциите на Rust, един от най-популярните езици за системно програмиране.
В тази статия ще разгледаме езика за програмиране Rust и неговите характеристики, като система от типове, безопасност на паметта и собственост. Ще разгледаме и списък с ресурси, които могат да ви помогнат да научите Rust.
Нека да започнем!
Съдържание
Какво е ръжда?
Rust е език за системно програмиране. Започна като личен проект на Graydon Hoare, разработчик, през 2006 г. За по-малко от десетилетие се превърна в предпочитан избор за системно програмиране и свързани приложения. Средната заплата на Rust програмист е около $120K.
Така че, ако искате да преминете от C++ към Rust или търсите да изберете нов език, изучаването на Rust може да бъде чудесен избор! Според проучването на StackOverflow Developer, Rust е избран за най-обичания език за програмиране – за седем поредни години.
Източник на изображението: StackOverflow
Rust предлага скоростта на езиците за програмиране на системи от ниско ниво като C и C++ и безопасността на езиците за програмиране на високо ниво като Python.
От забележителни проекти като Dropbox и Firefox до WebAssembly и вградено програмиране, Rust се използва широко във всички области на разработката на софтуер. Rust предлага поддръжка за управление на пакети извън кутията чрез Cargo.
Cargo: Мениджърът на пакети за Rust
Cargo е пакетният мениджър за Rust. Можете да използвате cargo за инсталиране на пакети от каси, регистъра на пакетите Rust. В допълнение към това да бъде мениджър на пакети, който ви позволява да търсите, инсталирате и управлявате пакети, cargo служи и като тестов инструмент, генератор на документи и система за изграждане.
Сега, след като имате общ преглед на Rust, нека разгледаме по-отблизо някои от характеристиките на Rust, които го отличават като език за системно програмиране с широко разпространение.
Полезни съобщения за грешка
Като начинаещ програмист ще се сблъскате с грешки и ще отделите значително време за отстраняване на грешки във вашия код. Ще използвате съобщенията за грешки и предупрежденията, предоставени от компилатора, за да коригирате тези проблеми. А полезните съобщения могат да ви помогнат да отстраните грешки по-бързо.
Примерно съобщение за грешка
Когато вашият код не се компилира успешно, 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 е цяло число – а не булево.
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;
}
}
Грешката съобщава за несъответствие на типа, където се очаква булево и е намерено цяло число.
error[E0308]: mismatched types
--> src/main.rs:3:8
|
3 | if num1{
| ^^^^ expected `bool`, found integer
Безопасност на паметта
Безопасността на паметта е друга характеристика на Rust, която го прави привлекателен за програмистите. Ще се опитаме да предоставим бегъл преглед на това как работи това.
Променливите трябва да бъдат инициализирани, преди да бъдат използвани
В 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, ще попаднете на грешка по време на компилиране. Следователно Руст няма представа за събиране на боклука.
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 subreddit и LinkedIn за подходящи дискусии.
Ресурси за обучение, за да започнете с Rust
Този раздел изброява няколко полезни ресурса, които да ви помогнат да започнете с Rust. Това не е изчерпателен списък, но включва някои препоръчани уроци, курсове и книги, които да ви помогнат в обучението ви.
#1. Ръжда по пример
Rust By Example ще ви научи на основите на Rust и стандартните библиотеки чрез поредица от примери, които можете да кодирате заедно в онлайн редактор.
Обхванатите теми включват каси, товари: инструментът за управление на пакети за Rust, генерични продукти, характеристики, обработка на грешки и много други.
#2. шумолене
Rustlings е друг официален учебен ресурс за езика за програмиране Rust. Подобно е на Rust като пример. Това обаче изисква да настроите вашата локална среда за разработка, да клонирате примерен репо и да решите прости проблеми, за да научите тези концепции.
#3. Писта за упражнения Rust Track
Rust Track on Exercism има повече от 100 упражнения, които да ви помогнат да научите и тествате разбирането си за Rust. Exercism е безплатна платформа, където можете да бъдете наставлявани от опитни програмисти в допълнение към кодирането на пътя си през упражненията.
#4. Ultimate Rust Crash Course
The Ultimate Rust Crash Course, преподаван от Nathan Stocks в Udemy, обхваща следното:
- Основи на програмирането на Rust
- Модулна система в Rust
- Типове данни и контролен поток
- Справка и заемане
- Структури, характеристики и колекции
#5. Ultimate Rust 2: Междинни концепции
Ultimate Rust 2 е продължение на курса Ultimate Rust Crash Course и обхваща следните теми:
- Затваряния
- Итератори
- Обработка на грешки
- Единичен и интеграционен тест
- Регистриране, многопоточност и канали
#6. Rust lang: Пълното ръководство за начинаещи 2023 г
Този курс по Udemy, преподаван от Каталин Стефан, е изчерпателен курс по програмиране на Rust. Някои от обхванатите теми включват:
- Основи на Rust
- Типове данни, управляващи структури
- Функции, черти
- Управление на паметта
- Паралелност
#7. Програмиране на Rust: Бързо, безопасно разработване на системи
Програмиране на Rust от O’Reilly е популярна книга за програмиране на Rust, която ще ви научи на следното:
- Основни типове данни
- Собственост и заеми
- Асинхронно програмиране
- Бързи многопоточни приложения
- Затваряния, итератори
- Колекции
#8. Езикът за програмиране Rust, 2-ро издание
Езикът за програмиране Rust е създаден от известни сътрудници на общността Rust. Тази книга обхваща всичко, което трябва да знаете за Rust, включително:
- Собственост и заеми
- Генерики, черти
- Интелигентни указатели, многопоточност
- Тестване и обработка на грешки
#9. Пълното справочно ръководство за програмиране на Rust
Пълното справочно ръководство за програмиране на Rust от Packt обхваща следното:
- Внедряване на структури от данни в Rust
- Писане на повторно използвани и тествани компоненти в Rust
- Проектиране на многонишкови приложения дизайн на алгоритъм и
- Приложения на Rust в приложения за WebAssembly, мрежи и команден ред
#10. Творчески проекти за Rust програмисти
Ако сте опитен разработчик, изучаващ Rust, тогава изграждането на няколко проекта в областта, която ви интересува, ще бъде достатъчно, за да придобиете добро разбиране на езика. Creative Projects for Rust Programmers от Packt е книга, която учи Rust, като ги прилага към проекти като:
- Изграждане на Restful уеб услуги
- 2D игри с
- Разработка на уеб приложения с помощта на WebAssembly
- Емулатори на машинен език
- и още!
Заключение
Тази статия представя общ преглед на Rust като език за системно програмиране, включително функции като безопасност на паметта, подобрено управление на пакети и др. Ние също изброихме ресурси за обучение, за да ви помогнем да започнете да работите с Rust.
Като следваща стъпка можете да изберете един или повече от споменатите учебни ресурси, за да научите основите на Rust. Честито програмиране на Rust!
Можете също така да разгледате някои от най-добрите доставчици на хостинг сървъри на Rust.