Rust and Go ialah bahasa dengan aplikasi dalam aplikasi kritikal prestasi. Artikel ini menguraikan ciri utama dan kes penggunaan biasa untuk kedua-dua bahasa.
Dalam dekad yang lalu, Rust and Go telah menjadi agak popular. Karat selamat memori digunakan terutamanya dalam pengaturcaraan sistem. Go digemari kerana kesederhanaan dan keselarasan terbina dalam, yang menjadikannya sempurna untuk membina aplikasi web dan API boleh skala. Menariknya, firma teknologi terbesar, seperti syarikat FAANG dan Fortune 100, menggunakan kedua-dua Rust dan Go untuk pelbagai aspek aplikasi mereka.
Dalam artikel ini, anda akan menemui jawapan kepada soalan "Should I Rust or Should I Go?". Anda akan mempelajari cara Rust dan Go membandingkan antara satu sama lain dari segi konkurensi, dan keselamatan ingatan antara lain. Selain itu, anda akan belajar tentang senario berbeza yang paling sesuai untuk setiap bahasa.
Menjelang akhir artikel ini, anda akan dimaklumkan dengan baik tentang ciri utama dan kes penggunaan kedua-dua bahasa, membawa anda kepada keputusan termaklum dalam memilih yang sesuai untuk projek anda.
Rust ialah bahasa pengaturcaraan peringkat tinggi dengan tumpuan yang kuat pada keselamatan memori yang dicipta oleh Graydon Hoare, bekas pekerja Mozilla sebagai projek peribadi pada tahun 2006. Bahasa selamat ingatan seperti Rust telah disyorkan oleh Jabatan Amerika Syarikat.
Go ialah bahasa pengaturcaraan sumber terbuka yang dicipta di Google oleh Robert Griesemer, Rob Pike dan Ken Thompson pada tahun 2009. Ia ditaip secara statik dan serupa dengan C++ dalam sintaks. Dalam temu bual, Rob Pike berkata Go dicipta kerana kesukaran yang dikaitkan dengan operasi serentak dalam C++ pada masa itu.
Dalam bahagian ini, anda akan mempelajari cara Rust and Go membandingkan dari segi kelajuan dan penggunaan memori.
1. Perbandingan penanda aras
Permainan Penanda Aras membandingkan masa jalan dan penggunaan memori kedua-dua Rust dan Go. Untuk semua algoritma yang diuji, didapati bahawa kod Rust yang paling dioptimumkan mempunyai masa pelaksanaan yang lebih cepat berbanding dengan kod Go yang paling dioptimumkan.
Untuk algoritma regex-redux dan pepohon binari, Rust jauh mengatasi Go seperti yang ditunjukkan dalam imej di bawah. Kod Rust menggunakan kurang memori dan dilaksanakan dalam masa yang lebih singkat berbanding dengan Go.
2. Pengurusan dan Kecekapan Memori
Kedua-dua Rust dan Go adalah bahasa yang selamat memori walaupun mereka mencapai ini dengan cara yang berbeza. Reka bentuk karat mengutamakan pelaksanaan pantas manakala Go menyukai kompilasi pantas. Sistem pemilikan dan peminjaman Rust menghalang banyak punca biasa kebocoran memori pada masa penyusunan, manakala Go bergantung pada pengumpulan sampah automatik untuk membebaskan memori yang tidak digunakan pada masa jalan. Walau bagaimanapun, kedua-dua bahasa masih boleh mengalami kebocoran memori dalam keadaan tertentu.
Dalam bahagian ini, anda akan belajar tentang pendekatan unik Rust and Go to concurrency and parallelism.
1. Pendekatan Karat
Karat menyokong konkurensi melalui penggunaan paradigma async/menunggu dan penggunaan benang dan saluran.
Paradigma async/menunggu Rust membolehkan anda menulis kod tak segerak yang lebih mudah dibaca dan diselenggara. Masa jalan yang dibina pada sifat Masa Depan Rust seperti Tokio atau async-std sering digunakan dengan paradigma async/wait. Berikut ialah contoh penggunaan async/wait:
use tokio::time::{sleep, Duration};
async fn execute_task() {
println!("Task has begun.");
sleep(Duration::from_secs(2)).await;
println!("Task is done.");
}
#[tokio::main]
async fn main() {
let task_handle = tokio::spawn(async {
execute_task().await;
});
task_handle.await.unwrap();
println!("Main function completed.");
}
Dalam kod di atas, fungsi execute_task mensimulasikan tugasan yang mengambil sedikit masa untuk diselesaikan. Masa jalan Rust Tokio menguruskan pelaksanaan fungsi utama tanpa menyekat benang, membenarkan tugas tak segerak lain untuk diteruskan serentak. Fungsi utama kemudian menunggu tugas selesai sebelum mencetak mesej selesai.
Inilah outputnya:
Pustaka standard Rust menyediakan sokongan untuk urutan dan serentak menghantar mesej dengan saluran. Berikut ialah contoh:
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
fn main() {
let (sender, receiver) = mpsc::channel();
thread::spawn(move || {
let messages = vec![
String::from("greetings"),
String::from("from"),
String::from("the"),
String::from("worker"),
];
for message in messages {
sender.send(message).unwrap();
thread::sleep(Duration::from_secs(1));
}
});
for received_message in receiver {
println!("Received: {}", received_message);
}
}
Dalam kod di atas, utas baharu yang berjalan serentak dengan utas utama dibuat menggunakan utas::spawn(). Urutan ini menghantar satu siri mesej melalui saluran yang dibuat menggunakan mpsc::channel(). Apabila mesej dihantar daripada utas yang dihasilkan, ia diterima dan dicetak oleh utas utama.
Inilah outputnya:
2. Pendekatan Go
Go mencapai keselarasan melalui penggunaan goroutin dan saluran. Goroutines ialah utas ringan yang diuruskan oleh masa jalan Go yang membolehkan fungsi berjalan serentak. Fungsi biasa boleh dijadikan goroutine dengan menambahkan kata kunci go di hadapannya.
package main
import (
"fmt"
"time"
)
func displayDigits() {
for i := 1; i <= 5; i++ {
time.Sleep(1 * time.Second) // sleep to demonstrate concurrency
fmt.Printf("Digit: %d\n", i)
}
}
func displayCharacters() {
for i := 'A'; i <= 'E'; i++ {
time.Sleep(1 * time.Second)
fmt.Printf("Character: %c\n", i)
}
}
func main() {
// Launch the goroutines
go displayDigits()
go displayCharacters()
// Wait for the goroutines to complete
time.Sleep(6 * time.Second)
fmt.Println("Finished")
}
Dalam kod ini di atas, dua goroutine ditakrifkan. Goroutine pertama mencetak digit daripada 1 hingga 5, manakala yang kedua mencetak aksara dari A hingga E. Fungsi utama melancarkan goroutine ini dan kemudian menunggu selama 6 saat supaya goroutine mempunyai masa yang cukup untuk dijalankan sebelum mencetak "Selesai".
Inilah outputnya
Groutine boleh berkomunikasi antara satu sama lain menggunakan saluran. Berikut ialah contoh:
package main
import "fmt"
func transmitMessages(ch chan string) {
msgs := []string{"Greetings", "Simplicity", "Concurrency"}
for _, message := range msgs {
ch <- message
}
// Properly close the channel after sending all messages
close(ch)
}
func main() {
ch := make(chan string)
// Launch the transmission of messages concurrently
go transmitMessages(ch)
for message := range ch {
fmt.Println(message)
}
}
Dalam kod di atas, fungsi transmitMessages, berjalan sebagai goroutine berasingan, menghantar satu siri mesej melalui saluran. Kemudian, fungsi utama menerima mesej ini dan mencetaknya.
Inilah outputnya:
Di sini, anda akan belajar tentang keluk pembelajaran kedua-dua bahasa dan kelajuan pembangunan.
Rust mempunyai keluk pembelajaran yang lebih curam berbanding Go yang telah dipuji oleh pembangun di seluruh dunia kerana kesederhanaan dan sintaksnya yang mudah difahami. Sebaliknya karat memerlukan lebih banyak masa untuk memahami kerana pembangun sering bergelut dengan konsep penting seperti peraturan keselamatan ingatan, penukaran jenis dan semakan jenis.
Perkara yang sama boleh dikatakan tentang kelajuan pembangunan kerana Go lebih mudah difahami dan pembangun boleh mula bekerja dengannya dengan lebih pantas berbanding Rust yang boleh mengambil sedikit masa kerana keluk pembelajaran yang curam.
Dalam bahagian ini, anda akan mempelajari tentang langkah berbeza yang ditetapkan oleh kedua-dua bahasa untuk membolehkan keselamatan dan kebolehpercayaan.
1. Sistem Pemilikan Rust
Dalam Rust, apabila nilai ditetapkan kepada pembolehubah atau dipindahkan ke fungsi, pemilikan dipindahkan, menyebabkan pembolehubah asal tidak boleh diakses. Ini adalah untuk mengelakkan ralat bebas berganda dan perlumbaan data. Sistem pemilikan Rust memastikan keselamatan memori dengan mengurus peruntukan memori dan proses deallokasi.
fn main() {
{
let c2 = String::from("Ownership model");
let c3 = c2;
println!("{}", c3);
}
}
Dalam contoh ini, kami mempunyai rentetan c2. Apabila kami menetapkan c2 kepada c3, Rust membatalkan c2. Jika anda cuba mencetak c2, anda akan mendapat ralat masa kompilasi seperti yang ditunjukkan dalam imej di bawah.
2. Pengendalian ralat Go
Tidak seperti dalam kebanyakan bahasa pengaturcaraan moden, ralat dalam Go tidak terkecuali. Ia hanyalah nilai yang melaksanakan antara muka ralat. Pendekatan ini membolehkan kod yang lebih mudah dibaca dan diselenggara. Di bawah ialah antara muka ralat yang digunakan oleh Go.
type error interface {
Error() string
}
Apabila membandingkan Rust dan Go, adalah penting untuk mempertimbangkan ekosistem, saiz komuniti dan sokongan korporat mereka
1. Saiz dan aktiviti komuniti
Kedua-dua Rust dan Go mempunyai komuniti yang aktif dan bertenaga. Walaupun Go menonjol dengan lebih banyak bintang GitHub dan pengguna aktif berbanding Rust. Di bawah ialah Halaman GitHub dan bilangan soalan Stack Overflow yang ditanya untuk kedua-dua bahasa.
Karat
Di bawah ialah halaman Rust Github dengan 96k bintang dan halaman Stack Overflow dengan lebih 42k soalan ditandakan [rust].
Rust GitHub Stars
Soalan Limpahan Timbunan Karat
Pergilah
Di bawah ialah halaman Go Github dengan 122k bintang dan halaman Stack Overflow dengan lebih 73k soalan ditandakan [pergi].
Go GitHub Stars
Pergi Timbunan Soalan Limpahan
Menurut tinjauan 2024 oleh Stack Overflow, pembangun mengundi Rust sebagai bahasa pengaturcaraan yang paling dikagumi selama 8+ tahun berturut-turut.
2. Sokongan korporat dan penerimaan
Rust disokong oleh Mozilla, dan kini oleh Rust Foundation. Syarikat teknologi seperti Dropbox, Cloudflare dan Meta menggunakan Rust untuk perkhidmatan intensif prestasi.
Go dicipta di Google, dan ia mempunyai sokongan dan penerimaan korporat yang besar. Syarikat utama seperti Google, Uber dan Dropbox bergantung pada Go untuk kebanyakan perkhidmatan bahagian belakang mereka. Docker, teknologi kontena terkemuka telah dibina terutamanya dalam Go.
3. Rangka Kerja dan Perpustakaan Popular
Karat:
Pergi:
Berikut ialah jadual yang meringkaskan perbezaan utama antara setiap bahasa.
| Aspect | Rust | Go |
|---|---|---|
| Memory Safety | Enforced at compile time without the need for garbage collection. | Relies on a garbage collector. |
| Performance | Comparable to C/C++. | Slightly lower than Rust but fast enough for many applications. |
| Concurrency Model | Utilizes an ownership model with threads and async tasks. | Built-in support with goroutines and channels. |
| Type System | Strong with pattern matching and type inference. | Statically typed with a simpler type system. |
| Compilation Times | Slower due to complex optimizations and safety checks. | Faster compilation. |
| Ease of Use | Steeper learning curve due to advanced features. | Easier to learn. |
| Standard Library | Rich but less extensive, focusing more on performance-critical and systems programming features. | Comprehensive, especially strong in networking, I/O, and web server support. |
| Community and Ecosystem | Rapidly growing, especially among systems programmers interested in safety and performance. | Large and mature, widely used in cloud infrastructure, networking, and DevOps tools. |
| Error Handling | Based on Result and Option types. | Uses the error interface, treating errors as values. |
Karat terutamanya cemerlang dalam prestasi dan senario kritikal memori atau senario di mana sejumlah besar data sedang diproses. Anda boleh menggunakan Rust dalam senario berikut:
Go boleh digunakan dalam pelbagai senario. Konkurensi terbina dalam menjadikannya pilihan yang bagus untuk aplikasi yang mengendalikan berbilang permintaan. Secara keseluruhannya, Go adalah sesuai jika anda mementingkan kesederhanaan dan kebolehbacaan kod berbanding prestasi. Anda harus menggunakan Go jika anda memerlukan:
Pada penghujung hari, kedua-dua Rust dan Go adalah pilihan yang bagus untuk membina aplikasi bahagian pelayan. Walau bagaimanapun, pilihan yang betul akan berdasarkan keperluan permohonan anda dan perkara yang anda ingin capai.
Artikel ini merangkumi ciri utama, kes penggunaan dan perbezaan antara bahasa Rust dan Go, melengkapkan anda dengan pengetahuan untuk memutuskan yang terbaik mengikut keperluan projek anda.
Berikut ialah beberapa sumber untuk bacaan lanjut.
Atas ialah kandungan terperinci Rust vs Go? Perlukah saya Berkarat atau Haruskah Saya Pergi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
