Урок за ръжда: Започнете с езика Rust

През последните няколко години Ръст премина от любопитство, създадено в лабораторията на служител на Mozilla, до силен претендент за писането на следващото поколение местни приложения и голи метални решения. Но този напредък идва от Rust, предоставяйки собствена система за управление на вериги от инструменти и компоненти - заедно със свои собствени функции и странности.

Тази статия разглежда основите на създаването на работна среда в Rust, конфигурирането на IDE и максималното използване на набора от инструменти, който Rust предоставя за разработка на приложения.

Свързано видео: Разработване на по-безопасен софтуер с Rust

Бързо ускорявайте новия Rust, създаден да създава бърз софтуер на системно ниво. Този двуминутен анимиран обяснител показва как Rust заобикаля досадни проблеми с програмирането на паметта и управлението.

Разберете Rust нощни, бета и стабилни версии

Веригата от инструменти на Rust се състои предимно от компилатора Rust rustc, заедно с инструменти за управление на Rust инсталация. Тъй като Rust е в непрекъснато развитие, веригата инструменти Rust е проектирана да бъде лесна за актуализиране.

Софтуерните проекти често се предоставят по множество канали, за да се разделят стабилната и бета версиите на кода. Веригата от инструменти на Rust работи по същия начин, предлагайки три канала за своята верига от инструменти:

  • Стабилен: Основни точки, които се появяват на всеки шест седмици или така.
  • Бета: Кандидати за следващото голямо издание, което се появява по-често.
  • Nightly: Най-непосредствената конструкция, с достъп до авангардни функции, но без гаранции за тяхната стабилност.

Както посочи разработчикът Карол Кучмарски, най-добре е да мислите за нощния канал Rust като за свой собствен език. Някои функции на Rust, като компилиране на WebAssembly, са достъпни само в нощния канал и могат да бъдат активирани само чрез специални директиви на компилатора. С други думи, те дори няма да се компилират в бета или стабилни канали. 

Това е по дизайн, защото няма гаранция, че нощните функции ще се поддържат никъде другаде. Много от тези функции обаче в крайна сметка излизат от нощния канал и стават бета и стабилни версии. (Например компилирането в WebAssembly работи стабилно от Rust 1.30.)

Накратко:

  1. Използвайте стабилен за действителна производствена работа.
  2. Използвайте бета версия, за да тествате текущия софтуер спрямо предстоящите версии, за да видите дали нещо може да се счупи при надстройката.
  3. Използвайте само всяка вечер за експерименти с пясък с най-новите функции на Rust.

Изберете операционна система за разработка на Rust

Rust поддържа и трите основни платформи - Windows, Linux и MacOS - както в 32-, така и в 64-битови превъплъщения, с официални двоични файлове за всяка. Множество други платформи също имат официални двоични файлове, но те нямат същото ниво на покритие на автоматизираното тестване. Тези второкласни платформи включват ARMv6 и ARMv7 за iOS, Android и Linux; MIPS Linux и MIPS64 Linux; 32-битови издания на x86 iOS, Windows и Linux; и WebAssembly. Други платформи, като Windows XP или експерименталната HaikuOS, се поддържат чрез неофициални компилации.

Екипът на Rust за разработка заяви, че не е една от мисиите на Rust да бъде възможно най-широко преносим. Например, въпреки че Rust се предлага в много ARM архитектури, не е гарантирано, че Rust ще бъде официално поддържан на хардуерни платформи от нисък клас.

Въпреки това трябва да има поддържана Rust компилация, достъпна за по-голямата част от обичайните случаи на масово използване - а именно 32- и 64-битовите Windows, Linux и MacOS.

Ако планирате да разработвате Rust под Windows, имайте предвид веригите от инструменти. Rust поддържа две вериги от инструменти на Windows:

  • Родният Microsoft Visual C (MSVC) ABI
  • Gnu ABI, използван от GCC линкера.

Тъй като почти целият C / C ++ софтуер, вграден в Windows, така или иначе използва MSVC, вие ще искате да използвате веригата от инструменти MSVC в по-голямата част от времето. Ако някога се нуждаете от GCC, най-вероятно ще бъде за взаимодействие с библиотеки на трети страни, вградени в Windows с GCC.

Добрата новина е, че системата за управление на веригите инструменти на Rust ви позволява да поддържате инсталирани вериги от инструменти MSVC и GCC и ви позволява да превключвате между тях за всеки отделен проект.

Една от целите за компилация на Rust е WebAssembly, което означава, че можете да пишете в Rust и да се разположите в уеб браузър. WebAssembly все още е груб по краищата, както и поддръжката на Rust за него. Но ако сте амбициозни и искате да объркате ръцете си, прочетете книгата, съставена от разработчиците на Rust и WebAssembly, която описва подробно процеса за компилиране на WebAssembly в Rust. Книгата включва урок за прост проект, изпълнение на Играта на живота на Конуей, написан на Rust и разположен като WebAssembly.

Започнете настройката на Rust с rustup

Rust предлага цялостна инсталационна инсталация и система за поддръжка на веригата инструменти, наречена rustup. Изтеглете rustupи стартирайте; ще получи най-новите версии на веригата инструменти Rust и ще ги инсталира вместо вас.

Най-критичните инструменти, поддържани от rustup:

  • rustupсебе си. Всеки път, когато rustupсе публикуват нови версии на или други инструменти, можете просто да стартирате rustup updateи всичко да се актуализира автоматично.
  • rustc, компилаторът Rust.
  • Карго, мениджър на пакети на Rust и работно пространство.

По подразбиране rustupинсталира Rust от стабилния канал. Ако искате да използвате бета или нощни версии, трябва да инсталирате тези канали (например  rustup install nightly) и да зададете Rust да ги използва по подразбиране ( rustup default nightly). Можете също така ръчно да посочите кой канал да използвате, когато компилирате приложение Rust, така че не е нужно да задавате и нулирате настройката по подразбиране всеки път, когато се движите между проекти.

Можете също да използвате  rustup за инсталиране и поддържане на персонализирани вериги от инструменти. Те обикновено се използват от неофициални компилации на Rust на трети страни за неподдържани платформи, тъй като те обикновено изискват собствени линкери или други специфични за платформата инструменти.

Конфигурирайте вашата IDE за Rust

Въпреки че Rust е сравнително нов език, той вече получи силна подкрепа от много често срещани IDE. Разработчикът Мануел Хофман поддържа проект за проследяване на състоянието на такава подкрепа на уебсайта areweideyet.com.

Успешната работа на Rust с IDE е изрична цел на екипа му за разработка чрез функция, наречена Rust Language Server (RLS). RLS предоставя обратна връзка на живо за въпросния код от собствения компилатор на Rust, а не от парсер на трета страна.

Ето IDE, които поддържат Rust:

  • Кодът на Visual Studio на Microsoft има разширение за поддръжка на език Rust, създадено от екипа на собствените разработчици на Rust. Това ниво на интеграция го прави една от най-добре поддържаните IDE за Rust. 
  • Потребителите на Eclipse могат да изтеглят предварително опаковано издание на Eclipse за разработка на ръжда или да използват самостоятелната приставка за корозия за Eclipse Photon. (По-ранен пакет, RustDT, вече не се поддържа.)
  • Ако сте фен на Emacs или Vim, други разработчици като вас са написали специфични за Rust добавки и за двата редактора. Emacs има специфичен за Rust режим, а Vim има плъгин за осигуряване на подчертаване на синтаксиса и форматиране. Поддръжката на RLS е налична както за Emacs, така и за Vim, но трябва да бъде добавена и конфигурирана ръчно.
  • Потребителите на IntelliJ Idea и Atom могат да добавят приставки, за да закръглят поддръжката на Rust.
  • Sublime Text има поддръжка на Rust синтаксис от кутията, а приставките осигуряват по-задълбочена поддръжка за други функции.
  • Проект за създаване на проста IDE, специално за Rust, SolidOak, беше в процес на разработка за известно време, но оттогава спря. Най-добре е да изберете една от съществуващите IDE, която вече има поддръжка.

Създайте първия си проект Rust

Проектите за ръжда са предназначени да имат последователна структура на директорията, като в тях се съхраняват код и метаданни за проекти по определени начини. Кодът се съхранява в srcподдиректория, а подробностите за проекта се съхраняват в два файла в основната директория  Cargo.tomlна проекта (основната информация за проекта) и Cargo.lock(автоматично генериран списък с зависимости). Можете да създадете тази структура на директорията и метаданните на ръка, но е по-лесно просто да използвате собствените инструменти на Rust, за да си свършите работата.

Съвет:  Онлайн ръководството за изучаване на Rust чрез пример за ръжда предоставя интерактивни примерни кодове, които могат да се редактират и стартират директно в браузъра. Той засяга почти всяка основна концепция за ръжда, въпреки че някои от по-ключовите понятия, като заемане и продължителност на живота, са въведени относително късно в дискусията.

Инструментът Rust's Cargo управлява както проектите на Rust, така и библиотеките или „каси“, които те използват. За да завъртите нов проект Rust с име my_projectв собствената си директория, напишете cargo new my_project. (За разработчиците на C #, работещи с .Net Core, помислете за dotnet newкомандата.) Новият проект се появява в поддиректория с това име, заедно с основен манифест на проекта - Cargo.tomlфайлът и заглушител за изходния код на проекта, в srcподдиректория.

Когато създавате нов проект,  main.rsавтоматично се създава файл в srcдиректорията на проекта. Този файл съдържа основно приложение „здравей, свят“, така че можете веднага да тествате вашата верига с инструменти Rust, като го компилирате и стартирате.

Изходният код за приложението „здравей, свят“:

fn main() {

    println!(“Hello World!”);

}

За да го изградите и стартирате, въведете корена на директорията на проекта и въведете cargo run. Имайте предвид, че по подразбиране Cargo изгражда проекти в режим за отстраняване на грешки. За да стартирате в режим на освобождаване, използвайте cargo run --release. Двоичните файлове се изграждат в target/debugили target/releaseподдиректорията на проект, в зависимост от това кой профил на компилация използвате.

Работете с каси с ръжда

Управлението на пакети е ключова част от всяка съвременна програмна среда. За тази цел Rust предоставя „щайги“, които са библиотеки на трети страни, пакетирани за разпространение с инструментите на Rust. Можете да намерите щайги в официалния регистър на пакета Rust, Crates.io.

Ако вашият проект има зависимост от конкретна щайга, трябва да я посочите, като редактирате Cargo.tomlфайла на проекта . Стандартният начин да направите това е ръчно - т.е. чрез просто редактиране Cargo.tomlдиректно с текстов редактор. Следващият път, когато проектът бъде възстановен, Rust автоматично получава всички необходими зависимости.

Съвет: Два инструмента cargo-editи cargo-edit-locallyмогат да актуализират зависимости от командния ред, въпреки че са неофициални проекти на трети страни.

Когато изграждате проект за ръжда, който зависи от външни щайги, Cargo по подразбиране ги търси в Crates.io; не е необходимо да ги получавате ръчно. Можете също така да се позовавате на каси в проекта си по URL, а не по име на щайгата, в случай че имате нужда от щайга, която не се хоства в системния регистър, като например нещо от частно хранилище.

Имайте предвид, че някои щайги ще инсталират и надграждат само нощния канал на Rust, защото използват експериментални функции, които не са налични в други канали. Ако сте на освобождаващия канал и се опитате да инсталирате такава щайга, няма да получите никакво предупреждение, докато самата компилация не успее. В документацията за каси обикновено се споменава дали изисква нощния канал или не, така че прочетете, преди да включите, камо ли да компилирате.

Касите могат да се доставят с включени двоични файлове. Някои от тях са инструменти на командния ред, използвани при разработката на Rust; други са инструменти с общо предназначение (като  ripgrep). За да инсталирате един от тези щайги, просто напишете cargo install . Това не е единственият начин за разпространение на двоичен файл, създаден с Rust, но е удобен начин за разработчиците на Rust да ги получат като част от работен поток, включващ Rust инструменти.

Кръстосано компилиране на Rust на друга платформа

Тъй като Rust поддържа множество вериги от инструменти, дори при една и съща инсталация на Rust, можете да компилирате Rust приложения в целевата операционна система и среда, която е различна от тази, на която компилирате.

Такова кръстосано компилиране изисква верига от инструменти на платформата, върху която работите, която да съответства на целевата платформа. Понякога, както при кръстосаното компилиране с Linux на Windows или обратно, това включва малко повече от наличието на GCC линкер. Но друг път е по-сложно. Например за кръстосано компилиране в MacOS са ви необходими Xcode IDE библиотеки, за да завършите работата - cctools (еквивалент на Apple на binutils) и MacOS SDK.

Инструментите на трети страни предлагат някои начини за заобикаляне на тези трудности:

  • Един такъв инструмент е Trust, шаблон на Travis CI и AppVeyor, който може автоматично да публикува двоични версии на проект Rust. Той може да бъде създаден за Linux, Windows и MacOS, въпреки че изисква използването на услугите Travis CI и AppVeyor и изисква вашият проект да бъде хостван на GitHub.
  • Друг проект, Cross, се изпълнява директно на 64-битов x86 Linux хост, но предоставя това, което създателят му описва като „нулева настройка“ за кръстосано компилиране на голямо разнообразие от цели, включително 64-битов Windows и MIPS.
  • Проектът crossbuild осигурява мулти-архитектурно изображение на Docker, което може да се използва за кръстосано изграждане между трите основни платформи.