Go vs Rust : comparatif

Voici un comparatif détaillé entre Go et Rust dans un format de cheatsheet :

Tableau comparatif rapide

Go — Points forts

• Performance optimisée :

  package main
  
  import "fmt"
  
  func main() {
      fmt.Println("Hello, World!")
  }
  

• Facile d'apprentissage :

  package main
  
  import (
      "fmt"
      "math/rand"
  )
  
  func main() {
      rand.Seed(time.Now().UnixNano())
      num := rand.Intn(100)
      fmt.Println("Random number:", num)
  }
  

• Ecosystème vaste :
  • Large communauté et de nombreux packages disponibles.
• Facile de déploiement :
  • Compilé en exécutable portable.
• Bibliothèques robustes :
  • Support pour HTTP, nettoyage de code, etc.

Rust — Points forts

• Typage statique fort :

  fn main() {
      let x: i32 = 5;
      println!("The value of x is: {}", x);
  }
  

• Sécurité accrue :

  fn divide(dividend: u32, divisor: u32) -> Option<u32> {
      if divisor == 0 {
          None
      } else {
          Some(dividend / divisor)
      }
  }
  
  fn main() {
      match divide(10, 0) {
          Some(result) => println!("Result: {}", result),
          None => println!("Cannot divide by zero"),
      }
  }
  

• Performance optimisée :
  • Compilation en bytecode efficace.
• Concurrence sûre :
  • Gestion automatique des ressources et évitez les bugs de concurrence.
• Documentation détaillée :
  • Excellent système de documentation et de commentaires.

Syntaxe cote à cote

Déclaration d'une fonction

// Go
func add(a, b int) int {
    return a + b
}

// Rust
fn add(a: i32, b: i32) -> i32 {
    a + b
}

Boucle for

// Go
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// Rust
for i in 0..5 {
    println!("{}", i);
}

Structures de données

// Go
type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Alice", Age: 30}
    fmt.Println(p.Name, p.Age)
}

// Rust
struct Person {
    name: String,
    age: u8,
}

fn main() {
    let p = Person { name: "Alice".to_string(), age: 30 };
    println!("{} is {} years old", p.name, p.age);
}

Quand choisir Go vs Rust

• Go :
  • Pour des applications simples et performantes nécessitant une bonne performance.
  • Pour les startups et les petites équipes.
  • Pour des services web back-end.
• Rust :
  • Pour des bibliothèques systèmes haute performance.
  • Pour des applications où la sécurité est primordiale (cryptographie, sécurité réseau).
  • Pour des projets nécessitant une gestion fine de la mémoire.

Verdict

Go offre une excellente balance entre performance et facilité d'utilisation, idéal pour les petites à moyennes équipes. Rust, bien qu'ayant un apprenant plus difficile, offre des avantages majeurs en termes de sécurité et de performance, bien adapté aux projets complexes et hautement concurrentiels.