Tutto ciò che devi sapere per iniziare a scrivere Rust

Dalla sua uscita nel 2015, Rust ha guadagnato popolarità come uno dei linguaggi di programmazione preferiti dagli sviluppatori. Rust offre prestazioni eccellenti e funzionalità di sicurezza con una sintassi intuitiva e concisa che rende il linguaggio desiderabile.

Rust è adatto per la creazione di vari programmi, tra cui app Web, strumenti a riga di comando e servizi di rete. Rust include molte funzionalità che ti aspetteresti da un linguaggio di programmazione moderno, come la concorrenza, l'inferenza del tipo e altro ancora.

Iniziare con la ruggine

Rust è un linguaggio di programmazione multipiattaforma che gira sulla maggior parte dei sistemi operativi. Per iniziare con Rust, vai al funzionario Sito web di ruggine e installa la versione preferita per il tuo sistema operativo.

Una volta installato Rust, puoi iniziare a scrivere programmi in file Rust con estensione

.rs estensione. Rust è versatile e facile da imparare. Lo troverai semplice se hai una precedente esperienza di programmazione.

Variabili e costanti in Rust

Rust è altamente espressivo e ci sono diversi modi per dichiarare le variabili. Puoi usare il permettere parola chiave per dichiarare le variabili.

Ecco come puoi dichiarare le variabili in Rust:

permettere UN: Corda;
permettere B: io32;
permettere c: () = ();

IL UN E B le variabili sono rispettivamente una stringa e un numero intero. IL C variabile è un tipo di unità Rust che funge da segnaposto per funzioni ed espressioni.

Dopo la dichiarazione facoltativa del tipo di dati, è possibile dichiarare e inizializzare variabili con valori utilizzando un segno di uguale.

fnprincipale(){
permettere età: Corda = Corda::da("cinque anni");
permettere età = 5; // equivalente a let age: i32 = 5;
stampa!("{}", età);
}

Il programma ne dichiara due età variabili prima di stampare con il stampa! macro. Il primo età la variabile specifica il tipo di dati e la seconda no.

Non è necessario specificare il tipo di dati di una variabile quando la si dichiara. Il compilatore Rust deduce il tipo dal tipo di dati del valore in fase di compilazione.

Puoi anche dichiarare costanti in Rust con il cost parola chiave in modo simile alla dichiarazione di variabili:

cost età: &str = "cinque anni";

Non puoi modificare il valore di una variabile che dichiari come costante.

Rust fornisce funzionalità per commenti a riga singola e in blocco. Puoi usare le doppie barre (//) per i commenti a riga singola:

fnprincipale() {
// Questo è un commento di riga
permettere x = 5; // Questo commento spiega lo scopo della variabile `x`
}

Per commenti su più righe (commenti a blocchi), utilizzare una barra seguita da un asterisco (/*) e chiudere il blocco con un asterisco seguito da una barra (*/):

fnprincipale() {
/*
 Questo è un commento di blocco che si estende su più righe.
 Viene spesso utilizzato per descrivere un blocco di codice più grande.
 */
permettere x = 5;
}

I tuoi commenti dovrebbero essere concisi e diretti.

Array in ruggine

Gli array sono una raccolta di dimensioni fisse di elementi dello stesso tipo di dati. Rust alloca gli array sullo stack per impostazione predefinita.

Ecco come puoi dichiarare gli array in Rust:

fnprincipale() {
permettere numeri = [1, 2, 3, 4, 5];
}

IL numeri array contiene cinque elementi. Puoi accedere al valore in una posizione in un array usando il suo indice:

fnprincipale() {
permettere numeri = [1, 2, 3, 4, 5];
permettere x = numeri[3];
stampa!("{}", X)
}

IL principale funzione stampa il file X variabile che accede al quarto elemento dell'array.

Vettori in ruggine

Rust fornisce vettori per coprire i limiti dell'array. I vettori sono dimensionati dinamicamente; possono crescere e ridursi secondo necessità.

Ecco come puoi dichiarare i vettori in Rust:

fnprincipale() {
permettere mio_vec: Vec<io32> = vec![1, 2, 3, 4, 5];
permettere x = mio_vec[3];
stampa!("{}", X)
}

IL mio_vec vector è un vettore di interi a 32 bit. IL X variabile accede al quarto elemento del vettore e il principale la funzione stampa il valore nella console.

Le affermazioni condizionali di Rust

Le istruzioni condizionali sono una delle Le strutture di controllo di Rust per il processo decisionale nei programmi. Puoi usare il Se E altro parole chiave per gestire le decisioni nei tuoi programmi.

Ecco un Se istruzione che stampa una stringa sulla console in base all'uguaglianza di due numeri interi.

fnprincipale() {
permettere UN: io32 = 12;
Se un == 12 {
stampa!("a uguale dodici");
 }
}

IL principale funzione stampa la stringa con il stampa! macro poiché la variabile è uguale a 12.

Puoi usare il altro parola chiave per gestire i casi in cui il Se affermazione valuta falso:

fnprincipale() {
permettere UN: io32 = 12;
Se un == 123 {
stampa!("a uguale dodici");
 } altro {
stampa!("a non è uguale a dodici");
 }
}

In questo esempio, il altro l'istruzione viene eseguita perché il valore di a non è uguale a 123.

Puoi dichiarare istruzioni di corrispondenza con il incontro parola chiave per condizionali complessi:

fnprincipale() {
permettere età: io32 = 7;
incontro età {
1 => stampa!("uno"),
2 => stampa!("due"),
3 => stampa!("tre"),
 _ => stampa!("zero"),
 }
}

IL principale funzione corrisponde a età variabile ai casi in incontro istruzione ed esegue l'espressione che corrisponde al valore. Il carattere di sottolineatura (_) è l'istruzione predefinita che viene eseguita se esiste una corrispondenza per il valore.

Loop in ruggine

Rust fornisce cicli per attività ripetitive. Rust ha tre tipi principali di loop: ciclo continuo, Mentre, E per loop.

IL ciclo continuo parola chiave crea un ciclo infinito che viene eseguito finché non incontra una parola chiave break:

fnprincipale() {
ciclo continuo {
stampa!("stampato ripetutamente finché non si incontra l'istruzione break.");
rottura;
 }
}

IL Mentre loop è utile quando vuoi ripetere un blocco di codice fintanto che una condizione restituisce true:

fnprincipale() {
permetteremut contare = 0;
Mentre contare < 5 {
stampa!("Il conteggio è {}", contare);
 contare += 1;
 }
}

UN per loop è utile per l'iterazione su una raccolta di elementi, come un array:

fnprincipale() {
permettere numeri = [1, 2, 3, 4, 5];
per articolo In numeri.iter() {
stampa!("L'elemento corrente è {}", articolo);
 }
}

Questo per ciclo itera attraverso il numeri array e stampa ciascun elemento sulla console.

Dichiarare e chiamare funzioni Rust

Usa il fn parola chiave a dichiarare una funzione Rust, seguito dal nome della funzione, un elenco di parametri e un tipo restituito (se presente).

Ecco come puoi dichiarare una funzione con parametri e un tipo restituito:

fnaggiungere(UN: io32, B: io32) -> io32 {
ritorno a+b;
}

IL aggiungere La funzione accetta due numeri interi a 32 bit e restituisce un numero intero a 32 bit, la somma dei due parametri.

Per chiamare una funzione da un'altra parte del codice, è sufficiente specificare il nome e gli argomenti (se presenti):

fnprincipale() {
permettere risultato = aggiungi(2, 3);
stampa!("2 + 3 = {}", risultato);
}

IL risultato La variabile contiene il risultato della chiamata a aggiungere funzione. IL principale la funzione stampa il risultato sulla console usando il stampa! macro.

Strutture in Ruggine

Rust fornisce strutture per la definizione di tipi di dati personalizzati che raggruppano valori correlati. Le strutture sono progetti per la creazione di oggetti con proprietà specifiche.

Ecco come puoi dichiarare una struttura:

structPersona {
 nome: Corda,
 età: u32,
 è_maschio: bool,
}

IL Persona struct ha tre campi: una stringa, un numero intero senza segno a 32 bit e un valore booleano.

Dopo aver definito una struttura, puoi crearne istanze in altre parti del tuo programma:

fnprincipale() {
permettere persona1 = Persona {
 nome: Corda::da("Candace Flynn"),
 età: 16,
 è_maschio: falso,
 };
}

IL persona1 variabile è un'istanza di Persona struct. Durante la creazione di un'istanza, è possibile assegnare valori ai campi struct. Puoi creare tutte le istanze di una struttura che desideri.

Puoi implementare concetti OOP in Rust

Rust è flessibile e puoi implementare i concetti OOP in Rust con strutture dati integrate come struct.

Utilizzerai le strutture come alternativa alle classi. Con la struttura di Rust, puoi definire un progetto per il tipo e implementare i diversi concetti OOP con le funzionalità fornite da Rust sulle strutture.