Rust tutorial: Kom i gang med Rust-språket

I løpet av de siste par årene har Rust gått fra en nysgjerrighet brygget opp i laboratoriet til en Mozilla-ansatt til en sterk konkurrent for å skrive neste generasjon av innfødte apper og bare-metall-løsninger. Men disse fremskrittene kommer fra Rust som tilbyr sitt eget verktøyskjede- og komponentstyringssystem - sammen med sine egne funksjoner og særegenheter.

Denne artikkelen går gjennom det grunnleggende om å sette opp et arbeidsmiljø i Rust, konfigurere en IDE og få mest mulig ut av verktøysettet Rust gir for apputvikling.

Relatert video: Utvikler tryggere programvare med Rust

Kom raskt i gang med nykommer Rust, designet for å lage rask programvare på systemnivå. Denne to-minutters animerte forklareren viser hvordan Rust omgår de plagsomme programmeringsproblemene med minne og ledelse.

Forstå Rust utgivelser hver natt, beta og stabile

Rust sin verktøykjede består hovedsakelig av Rust-kompilatoren, rustc, sammen med verktøy for å administrere en rustinstallasjon. Fordi Rust er under stadig utvikling, er Rust-verktøykjeden designet for å være enkel å holde seg oppdatert.

Programvareprosjekter blir ofte levert via flere kanaler for å skille de stabile og betaversjonene av koden. Rusts verktøykjede fungerer på samme måte og tilbyr tre kanaler for verktøykjeden:

Stabil: Store poengutgivelser, som dukker opp hver sjette uke eller så.
Beta: Kandidater til neste store poengutgivelse, som dukker opp oftere.
Nattlig: Den mest umiddelbare bygningen, med tilgang til banebrytende funksjoner, men ingen garantier for stabiliteten.

Som utvikler Karol Kuczmarski har påpekt, er det best å tenke på den nattlige Rust-kanalen som sitt eget språk. Noen Rust-funksjoner, som kompilering til WebAssembly, er bare tilgjengelig i nattkanalen, og de kan bare aktiveres av spesielle kompilatordirektiv. Med andre ord vil de ikke engang kompilere på beta- eller stabile kanaler.

Det er etter design, fordi det ikke er noen garanti for at nattlige funksjoner støttes noe annet sted. Imidlertid går mange av disse funksjonene til slutt ut av den nattlige kanalen og til beta- og stabile utgivelser. (Kompilering til WebAssembly fungerer for eksempel i stabil fra og med Rust 1.30.)

Kort oppsummert:

Bruk stabil for faktisk produksjonsarbeid.
Bruk beta for å teste nåværende programvare mot kommende versjoner for å se om noe kan ødelegge oppgraderingen.
Bruk bare nattlig for sandkasseeksperimenter med Rusts nyeste funksjoner.

Velg et operativsystem for utvikling av rust

Rust støtter alle de tre store plattformene - Windows, Linux og MacOS - i både 32- og 64-bits inkarnasjoner, med offisielle binærfiler for hver. En rekke andre plattformer har også offisielle binærfiler, men de har ikke samme nivå av automatisert testdekning. Disse andre klassens plattformer inkluderer ARMv6 og ARMv7 for iOS, Android og Linux; MIPS Linux og MIPS64 Linux; 32-biters utgaver av x86 iOS, Windows og Linux; og WebAssembly. Andre plattformer, som Windows XP eller den eksperimentelle HaikuOS, støttes gjennom uoffisielle builds.

Rusts utviklingsteam har uttalt at det ikke er et av Rusts oppdrag å være så bredt bærbar som mulig. For eksempel, selv om Rust er tilgjengelig på mange ARM-arkitekturer, er det ikke garantert at Rust vil bli offisielt støttet på low-end maskinvareplattformer.

Når det er sagt, bør det være en støttet Rust-build tilgjengelig for de aller fleste vanlige, vanlige brukstilfeller - nemlig 32- og 64-biters Windows, Linux og MacOS.

Hvis du planlegger å utvikle deg i Rust på Windows, må du huske på verktøykjedene dine. Rust støtter to verktøykjeder på Windows:

Den opprinnelige Microsoft Visual C (MSVC) ABI
Gnu ABI brukt av GCC linker.

Fordi nesten all C / C ++ -programvare innebygd i Windows bruker MSVC uansett, vil du bruke MSVC-verktøykjeden langt de fleste av tiden. Hvis du noen gang trenger GCC, vil det mest sannsynlig være for samhandling med tredjepartsbiblioteker innebygd i Windows med GCC.

Den gode nyheten er at Rusts verktøyskjedeadministrasjonssystem lar deg beholde begge MSVC og GCC-verktøykjeder er installert, og det lar deg bytte mellom dem på prosjekt-for-prosjektbasis.

Et av Rusts kompileringsmål er WebAssembly, noe som betyr at du kan skrive i Rust og distribuere til en nettleser. WebAssembly selv er fortsatt grov rundt kantene, og det er også Rusts støtte for det. Men hvis du er ambisiøs og vil gjøre hendene dine rotete, kan du lese boken som er samlet av Rust og WebAssembly-utviklere som beskriver prosessen for å kompilere WebAssembly til Rust. Boken inneholder en veiledning for et enkelt prosjekt, en implementering av Conways Game of Life, skrevet i Rust og distribuert som WebAssembly.

Start Rust-oppsettet med `rustup`

Rust tilbyr et alt-i-ett-installatør og vedlikeholdssystem for verktøykjeder rustup. nedlasting rustup og kjør den; den får de nyeste versjonene av Rust-verktøykjeden og installerer dem for deg.

De mest kritiske verktøyene som vedlikeholdes av rustup er:

rustup seg selv. Hver gang nye versjoner av rustup eller andre verktøy er publisert, kan du bare kjøre rustup oppdatering og ha alt oppdatert automatisk.
rustc, Rust kompilatoren.
Cargo, Rusts pakke- og arbeidsområdet manager.

Som standard, rustup installerer Rust fra stallkanalen. Hvis du vil bruke beta- eller nattversjoner, må du installere disse kanalene (for eksempelrustup installere hver natt), og angi Rust for å bruke dem som standard (rustup standard nattlig). Du kan også spesifisere hvilken kanal du skal bruke når du kompilerer et Rust-program, slik at du ikke trenger å angi og tilbakestille standardverdien hver gang du flytter mellom prosjekter.

Du kan også brukerustup å installere og vedlikeholde tilpassede verktøykjeder. Disse brukes vanligvis av uoffisielle tredjepartsbygg av Rust for ikke-støttede plattformer, fordi de vanligvis krever egne lenker eller andre plattformsspesifikke verktøy.

Konfigurer IDE for Rust

Til tross for at Rust er et relativt nytt språk, har det allerede fått sterk støtte fra mange vanlige IDEer. Utvikler Manuel Hoffman vedlikeholder et prosjekt for å spore tilstanden til slik støtte på nettstedet areweideyet.com.

Å få Rust til å fungere godt med IDEer er et uttrykkelig mål for utviklingsteamet, via en funksjon kalt Rust Language Server (RLS). RLS gir live tilbakemeldinger om den aktuelle koden fra Rust sin egen kompilator, i stedet for fra en tredjeparts parser.

Her er IDEene som støtter Rust:

Microsofts Visual Studio Code har en støtteutvidelse for Rust språk opprettet av Rust sitt eget team for utviklerverktøy. Dette integrasjonsnivået gjør det til en av de best støttede IDEene for Rust.
Eclipse-brukere kan laste ned en ferdigpakket utgave av Eclipse for Rust-utvikling, eller bruke det frittstående Corrosion-pluginet for Eclipse Photon. (En tidligere pakke, RustDT, vedlikeholdes ikke lenger.)
Hvis du er fan av Emacs eller Vim, har andre utviklere som deg skrevet Rust-spesifikke tillegg for begge redaktørene. Emacs har en Rust-spesifikk modus, og Vim har et plugin for å gi syntaks fremheving og formatering. RLS-støtte er tilgjengelig for både Emacs og Vim, men den må legges til og konfigureres manuelt.
IntelliJ Idea og Atom-brukere kan legge til plugins for å avrunde Rust-støtte.
Sublime Text har Rust-syntaksstøtte ute av esken, og plugins gir dypere støtte for andre funksjoner.
Et prosjekt for å lage en enkel IDE spesielt for Rust, SolidOak, var under utvikling en periode, men har siden da stoppet opp. Det beste alternativet er å gå med en av de eksisterende IDEene som allerede har støtte.

Lag ditt første Rust-prosjekt

Rustprosjekter er ment å ha en konsistent katalogstruktur, med kode og prosjektmetadata lagret i dem på bestemte måter. Koden er lagret i en src underkatalog, og detaljer om prosjektet lagres i to filer i prosjektets rotkatalog,Cargo.toml (prosjektets grunnleggende informasjon) og Last. Lås (en automatisk generert liste over avhengigheter). Du kan opprette katalogstrukturen og metadataene for hånd, men det er lettere å bare bruke Rust sine egne verktøy for å gjøre jobben.

Tips:Rust By Example online guide for å lære Rust gir interaktive kodeeksempler som kan redigeres og kjøres direkte i nettleseren. Den berører nesten alle større Rust-konsepter, selv om noen av de mer sentrale begrepene, som lån og levetid, introduseres relativt sent i diskusjonen.

Rust's Cargo-verktøy styrer både Rust-prosjekter og biblioteker, eller "kasser", de bruker. Å spinne opp et nytt Rust-prosjekt som heter mitt prosjekt i sin egen katalog, skriv inn last nytt my_project. (For C # -utviklere som jobber med .Net Core, tenk på dotnet nytt kommandoen.) Det nye prosjektet vises i en underkatalog med det navnet, sammen med et grunnleggende prosjektmanifest - Cargo.toml fil - og en stubbe for prosjektets kildekode, i en src underkatalog.

Når du oppretter et nytt prosjekt, amain.rs filen blir automatisk opprettet i src katalog av prosjektet. Denne filen inneholder en grunnleggende "hallo verden" -app, slik at du kan teste Rust-verktøykjeden din med en gang ved å kompilere og kjøre den.

Kildekoden for "hallo verden" -appen:

fn main () {

println! (“Hello World!”);

}

For å bygge og kjøre den, skriv inn roten til prosjektkatalogen og skriv lastekjøring. Merk at Cargo som standard bygger prosjekter i feilsøkingsmodus. For å kjøre i utløsermodus, bruk lastekjøring - utgivelse. Binærfiler er bygget i mål / feilsøk eller mål / løslat underkatalog for et prosjekt, avhengig av hvilken kompilasjonsprofil du bruker.

Arbeid med rustkasser

Pakkehåndtering er en viktig del av ethvert moderne programmeringsmiljø. For å oppnå dette gir Rust "kasser", som er tredjepartsbiblioteker pakket for distribusjon med Rusts verktøy. Du finner kasser i det offisielle Rust-pakkeregistret, Crates.io.

Hvis prosjektet ditt er avhengig av en bestemt kasse, må du spesifisere kassen ved å redigere prosjektets Cargo.toml fil. Standard måten å gjøre dette på er manuelt - det vil si ved å redigere Cargo.toml direkte med en tekstredigerer. Neste gang prosjektet gjenoppbygges, oppnår Rust automatisk alle nødvendige avhengigheter.

Tips: To verktøy, lastredigering og last-rediger-lokalt, kan oppdatere avhengigheter fra kommandolinjen, selv om de er uoffisielle tredjepartsprosjekter.

Når du bygger et Rust-prosjekt som er avhengig av eksterne kasser, ser Cargo som standard etter disse kassene på Crates.io; du trenger ikke å skaffe dem manuelt. Du kan også referere til kasser i prosjektet ditt etter URL i stedet for etter kassenavn, i tilfelle du trenger en kasse som ikke er vert i registeret, for eksempel noe fra et privat depot.

Merk at noen kasser vil kun installere og bygge på Rusts nattlige kanal, fordi de bruker eksperimentelle funksjoner som ikke er tilgjengelige i andre kanaler. Hvis du er på utgivelseskanalen og prøver å installere en slik kasse, får du ingen advarsler før selve samlingen mislykkes. Kassedokumentasjon nevner vanligvis om det krever nattlig kanal eller ikke, så les deg opp før du inkluderer, enn si kompilering.

Kasser kan leveres med binærfiler inkludert. Noen er kommandolinjeverktøy som brukes i Rust-utvikling; andre er verktøy for allmenn bruk (som f.eksripgrep). For å installere en av disse kassene, skriv bare inn lastinstallasjon . Dette er ikke den kun måte å distribuere en binær opprettet med Rust, men det er en praktisk måte for Rust-utviklere å skaffe dem som en del av en arbeidsflyt som involverer Rust-verktøy.

Krysskompiler Rust til en annen plattform

Siden Rust støtter flere verktøykjeder, selv i samme installasjon av Rust, kan du kompilere Rust-applikasjoner til et mål OS og miljø som er forskjellig fra det du kompilerer på.

Slik tverrkompilering krever en verktøykjede på plattformen du jobber med som samsvarer med målplattformen. Noen ganger, som med kryss-kompilering til Linux på Windows eller omvendt, innebærer dette lite mer enn å ha GCC-linkeren. Men andre ganger er det mer komplekst. For å krysskompilere til MacOS, for eksempel, trenger du Xcode IDE-bibliotekene for å fullføre jobben - cctools (Apples tilsvarer binutils) og MacOS SDK.

Tredjepartsverktøy tilbyr noen måter rundt disse vanskelighetene:

Et slikt verktøy er Trust, en Travis CI- og AppVeyor-mal som automatisk kan publisere binære utgivelser av et Rust-prosjekt. Den kan bygges for Linux, Windows og MacOS, selv om den krever bruk av Travis CI- og AppVeyor-tjenestene, og det krever at prosjektet ditt er vert på GitHub.
Et annet prosjekt, Cross, kjører direkte på en 64-bit x86 Linux-vert, men gir det som skaperen beskriver som "nulloppsett" kryss-kompilering til et bredt utvalg av mål, inkludert 64-biters Windows og MIPS.
Crossbuild-prosjektet gir et multi-arkitektur Docker-bilde som kan brukes til å krysse bygging mellom alle de tre store plattformene.