Array di ruggine
Questo articolo esplorerà come possiamo creare e utilizzare array nel linguaggio di programmazione ruggine.
Array di ruggine
In Rust, come la maggior parte dei linguaggi di programmazione, rappresentiamo un array di una coppia di parentesi quadrate. La ruggine richiede che le dimensioni di un array siano conosciute prima della compilazione. Se la dimensione di un array non è definita al momento della compilazione, questa è nota come una fetta.
Crea array di ruggine
Esistono due modi principali per creare array in ruggine:
Aggiungendo gli elementi dell'array a una coppia di staffe quadrate. Questo è il metodo di creazione di array più semplice e comune. Possiamo esprimere la sintassi per questo metodo di creazione dell'array come mostrato:
Let Array_Name: [F64, 3] = [3.141, 100.2443, 223.554]Quanto sopra crea un array con il nome della variabile "Array_name". Nel nostro caso, l'array contiene valori a punta mobile firmati a 64 bit come specificato dal valore F64. La dimensione dell'array è 3. Ciò significa che può contenere fino a 3 elementi.
Ci riferiamo al secondo metodo per creare un array come un'espressione ripetuta. La sintassi è come [n, x] in cui l'array contiene il valore di x viene copiato n volte.
Rust Dichiara l'array
Esistono vari tipi di array in ruggine. Ogni tipo è determinato dal metodo di dichiarazione utilizzato. I seguenti sono gli array e come dichiararli.
Array senza dimensioni e tipo
Il primo tipo di array è uno senza dimensioni e tipo. Questo è un metodo molto utile per le operazioni di array rapidi.
Per dichiarare un array senza tipo o dimensione, utilizzare la sintassi come mostrato di seguito:
let Array_name = [Elements];Qui, usiamo la parola chiave let, seguita dal nome della variabile. Successivamente, utilizziamo l'operatore di assegnazione, seguito dagli elementi dell'array all'interno di una coppia di staffe quadrate.
Un esempio è come mostrato:
Siar = [1,2,3];Il compilatore determina il tipo di array in base agli elementi memorizzati in esso. Il numero totale di elementi nell'array diventa la sua dimensione.
Array con tipo e dimensione
Il secondo tipo di array è uno con un tipo e una dimensione durante la dichiarazione. Per questo tipo di array, impostiamo il tipo di dati degli elementi che desideriamo archiviare nell'array e quanti elementi si terrà l'array.
La sintassi per questa creazione di array è come mostrato di seguito:
let Array_name: [data_type; array_size] = [array_elements];Un esempio è come mostrato di seguito:
fn main ()ARR: [i32; 3] = [1,2,3];
Quanto sopra crea un array chiamato "arr" che contiene interi firmati a 3, 32 bit.
Array con valori predefiniti
Il terzo tipo di array in ruggine è uno che contiene un valore predefinito. In questo tipo di array, tutti gli elementi nell'array contengono un unico valore identico che puoi aggiornare come si vede adatta.
La sintassi è come mostrata:
let Array_name: [data_type; array_size] = [default_value; array_size];Un esempio di tale array è come mostrato:
fn main ()ARR: [&str; 3] = ["nil"; 3];
L'esempio sopra crea un array di & STR e taglia 3. Includiamo anche un valore predefinito, "zero". Quindi, tutti e tre gli elementi nell'array manterranno il valore predefinito se non aggiornato.
Array di stampa ruggine
Possiamo stampare un array usando la stampa! macro e tratto di debug nella std :: fmt. Un esempio è come mostrato:
fn main ()ARR: [&str; 3] = ["nil"; 3];
println!(":? ", arr);
Il codice sopra deve stampare l'array come mostrato:
Indicizzazione dell'array di ruggine
Sebbene possiamo stampare l'intero array usando il tratto di debug dal modulo FMT, possiamo accedere a singoli elementi dall'array usando il suo indice.
In ruggine, l'indicizzazione dell'array inizia a 0. Ciò significa che il primo elemento nell'array è all'indice 0 e il secondo è all'indice 1 e così via.
Per accedere a un elemento dal suo indice, utilizziamo il nome dell'array seguito dall'indice dell'elemento, desideriamo accedere all'interno di una coppia di parentesi quadrate.
Un esempio è come mostrato:
fn main ()ARR: [&str; 3] = ["nil"; 3];
println!("", arr [0]);
L'esempio sopra dovrebbe essere l'elemento in indice 0 o il primo elemento nell'array.
Per ottenere l'ultimo elemento nell'array, usiamo la lunghezza dell'array - 1 dall'indicizzazione inizia a 0.
Un esempio è come mostrato:
fn main ()let database: [&str; 3] = ["Mysql", "MongoDB", "SQL Server"];
println!("", database [database.len () - 1]);
Nell'esempio sopra, utilizziamo la funzione Len () per ottenere la lunghezza dell'array. Questa funzione integrata restituisce la lunghezza (numero di elementi) nell'array.
Il programma sopra dovrebbe restituire l'elemento all'indice 2 come:
Rust iterazione sull'array
Un'altra operazione comune quando si lavora con le matrici è iterare su ciascun elemento nell'array. In Rust, possiamo raggiungere questo obiettivo usando un loop per.
Un esempio è come mostrato di seguito:
fn main ()let database: [&str; 3] = ["Mysql", "MongoDB", "SQL Server"];
per i in 0 ... database.len ()
println!("Indice: , elemento: ", i, database [i]);
Il programma di esempio sopra utilizza un ciclo semplice per iterare sugli elementi nell'array. Per ottenere il numero di elementi nell'array, possiamo usare la funzione Len (). All'interno del loop, accediamo a ciascun elemento in base all'indice.
I valori risultanti sono come mostrati:
Mutabilità dell'array di ruggine
Come tutte le variabili in ruggine, gli array sono immutabili per impostazione predefinita. Quindi, il tentativo di cambiare l'array causerà un errore.
Un esempio è come mostrato:
fn main ()let database: [&str; 3] = ["Mysql", "MongoDB", "SQL Server"];
Database [0] = "PostgreSQL";
Il programma sopra tenta di modificare il valore dell'elemento all'indice 0. L'esecuzione del codice sopra restituirà un errore come mostrato:
Possiamo impostare l'array su mutabile usando la parola chiave MUT per evitare questo errore. Il codice è come mostrato di seguito:
Let Database MUT: [&str; 3] = ["Mysql", "MongoDB", "SQL Server"];Questo rende l'array mutabile, permettendoti di modificarne i valori come si vede opti.
Conclusione
Questo articolo ha esplorato come creare e utilizzare array in ruggine. Tieni presente che gli array possono essere ampliati per fare molto di più. Considera i documenti Rust per ulteriori informazioni.