Programmering

Rust tutorial: Kom godt i gang med Rust-sproget

I løbet af de sidste par år er Rust gået fra en nysgerrighed brygget op i en Mozilla-medarbejders laboratorium til en stærk konkurrent til at skrive den næste generation af native apps og bare-metal-løsninger. Men disse fremskridt kommer fra Rust, der leverer sit eget værktøjskæde og komponentstyringssystem - sammen med sine egne funktioner og særheder.

Denne artikel gennemgår det grundlæggende ved at oprette et arbejdsmiljø i Rust, konfigurere en IDE og få mest muligt ud af det værktøjssæt, Rust giver appudvikling.

Relateret video: Udvikling af sikrere software med Rust

Kom hurtigt i gang med nybegynder Rust, der er designet til at oprette hurtig software på systemniveau. Denne animerede forklarer på to minutter viser, hvordan Rust omgår de irriterende programmeringsproblemer med hukommelse og styring.

Forstå Rust udgivelser om natten, beta og stabile

Rust's værktøjskæde består primært af Rust-kompilatoren, rustcsammen med værktøjer til styring af en rustinstallation. Da Rust er under konstant udvikling, er Rust-værktøjskæden designet til at være let at holde sig ajour.

Softwareprojekter leveres ofte via flere kanaler for at adskille de stabile og betaversioner af koden. Rust's værktøjskæde fungerer på samme måde og tilbyder tre kanaler til sin værktøjskæde:

  • Stabil: Større pointudgivelser, der dukker op hver sjette uge eller deromkring.
  • Beta: Kandidater til den næste store pointudgivelse, som dukker op oftere.
  • Natlig: Den mest øjeblikkelige bygning med adgang til banebrydende funktioner, men ingen garantier for deres stabilitet.

Som udvikleren Karol Kuczmarski har påpeget, er det bedst at tænke på den natlige Rust-kanal som sit eget sprog. Nogle rustfunktioner, såsom kompilering til WebAssembly, er kun tilgængelige i den natlige kanal, og de kan kun aktiveres af specielle kompilatordirektiver. Med andre ord kompilerer de ikke engang på beta- eller stabile kanaler.

Det er efter design, fordi der ikke er nogen garanti for, at nattlige funktioner understøttes andre steder. Imidlertid gradueres mange af disse funktioner til sidst ud af den natlige kanal og til beta- og stabile udgivelser. (Kompilering til WebAssembly fungerer for eksempel i stabil fra Rust 1.30.)

Kort sagt:

  1. Brug stabil til faktisk produktionsarbejde.
  2. Brug beta for at teste nuværende software mod kommende versioner for at se, om noget kan gå i stykker i opgraderingen.
  3. Brug kun om natten til sandkasseeksperimenter med Rust's nyeste funktioner.

Vælg et operativsystem til udvikling af rust

Rust understøtter alle tre store platforme - Windows, Linux og MacOS - i både 32- og 64-bit inkarnationer med officielle binære filer til hver. En række andre platforme har også officielle binære filer, men de har ikke det samme niveau af automatiseret testdækning. Disse andenklasses platforme inkluderer ARMv6 og ARMv7 til iOS, Android og Linux; MIPS Linux og MIPS64 Linux; 32-bit udgaver af x86 iOS, Windows og Linux; og WebAssembly. Andre platforme, som Windows XP eller det eksperimentelle HaikuOS, understøttes gennem uofficielle builds.

Rusts udviklingsteam har udtalt, at det ikke er en af ​​Rusts missioner at være så bredt bærbare som muligt. For eksempel, selvom Rust er tilgængelig på mange ARM-arkitekturer, er det ikke garanteret, at Rust bliver officielt understøttet på low-end hardwareplatforme.

Når det er sagt, skal der være en understøttet Rust-build tilgængelig for langt de fleste almindelige almindelige brugssager - nemlig 32- og 64-bit Windows, Linux og MacOS.

Hvis du planlægger at udvikle dig i Rust på Windows, skal du huske dine værktøjskæder. Rust understøtter to værktøjskæder på Windows:

  • Den oprindelige Microsoft Visual C (MSVC) ABI
  • Gnu ABI brugt af GCC linker.

Fordi næsten al C / C ++ -software, der er indbygget i Windows, bruger MSVC alligevel, vil du gerne bruge MSVC-værktøjskæden langt de fleste af tiden. Hvis du nogensinde har brug for GCC, vil det højst sandsynligt være til interoperation med tredjepartsbiblioteker, der er indbygget i Windows med GCC.

Den gode nyhed er, at Rusts værktøjskædestyringssystem lader dig beholde begge MSVC og GCC-værktøjskæder er installeret, og det giver dig mulighed for at skifte mellem dem på projekt-for-projekt-basis.

Et af Rusts kompileringsmål er WebAssembly, hvilket betyder at du kan skrive i Rust og implementere i en webbrowser. WebAssemblage i sig selv er stadig ru rundt om kanterne, og det samme gælder Rusts støtte til det. Men hvis du er ambitiøs og vil have rod i hænderne, skal du læse bogen udarbejdet af Rust og WebAssembly-udviklere, der beskriver processen til kompilering af WebAssembly til Rust. Bogen indeholder en tutorial til et simpelt projekt, en implementering af Conways Game of Life, skrevet i Rust og implementeret som WebAssembly.

Start din Rust-opsætning med rustup

Rust leverer et alt-i-en installatør og vedligeholdelsessystem til værktøjskæde kaldet rustup. Hent rustup og kør det; det får de nyeste versioner af Rust-værktøjskæden og installerer dem for dig.

De mest kritiske værktøjer vedligeholdt af rustup er:

  • rustup sig selv. Hver gang nye versioner af rustup eller andre værktøjer er offentliggjort, kan du bare køre rustup opdatering og få alt opdateret automatisk.
  • rustc, Rust-kompilatoren.
  • Cargo, Rust's pakke- og arbejdsområdeadministrator.

Som standard, rustup installerer Rust fra den stabile kanal. Hvis du vil bruge beta- eller natversioner, skal du installere disse kanaler (f.eks.rustup installere om natten), og indstil Rust til at bruge dem som standard (rustup standard om natten). Du kan også manuelt angive, hvilken kanal der skal bruges, når du kompilerer en Rust-applikation, så du ikke behøver at indstille og nulstille standardværdien, hver gang du bevæger dig mellem projekter.

Du kan også brugerustup at installere og vedligeholde brugerdefinerede værktøjskæder. Disse bruges typisk af uofficielle tredjepartsbygninger af Rust til ikke-understøttede platforme, fordi de typisk kræver deres egne linkere eller andre platformsspecifikke værktøjer.

Konfigurer din IDE til rust

På trods af at Rust er et relativt nyt sprog, har det allerede fået stærk støtte fra mange almindelige IDE'er. Udvikler Manuel Hoffman opretholder et projekt til at spore tilstanden af ​​sådan support på webstedet areweideyet.com.

At få Rust til at fungere godt med IDE'er er et udtrykkeligt mål for dets udviklingsteam via en funktion kaldet Rust Language Server (RLS). RLS giver live feedback om den pågældende kode fra Rust's egen compiler snarere end fra en tredjeparts parser.

Her er de IDE'er, der understøtter Rust:

  • Microsofts Visual Studio Code har en Rust-sprogudvidelse, der er oprettet af Rusts eget udviklerværktøjsteam. Dette integrationsniveau gør det til et af de bedst understøttede IDE'er for Rust.
  • Eclipse-brugere kan downloade en færdigpakket udgave af Eclipse for Rust-udvikling eller bruge det uafhængige Corrosion-plugin til Eclipse Photon. (En tidligere pakke, RustDT, vedligeholdes ikke længere.)
  • Hvis du er fan af Emacs eller Vim, har andre udviklere som dig skrevet Rust-specifikke tilføjelser til begge redaktører. Emacs har en rustspecifik tilstand, og Vim har et plugin, der giver syntaksfremhævning og formatering. RLS-support er tilgængelig for både Emacs og Vim, men den skal tilføjes og konfigureres manuelt.
  • IntelliJ Idea og Atom-brugere kan tilføje plugins for at afrunde Rust-support.
  • Sublime Text har Rust-syntaks-support ud af kassen, og plugins giver dybere support til andre funktioner.
  • Et projekt til at skabe en simpel IDE specielt til Rust, SolidOak, var under udvikling i en periode, men er siden gået i stå. Dit bedste valg er at gå med en af ​​de eksisterende IDE'er, der allerede har support.

Opret dit første Rust-projekt

Rustprojekter er beregnet til at have en konsistent bibliotekstruktur med kode og projektmetadata gemt inden for dem på bestemte måder. Koden er gemt i en src underkatalog, og detaljer om projektet gemmes i to filer i projektets rodmappe,Cargo.toml (projektets grundlæggende information) og Cargo.lock (en automatisk genereret liste over afhængigheder). Du kan oprette denne katalogstruktur og metadata i hånden, men det er lettere bare at bruge Rust egne værktøjer til at udføre jobbet.

Tip:Rust By Example online-guide til læring af Rust giver interaktive kodeeksempler, der kan redigeres og køres direkte i browseren. Det berører næsten ethvert større Rust-koncept, selvom nogle af de mere nøglebegreber som låntagning og levetid introduceres relativt sent i diskussionen.

Rust's Cargo-værktøj håndterer både Rust-projekter og bibliotekerne eller "kasser", de bruger. At spinde et nyt Rust-projekt med navnet mit_projekt skriv i sin egen mappe fragt nyt my_project. (For C # -udviklere, der arbejder med .Net Core, skal du tænke på dotnet nyt kommando.) Det nye projekt vises i en underkatalog med dette navn sammen med et grundlæggende projektmanifest - the Cargo.toml fil - og en stub til projektets kildekode i en src underkatalog.

Når du opretter et nyt projekt, amain.rs fil oprettes automatisk i src projektmappe. Denne fil indeholder en grundlæggende "hej verden" -app, så du kan teste din Rust-værktøjskæde med det samme ved at kompilere og køre den.

Kildekoden til appen “hej verden”:

fn main () {

println! (“Hello World!”);

}

For at opbygge og køre det skal du indtaste roden til projektmappen og skrive fragtkørsel. Bemærk, at Cargo som standard bygger projekter i fejlretningstilstand. Brug for at køre i frigivelsestilstand fragtkørsel - frigivelse. Binærfiler er bygget i mål / fejlretning eller mål / frigiv underkatalog for et projekt, afhængigt af hvilken kompilationsprofil du bruger.

Arbejd med rustkasser

Pakkehåndtering er en vigtig del af ethvert moderne programmeringsmiljø. Til dette formål leverer Rust "kasser", som er tredjepartsbiblioteker pakket til distribution med Rust's værktøjer. Du kan finde kasser i det officielle Rust-pakkeregister, Crates.io.

Hvis dit projekt er afhængigt af en bestemt kasse, skal du angive den kasse ved at redigere projektets Cargo.toml fil. Standardmetoden til dette er manuelt - det vil sige ved blot at redigere Cargo.toml direkte med en teksteditor. Næste gang projektet genopbygges, opnår Rust automatisk de nødvendige afhængigheder.

Tip: To værktøjer, lastredigering og fragt-rediger-lokalt, kan opdatere afhængigheder fra kommandolinjen, selvom de er uofficielle tredjepartsprojekter.

Når du bygger et Rust-projekt, der afhænger af eksterne kasser, ser Cargo som standard efter disse kasser på Crates.io; du behøver ikke at skaffe dem manuelt. Du kan også henvise til kasser i dit projekt efter URL i stedet for efter kassenavn, hvis du har brug for en kasse, der ikke er hostet i registreringsdatabasen, såsom noget fra et privat lager.

Bemærk, at nogle kasser vil kun installere og bygge på Rust's natlige kanal, fordi de bruger eksperimentelle funktioner, der ikke er tilgængelige i andre kanaler. Hvis du er på frigivelseskanalen, og du prøver at installere en sådan kasse, får du ingen advarsel, før selve kompileringen mislykkes. Kassedokumentation nævner normalt, om det kræver den natlige kanal eller ej, så læs op, inden du inkluderer, endsige kompilere.

Kasser kan leveres med binære filer inkluderet. Nogle er kommandolinjeværktøjer, der bruges i Rust-udvikling; andre er almindelige værktøjer (f.eksripgrep). For at installere en af ​​disse kasser skal du bare skrive lastinstallation . Dette er ikke det kun måde at distribuere en binær oprettet med Rust, men det er en bekvem måde for Rust-udviklere at få dem som en del af en arbejdsgang, der involverer Rust-værktøjer.

Kryds-kompilér Rust til en anden platform

Da Rust understøtter flere værktøjskæder, selv i den samme installation af Rust, kan du kompilere Rust-applikationer til et mål-OS og miljø, der er forskelligt fra det, du kompilerer om.

Sådan krydskompilering kræver en værktøjskæde på den platform, du arbejder på, der matcher målplatformen. Nogle gange, som med krydskompilering til Linux på Windows eller omvendt, involverer dette lidt mere end at have GCC-linkeren. Men andre gange er det mere komplekst. Til krydskompilering til MacOS har du f.eks. Brug for Xcode IDE-bibliotekerne for at afslutte jobbet - cctools (Apples ækvivalent med binutils) og MacOS SDK.

Tredjepartsværktøjer tilbyder nogle måder omkring disse vanskeligheder:

  • Et sådant værktøj er Trust, en Travis CI- og AppVeyor-skabelon, der automatisk kan offentliggøre binære udgivelser af et Rust-projekt. Det kan bygges til Linux, Windows og MacOS, selvom det kræver brug af Travis CI- og AppVeyor-tjenesterne, og det kræver, at dit projekt er vært på GitHub.
  • Et andet projekt, Cross, kører direkte på en 64-bit x86 Linux-vært, men leverer, hvad dets skaber beskriver som "zero-setup" krydskompilering til en lang række mål, herunder 64-bit Windows og MIPS.
  • Crossbuild-projektet giver et Docker-billede med flere arkitekturer, der kan bruges til at krydse mellem alle tre store platforme.