Variabili ruggine

Nella programmazione, una variabile si riferisce a un contenitore di archiviazione utilizzato per archiviare i valori. In poche parole, una variabile è una posizione di archiviazione denominata in cui il programma può archiviare e recuperare i dati. Sebbene il concetto fondamentale di una variabile sia universale tra i linguaggi di programmazione, la ruggine tratta le variabili in modo leggermente diverso.

In ruggine, una variabile è associata a un tipo specifico. Il compilatore utilizzerà il tipo di dati per determinare il layout della memoria della variabile e lo spazio per allocare alla variabile.

In questa corsa, esploreremo come lavorare con variabili in ruggine e come usarle per archiviare vari tipi di informazioni.

Nomina variabile della ruggine

Come accennato, una variabile è una posizione di archiviazione denominata all'interno di un programma. Ciò significa che dobbiamo creare un identificatore che altre parti del programma possono fare riferimento.

Sebbene denominare qualcosa come variabile possa sembrare molto banale, ci sono alcune regole a cui aderiamo.

Questi includono:

• Un nome variabile non può iniziare con una cifra o caratteri speciali a parte un sottolineaggio.
• Un nome può essere composto da caratteri alfanumerici minuscole o maiuscole o sottolineate.
• I nomi delle variabili sono sensibili al caso in ruggine. Quindi, l'età e l'età delle variabili non sono le stesse.
• Sebbene non sia un requisito, le regole di denominazione della ruggine definiscono una variabile locale che dovrebbe utilizzare una custodia di serpente per unire i nomi. Ad esempio, totali_points anziché totali.

Quanto sopra sono alcune regole di denominazione a cui aderire quando si nomina una variabile. Puoi controllare le regole di denominazione della ruggine nella risorsa seguente:

https: // ruggang.github.IO/API-GUIDELINES/NAMING.html

Dichiarazione variabile Rust

Possiamo dichiarare una variabile usando la parola chiave Let o const. Dopo la parola chiave let, impostiamo il nome della variabile e del suo tipo di dati.

La sintassi è come mostrata:

let variabile_name: type;

Un programma di esempio con dichiarazione variabile è come mostrato:

fn main ()
Lascia l'URL:&str;

Il suddetto dichiara una variabile chiamata URL di tipo e STR.

Il tipo di annotazione in ruggine è facoltativo. Ciò significa che il compilatore può dedurre il tipo dal valore assegnato alla variabile.

Di seguito è mostrato un esempio di dichiarazione variabile senza annotazione del tipo:

fn main ()
let url = "https: // linuxhint.com ";

La parola chiave const in ruggine consente di definire le variabili delle costanti. A differenza della parola chiave let, è necessario eseguire l'annotazione del tipo quando si utilizza la parola chiave const.

Un esempio è come mostrato:

fn main ()
const url: & str = "https: // linuxhint.com ";

Non possiamo modificare il valore di un valore costante più avanti nel programma dopo la dichiarazione. Una costante vivrà anche per la vita del programma e non ha un indirizzo di memoria fissa.

NOTA: Le costanti sono fondamentalmente immutabili, a differenza di non supportano la parola chiave mut. Controlla le sezioni di mutabilità variabile per saperne di più.

Secondo: Il valore di una costante deve essere, beh, costante. Non impostare il valore di una variabile const su un'espressione da valutare in fase di esecuzione.

Terzo: Sebbene seguano le regole della denominazione variabile. Le costanti usano Screaming_Snake_Case per i loro nomi.

Mutabilità variabile della ruggine

In ruggine, le variabili sono oggetti immutabili per impostazione predefinita. Ciò significa che non possiamo modificare i loro valori dopo la dichiarazione.

Prendi l'esempio di seguito:

fn main ()
let url = "https: // linuxhint.com ";
url = "https: // google.com ";

Se compiliamo il codice sopra, dovremmo ottenere un errore come mostrato di seguito:

L'output sopra mostra che il compilatore non consente la riassegnazione delle variabili per impostazione predefinita.

Tuttavia, Rust ti consente di creare variabili mutabili. È possibile utilizzare la parola chiave MUT durante la dichiarazione della funzione per renderla mutabile.

Considera l'esempio seguente:

fn main ()
let mut url = "https: // linuxhint.com ";
url = "https: // google.com ";

Il programma sopra crea una variabile mutabile chiamata URL. Ora possiamo riassegnare il suo valore più avanti nel programma.

Ombre variabile ruggine

Rust offre una funzione nota come ombra; Bene, la maggior parte dei Rustacei lo si riferisce a questo. È una funzionalità in cui è possibile dichiarare una variabile con lo stesso nome di una variabile che è già stata dichiarata e impostare un nuovo valore o un tipo per esso.

Mi piace pensarlo come un modo per introdurre mutabilità temporanea a una variabile.

Prendi il programma di esempio di seguito:

fnMain ()
leturl = "https: // linuxhint.com ";

// La seconda variabile ombre il primo
leturl = "https: // google.com ";
println!("", url);

println!("", url);

Nel programma sopra, dichiariamo una variabile immutabile chiamata URL nell'ambito globale. Creiamo quindi un ambito interno che ridisegna la variabile URL e le assegna un nuovo valore. La variabile URL nell'ambito interno ombreggia la variabile globale in questo caso.

Se eseguiamo il programma sopra, dovremmo ottenere un output come:

Tieni presente che l'ombra variabile differisce dalla mutabilità variabile. Questo è perché,

• Stiamo creando una nuova variabile quando si utilizzano la parola chiave let.
• Questa funzionalità è volatile e la funzione rimane immutabile ma con un nuovo valore.

Chiusura

Abbiamo esplorato come funzionano le variabili nel linguaggio di programmazione ruggine. Continua a praticare o controlla la documentazione per saperne di più.