Rust vs Go? Perlukah saya Berkarat atau Haruskah Saya Pergi

pengenalan

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.

Gambaran keseluruhan tentang Rust

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.

Ciri-ciri Utama

• Keselamatan Memori: Karat menguatkuasakan keselamatan ingatan pada masa penyusunan tanpa menggunakan pengumpulan sampah.
• Prestasi Setanding dengan C/C++: Rust sepantas C dan C++.
• Sistem Pemilikan: Rust menyokong operasi serentak menggunakan sistem pemilikan dan peminjamannya.
• Sistem Jenis Kuat dan Padanan Corak: Sistem jenis Rust dan ciri padanan corak meningkatkan keselamatan kod.

Gambaran keseluruhan Go

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.

Ciri-ciri Utama

• Kesederhanaan: Go mempunyai keluk pembelajaran sederhana yang memudahkan untuk digunakan.
• Masa Penyusunan Pantas: Go menyusun dengan cepat, membolehkan pembangunan dan lelaran pantas.
• Konkurensi Terbina dalam: goroutin dan saluran terbina dalam Go membolehkan operasi serentak.
• Pustaka Standard Kukuh: Pustaka standard Go sangat teguh.

Perbandingan: Rust vs Go

Prestasi

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.

Konkurensi dan Paralelisme

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.

• Async/Await Paradigm in Rust

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:

• Menggunakan Thread dan Saluran

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.

• Keselarasan dengan Goroutines

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:

Keluk Pembelajaran dan Kelajuan Pembangunan

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.

Keselamatan dan Kebolehpercayaan

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
}

Ekosistem dan Komuniti

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:

• Actix: Rangka kerja web yang berkuasa dan pantas.
• Roket: Rangka kerja web yang memfokuskan pada kemudahan penggunaan dan keselamatan.
• Serde: Pustaka yang digunakan secara meluas untuk penyiaran dan penyahsirilan.
• Tokio: Masa jalan untuk menulis aplikasi tak segerak dengan Rust.

Pergi:

• Gin: Rangka kerja web ringan yang mudah digunakan.
• Beego: Rangka kerja web sumber terbuka berprestasi tinggi.
• GORM: ORM paling popular untuk Go, menjadikannya mudah untuk mengendalikan pangkalan data.
• Cobra: Perpustakaan untuk mencipta aplikasi CLI yang berkuasa.

Berikut ialah jadual yang meringkaskan perbezaan utama antara setiap bahasa.

Bila hendak menggunakan Rust

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:

• Pengaturcaraan sistem: Karat kerana keselamatan ingatannya boleh digunakan untuk membina atur cara peringkat sistem seperti sistem pengendalian.
• Pengkomputeran Berprestasi Tinggi: Karat sesuai untuk aplikasi yang memerlukan prestasi luar biasa.
• Sistem teragih berskala besar: Keselamatan dan kelajuan memori karat menjadikannya pilihan yang sangat baik apabila membina sistem teragih.

Bila hendak menggunakan Go

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:

• Operasi serentak: Go membolehkan operasi serentak menggunakan goroutinya.
• Pembangunan pantas: Go mempunyai sintaks yang mudah dengan perpustakaan standard yang membolehkan pembangunan pantas.
• Kesederhanaan dan kebolehbacaan: Sintaks Go yang mudah difahami menjadikannya sesuai untuk pasukan yang besar.

Kesimpulan

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.

Sumber

Berikut ialah beberapa sumber untuk bacaan lanjut.

• Model Pemilik Karat

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!