Tutorial karat: Mulakan dengan bahasa Rust

Sejak beberapa tahun kebelakangan ini, Rust telah berubah dari rasa ingin tahu yang muncul di makmal pekerja Mozilla menjadi pesaing yang kuat untuk menulis generasi aplikasi generasi seterusnya dan penyelesaian kosong. Tetapi kemajuan itu datang dari Rust yang menyediakan rantai alat dan sistem pengurusan komponennya sendiri - bersama dengan ciri dan kebiasaannya sendiri.

Artikel ini membahas asas-asas mengatur lingkungan kerja di Rust, mengkonfigurasi IDE, dan memanfaatkan sebagian besar set alat yang disediakan Rust untuk pengembangan aplikasi.

Video berkaitan: Membangunkan perisian yang lebih selamat dengan Rust

Dapatkan kecepatan dengan pantas pada pendatang baru Rust, yang dirancang untuk membuat perisian peringkat sistem yang pantas. Penjelasan animasi dua minit ini menunjukkan bagaimana Rust memintas masalah pengaturcaraan memori dan pengurusan yang menjengkelkan.

Fahami Rust setiap malam, beta, dan siaran stabil

Rantai alat Rust terdiri terutamanya dari penyusun Rust rustc, bersama dengan alat untuk menguruskan pemasangan Rust. Oleh kerana Rust dalam perkembangan berterusan, rantai alat Rust direka agar mudah dikemas kini.

Projek perisian sering disediakan melalui pelbagai saluran, untuk memisahkan kod versi stabil dan beta. Rantai alat Rust berfungsi dengan cara yang sama, menawarkan tiga saluran untuk rantai alatnya:

  • Stabil: Pelepasan titik utama, yang muncul setiap enam minggu atau lebih.
  • Beta: Calon untuk pelepasan titik utama seterusnya, yang muncul lebih kerap.
  • Nightly: Binaan paling segera, dengan akses kepada ciri canggih tetapi tidak ada jaminan kestabilannya.

Seperti yang ditunjukkan oleh pemaju Karol Kuczmarski, lebih baik memikirkan saluran Rust malam sebagai bahasanya sendiri. Beberapa ciri Rust, seperti menyusun ke WebAssembly, hanya tersedia di saluran malam, dan hanya boleh diaktifkan dengan arahan penyusun khas. Dengan kata lain, mereka tidak akan menyusun pada saluran beta atau stabil. 

Itu berdasarkan reka bentuk, kerana tidak ada jaminan ciri malam akan disokong di tempat lain. Walau bagaimanapun, banyak ciri tersebut akhirnya keluar dari saluran malam dan menjadi siaran beta dan stabil. (Kompilasi ke WebAssembly, misalnya, berfungsi dalam stabil mulai Rust 1.30.)

Ringkasnya:

  1. Gunakan stabil untuk kerja pengeluaran sebenar.
  2. Gunakan beta untuk menguji perisian semasa dengan versi yang akan datang untuk melihat apakah ada yang boleh berlaku semasa peningkatan.
  3. Hanya gunakan setiap malam untuk eksperimen kotak pasir dengan ciri terbaru Rust.

Pilih OS untuk pembangunan Rust

Rust menyokong ketiga-tiga platform utama - Windows, Linux, dan MacOS - dalam kedua-dua inkarnasi 32- dan 64-bit, dengan binari rasmi untuk masing-masing. Beberapa platform lain juga mempunyai binari rasmi, tetapi mereka tidak mempunyai tahap liputan ujian automatik yang sama. Platform kelas kedua ini merangkumi ARMv6 dan ARMv7 untuk iOS, Android, dan Linux; MIPS Linux dan MIPS64 Linux; Edisi 32-bit x86 iOS, Windows, dan Linux; dan Perhimpunan Web. Platform lain, seperti Windows XP atau HaikuOS eksperimental, disokong melalui binaan tidak rasmi.

Pasukan pengembangan Rust telah menyatakan bahawa bukan salah satu misi Rust untuk menjadi seluas mungkin. Sebagai contoh, walaupun Rust tersedia di banyak seni bina ARM, tidak dijamin Rust akan disokong secara rasmi pada platform perkakasan kelas atas.

Walaupun begitu, harus ada build Rust yang disokong tersedia untuk sebilangan besar kes penggunaan arus perdana - iaitu, Windows, Linux, dan MacOS 32- dan 64-bit.

Sekiranya anda bercadang untuk membangun di Rust pada Windows, ingatlah rantai alat anda. Rust menyokong dua rantai alat pada Windows:

  • Microsoft Visual C (MSVC) ABI asli
  • Gnu ABI yang digunakan oleh penghubung GCC.

Kerana hampir semua perisian C / C ++ yang dibina di Windows menggunakan MSVC pula, anda pasti ingin menggunakan rangkaian alat MSVC pada sebahagian besar masa. Sekiranya anda memerlukan GCC, kemungkinan itu adalah untuk beroperasi dengan perpustakaan pihak ketiga yang dibina di Windows dengan GCC.

Berita baiknya adalah bahawa sistem pengurusan rantai alat Rust membolehkan anda memastikan rantai alat MSVC dan GCC dipasang, dan ini membolehkan anda beralih di antara mereka berdasarkan projek demi projek.

Salah satu sasaran penyusunan Rust adalah WebAssembly, yang bermaksud anda boleh menulis dalam Rust dan menyebarkannya ke penyemak imbas web. WebAss Assembly sendiri masih kasar di sekitar tepi, dan begitu juga sokongan Rust untuknya. Tetapi jika anda bercita-cita tinggi dan ingin membuat tangan anda tidak kemas, bacalah buku yang disusun oleh pemaju Rust dan WebAssembly yang memperincikan proses penyusunan WebAssembly ke Rust. Buku ini merangkumi tutorial untuk projek sederhana, pelaksanaan Conway's Game of Life, yang ditulis dalam Rust dan digunakan sebagai WebAssembly.

Mulakan persediaan Rust anda dengan rustup

Rust menyediakan pemasang all-in-one dan sistem penyelenggaraan rantai alat yang dipanggil rustup. Muat turun rustupdan jalankan; ia akan memperoleh versi terbaru rangkaian alat Rust dan memasangnya untuk anda.

Alat paling kritikal yang dikendalikan rustupadalah:

  • rustupsendiri. Setiap kali versi baru rustupatau alat lain diterbitkan, anda boleh menjalankan rustup updatedan memperbaharui semuanya secara automatik.
  • rustc, penyusun Rust.
  • Cargo, pengurus pakej dan ruang kerja Rust.

Secara lalai, rustupmemasang Rust dari saluran stabil. Sekiranya anda ingin menggunakan versi beta atau malam, anda mesti memasang saluran tersebut (contohnya  rustup install nightly), dan menetapkan Rust untuk menggunakannya secara lalai ( rustup default nightly). Anda juga dapat menentukan saluran mana yang akan digunakan secara manual ketika menyusun aplikasi Rust, jadi Anda tidak perlu menetapkan dan menetapkan semula lalai setiap kali anda berpindah di antara projek.

Anda juga boleh menggunakan  rustup untuk memasang dan mengekalkan rantai alat tersuai. Ini biasanya digunakan oleh rust pihak ketiga yang tidak rasmi untuk platform yang tidak disokong, kerana biasanya memerlukan penghubung mereka sendiri atau alat khusus platform lain.

Konfigurasikan IDE anda untuk Rust

Walaupun Rust menjadi bahasa yang agak baru, bahasa Rust sudah mendapat sokongan kuat dari banyak IDE biasa. Pembangun Manuel Hoffman mengekalkan projek untuk mengesan keadaan sokongan tersebut di laman web areweideyet.com.

Menjadikan Rust berfungsi dengan baik dengan IDE adalah tujuan jelas pasukan pengembangannya, melalui ciri yang disebut Rust Language Server (RLS). RLS memberikan maklum balas langsung mengenai kod yang dimaksudkan dari penyusun Rust sendiri, dan bukannya dari penghurai pihak ketiga.

Berikut adalah IDE yang menyokong Rust:

  • Kod Visual Studio Microsoft mempunyai peluasan sokongan bahasa Rust yang dibuat oleh pasukan alat pembangun Rust sendiri. Tahap integrasi ini menjadikannya salah satu IDE yang disokong terbaik untuk Rust. 
  • Pengguna Eclipse boleh memuat turun edisi pra-paket Eclipse untuk pengembangan Rust, atau menggunakan plugin Corrosion yang berdiri sendiri untuk Eclipse Photon. (Pakej sebelumnya, RustDT, tidak lagi dikekalkan.)
  • Sekiranya anda peminat Emacs atau Vim, pembangun lain seperti anda telah menulis tambahan Rust untuk kedua-dua editor. Emacs mempunyai mod khusus Rust, dan Vim mempunyai plugin untuk memberikan penekanan dan pemformatan sintaks. Sokongan RLS tersedia untuk Emac dan Vim, tetapi ia mesti ditambah dan dikonfigurasi secara manual.
  • Pengguna IntelliJ Idea dan Atom dapat menambahkan pemalam untuk melengkapkan sokongan Rust.
  • Teks Sublime mempunyai sokongan sintaks Rust di luar kotak, dan pemalam memberikan sokongan yang lebih mendalam untuk ciri lain.
  • Projek untuk membuat IDE sederhana khusus untuk Rust, SolidOak, sedang dikembangkan untuk beberapa waktu tetapi sejak itu terhenti. Pertaruhan terbaik anda adalah dengan menggunakan salah satu IDE yang ada yang sudah mempunyai sokongan.

Buat projek Rust pertama anda

Projek karat dimaksudkan untuk memiliki struktur direktori yang konsisten, dengan metadata kod dan projek disimpan di dalamnya dengan cara tertentu. Kod disimpan dalam srcsubdirektori, dan perincian mengenai projek disimpan dalam dua fail di direktori root projek,  Cargo.toml(maklumat asas projek) dan Cargo.lock(senarai kebergantungan yang dihasilkan secara automatik). Anda boleh membuat struktur direktori dan metadata dengan tangan, tetapi lebih mudah hanya menggunakan alat Rust sendiri untuk melakukan tugas itu.

Petua:  Panduan dalam talian untuk belajar Rust By Contoh Rust menyediakan contoh kod interaktif yang boleh diedit dan dijalankan terus di penyemak imbas. Ini menyentuh hampir semua konsep utama Rust, walaupun beberapa konsep yang lebih penting, seperti pinjaman dan jangka hayat, diperkenalkan agak lewat dalam perbincangan.

Alat Kargo Rust menguruskan kedua projek Rust dan perpustakaan, atau "peti" yang mereka gunakan. Untuk membuat projek Rust baru yang dinamakan my_projectdalam direktori sendiri, ketik cargo new my_project. (Untuk pembangun C # yang bekerja dengan. Net Core, fikirkan dotnet newperintahnya.) Projek baru muncul dalam subdirektori dengan nama itu, bersama dengan manifes projek asas - Cargo.tomlfail - dan rintisan untuk kod sumber projek, dalam srcsubdirektori.

Semasa anda membuat projek baru,  main.rsfail akan dibuat secara automatik di srcdirektori projek. Fail ini mengandungi aplikasi "hello world" asas, jadi anda dapat segera menguji rantai alat Rust anda dengan menyusun dan menjalankannya.

Kod sumber untuk aplikasi "hello world":

fn main() {

    println!(“Hello World!”);

}

Untuk membina dan menjalankannya, masukkan akar direktori projek dan taipkan cargo run. Perhatikan bahawa secara lalai, Cargo membina projek dalam mod debug. Untuk berjalan dalam mod pelepasan, gunakan cargo run --release. Binari dibina dalam target/debugatau target/releasesubdirektori projek, bergantung pada profil penyusunan yang anda gunakan.

Bekerja dengan peti karat

Pengurusan pakej adalah bahagian penting dalam persekitaran pengaturcaraan moden. Untuk itu, Rust menyediakan "peti," yang merupakan perpustakaan pihak ketiga yang dikemas untuk diedarkan dengan alat Rust. Anda boleh mendapatkan peti di pendaftaran paket Rust rasmi, Crates.io.

Sekiranya projek anda bergantung pada peti tertentu, anda perlu menentukan peti itu dengan mengedit Cargo.tomlfail projek . Cara standard untuk melakukan ini adalah secara manual - iaitu dengan hanya mengedit Cargo.tomlsecara langsung dengan penyunting teks. Pada masa projek ini dibina semula, Rust secara automatik memperoleh kebergantungan yang diperlukan.

Petua: Dua alat, cargo-editdan cargo-edit-locally, dapat mengemas kini pergantungan dari baris perintah, walaupun ia adalah projek pihak ketiga tidak rasmi.

Apabila anda membina projek Rust yang bergantung pada peti luaran, Cargo mencari peti tersebut di Crates.io secara lalai; anda tidak perlu mendapatkannya secara manual. Anda juga boleh merujuk peti dalam projek anda melalui URL dan bukan dengan nama peti, sekiranya anda memerlukan peti yang tidak dihoskan dalam pendaftaran, seperti sesuatu dari repositori peribadi.

Perhatikan bahawa beberapa peti hanya akan dipasang dan dibina di saluran malam Rust, kerana mereka menggunakan ciri eksperimen yang tidak terdapat di saluran lain. Sekiranya anda berada di saluran pelepas dan anda cuba memasang peti seperti itu, anda tidak akan mendapat amaran sehingga kompilasi itu sendiri gagal. Dokumentasi peti biasanya menyebut sama ada ia memerlukan saluran malam atau tidak, jadi baca sebelum anda menyertakan, apalagi menyusun.

Peti boleh disertakan dengan binari yang disertakan. Sebilangannya adalah alat baris perintah yang digunakan dalam pengembangan Karat; yang lain adalah alat tujuan umum (seperti  ripgrep). Untuk memasang salah satu peti ini, ketik sahaja cargo install . Ini bukan satu- satunya cara untuk mengedarkan binari yang dibuat dengan Rust, tetapi cara mudah bagi pemaju Rust untuk mendapatkannya sebagai sebahagian daripada aliran kerja yang melibatkan alat Rust.

Merentas Rust ke platform lain

Kerana Rust menyokong pelbagai rantai alat, walaupun dalam pemasangan Rust yang sama, anda dapat menyusun aplikasi Rust ke OS sasaran dan persekitaran yang berbeza dari yang anda kumpulkan.

Penyusunan silang semacam itu memerlukan rantai alat pada platform yang anda kerjakan yang sepadan dengan platform sasaran. Kadang-kadang, seperti penyusunan silang ke Linux pada Windows atau sebaliknya, ini melibatkan lebih banyak daripada mempunyai penghubung GCC. Tetapi pada masa lain, ia lebih kompleks. Untuk penyusunan silang ke MacOS, misalnya, anda memerlukan perpustakaan Xcode IDE untuk menyelesaikan tugas - cctools (setara dengan binutil Apple) dan SDK MacOS.

Alat pihak ketiga menawarkan beberapa cara mengatasi kesulitan ini:

  • Salah satu alat tersebut ialah Trust, templat Travis CI dan AppVeyor yang secara automatik dapat menerbitkan siaran binari projek Rust. Ia boleh dibina untuk Linux, Windows, dan MacOS, walaupun memerlukan penggunaan perkhidmatan Travis CI dan AppVeyor, dan ia memerlukan projek anda dihoskan di GitHub.
  • Projek lain, Cross, dijalankan secara langsung pada hos Linux 64-bit x86, tetapi memberikan apa yang digambarkan oleh penciptanya sebagai penyusunan silang "penyusunan sifar" ke pelbagai sasaran, termasuk Windows dan MIPS 64-bit.
  • Projek membina silang memberikan imej Docker berbilang seni bina yang boleh digunakan untuk membina silang antara ketiga-tiga platform utama.