I linguaggi di programmazione differiscono nel modo in cui gestiscono la memoria e applicano le regole di gestione della memoria. Go e Python utilizzano Garbage Collector, così gli sviluppatori possono concentrarsi sulla scrittura del codice. C e C++ danno ai programmatori la responsabilità di gestire la memoria a un livello inferiore.
Rust tratta la gestione della memoria in modo diverso, utilizzando concetti che chiama proprietà e prestito. Utilizza un "controllo prestito" per rafforzare la sicurezza della memoria in modo efficiente.
Che cos'è la proprietà?
La proprietà è una caratteristica e una convenzione di Rust che aiuta a garantire la sicurezza della memoria dei programmi senza un Garbage Collector. È un altro modo di affrontare il problema delle perdite di memoria nel tuo codice
Il compilatore Rust controlla se un programma obbedisce alle regole di proprietà in fase di compilazione. Se il programma segue queste regole, può essere eseguito. In caso contrario, il compilatore si rifiuta di produrre un eseguibile.
Rust verifica le regole di proprietà utilizzando il prendere in prestito controllore. Il controllore di prestito verifica il modello di proprietà e decide se un valore in memoria (impilare o accumulare) è fuori campo o meno. Se un valore è fuori dal suo ambito, non è accessibile ad altre parti del programma a meno che non sia preso in prestito.
Le regole di proprietà
In Rust, ogni variabile possiede il valore con cui è inizializzata e può esserci un solo proprietario. Una volta che il proprietario è fuori dall'ambito, il valore viene eliminato. È importante comprendere i dettagli delle regole di proprietà.
La prima regola di proprietà è che ogni variabile possiede il suo valore inizializzato.
permettere proprietario = Corda::Da uno");
Il proprietario la variabile sopra possiede la stringa uno e, a differenza di linguaggi come Python e Go, quel valore verrà eliminato durante la riassegnazione delle variabili.
La seconda regola di proprietà è che due variabili non possono puntare alla stessa posizione di memoria; ogni valore può avere un solo proprietario.
permettere nuovo_proprietario = proprietario;
Il nuovo proprietario La variabile ora possiede il valore memorizzato nella posizione di memoria di proprietario variabile. Se provi ad usare il proprietario variabile, il compilatore andrà nel panico e si rifiuterà di generare un eseguibile.
Nella maggior parte delle lingue che utilizzano Garbage Collector, due variabili possono puntare alla stessa posizione di memoria. Ecco un esempio di codice JavaScript equivalente:
permettere proprietario = "proprietario";
permettere nuovo_proprietario = proprietario;
consolle.log (nuovo_proprietario);
L'esecuzione del codice JavaScript sopra funziona senza errori e, se fai lo stesso in Go o Python, anche il tuo programma funzionerà senza errori.
La terza regola di proprietà è che una volta che una variabile è fuori dall'ambito dichiarato, il valore viene eliminato e la memoria viene deallocata.
// una variabile in un ambito separato
{
permettere esempio = Corda::from("Ecco un nuovo ambito");
}
Stampa!("{}", esempio)
Non puoi accedere al esempio variabile al di fuori del suo ambito; provare a farlo causerà il panico nel compilatore.
Proprietà nelle funzioni
Quando si passa un valore a una funzione come argomento, la funzione può accedere a quella variabile anche se non è stata dichiarata nel suo ambito:
fnstampante(valore: Corda) -> Corda {
Restituzione valore
}fnprincipale() {
permettere x = Corda::from("Stampa un valore"); // x possiede il valore della stringa
// la proprietà viene spostata qui nella funzione stampante
Stampa!("{} Il Risultato di Stampa X è che -:", stampante (x));
}
La funzione può accedere a quella variabile perché Rust ne sposta la proprietà alla funzione in fase di compilazione.
Potresti pensare che sia ancora possibile utilizzare la variabile in un secondo momento nel suo ambito originale:
fnstampante(valore: Corda) -> Corda {
Restituzione valore
}fnprincipale() {
permettere x = Corda::from("Stampa un valore");
Stampa!("{} Il Risultato di Stampa x è che -:", stampante (x));
// Tentativo di utilizzare la variabile dopo che la proprietà del suo valore è stata trasferita
stampa!("{} non dovrebbe essere accessibile", x)
}
Ma se provi questo, il compilatore andrà nel panico e si rifiuterà di produrre un eseguibile:
Rust dà la priorità alla riutilizzabilità del codice
La riutilizzabilità del codice è una pratica essenziale, ma per esercitarsi sulla riutilizzabilità del codice è necessario comprendere le regole di proprietà di Rust.
Rust è un linguaggio di programmazione molto flessibile. Fornisce concetti come prendere in prestito, spostare, copiare e clonare la proprietà per il riutilizzo delle variabili.
