Imparare a programmare in Rust usando JavaScript: una guida per principianti

Ciao mondo, come state tutti? Sono un ingegnere del software che ama scrivere durante il mio tempo libero. Spesso mi ritrovo a creare racconti per antologie o a inventare folli romanzi ispirati ai miei incubi. Questa connessione tra scrittura e sviluppo software mi ha portato a creare Momo, un software per scrittori, come ho accennato qui .

Ho iniziato redigendo tutto ciò che potevo pensare in un documento di architettura completo. La scorsa settimana ho iniziato a lavorare su una versione desktop utilizzando Tauri (con Rust) per il backend e ReactJS e Vite per il frontend. Ho scelto questo approccio perché i pacchetti Tauri sono leggeri, sicuri e meglio gestiti dal sistema operativo. Dopo aver lavorato con Electron per sei anni, ho finalmente scoperto un degno concorrente. L'unica sfida è imparare a scrivere in Rust, una lingua che non ho mai letto prima. Ed è di questo che parleremo qui.

Prima impressione

All'apertura di un file Rust, mi sono trovato perplesso dalle numerose parole chiave difficili. Come persona esperta in Kotlin, Java, JavaScript, Python e C#, ho deciso di studiare Rust confrontando le sue funzionalità con JavaScript.

1. Variabili:

In JavaScript, abbiamo variabili dinamiche, usando letper variabili mutabili e constper costanti.

const x = 5; // constant
let y = 8 // mutable

let x = 5; // Immutable
let mut y = 8 // Mutable

Rust presenta un sistema di tipi forte e statico, che richiede una dichiarazione esplicita del tipo di variabile, che è più robusto di TypeScript. I tipi comuni includono numeri interi (i32, u32, i64, ecc.), numeri in virgola mobile (f32, f64) e valori booleani (bool). JavaScript, anche con TypeScript, utilizza la digitazione dinamica e non richiede di specificare il tipo di un numero.

A Ruggine:

let x: i32 = 6;
let y: f64 = 3.16;
let z: bool = false;

let x = 6; // Number
let y = 3.16; // Number
let z = false; // Boolean

Le funzioni di Rust sono definite usando "fn", con il tipo di ritorno scritto come "->". In JavaScript, le funzioni sono definite come "funzione" e non è necessario specificare il tipo restituito.

A Ruggine:

fn add(x: i32, y: i32) -> i32 {
  x * y
}

function add(x, y) {
  return x * y;
}

function add(x: number, y: number) {
  return x * y;
}

4. Strutture di controllo

Sia JavaScript che Rust hanno strutture di controllo simili come i cicli if-else, while e for.

A Ruggine:

if x < y {
  println!("x is less than y");
} else {
  println!("x is greater than or equal to y");
}

while x < 10 {
  println!("x is {}", x);
  x += 1;
}

for i in 0..10 {
  println!("i is {}", i);
}

if (x < y) {
  console.log("x is less than y");
} else {
  console.log("x is greater than or equal to y");
}

while (x < 10) {
  console.log("x is", x);
  x += 1;
}

for (let i = 0; i < 10; i++) {
  console.log("i is", i);
}

Rust gestisce gli errori utilizzando i tipi "Risultato" e "Opzione". In JavaScript, la gestione degli errori in genere comporta blocchi try-catch o callback error-first.

A Ruggine:

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Cannot divide by zero.".to_string())
    } else {
        Ok(a / b)
    }
}

match divide(10.0, 2.0) {
    Ok(result) => println!("Result is {}", result),
    Err(e) => println!("Error: {}", e),
}

function divide(a, b) {
    if (b === 0) {
        throw new Error("Cannot divide by zero.");
    } else {
        return a / b;
    }
}

try {
    const result = divide(10, 2);
    console.log("Result is", result);
} catch (e) {
    console.log("Error:", e.message);
}

JavaScript e Rust supportano la programmazione modulare, promuovendo una migliore organizzazione del codice attraverso file separati.

In Rust, supponendo di avere un file chiamato math.rscon il seguente contenuto:

pub fn add(x: i32, y: i32) -> i32 {
    x + y
}

mod math;
use math::add;

fn main() {
    let result = add(5, 10);
    println!("Result is {}", result);
}

export function add(x, y) {
  return x + y;
}

import { add } from ‘./math.js’;

const result = add(5, 10);
console.log("Result is", result);

Queste sono le basi che ho imparato in Rust, usando JavaScript come base. Mentre continuo a sviluppare e apprendere concetti più complessi, condividerò qui le mie intuizioni. Spero che lo troverai utile e alla prossima!