Los lenguajes de programación difieren en la forma en que manejan la memoria y hacen cumplir las reglas de administración de la memoria. Go y Python emplean recolectores de basura para que los desarrolladores puedan concentrarse en escribir código. C y C++ otorgan a los programadores la responsabilidad de administrar la memoria en un nivel inferior.
Rust trata la gestión de la memoria de manera diferente, utilizando conceptos que llama propiedad y préstamo. Utiliza un "verificador de préstamo" para hacer cumplir la seguridad de la memoria de manera eficiente.
¿Qué es la propiedad?
La propiedad es una característica y convención de Rust que ayuda a garantizar la seguridad de la memoria de los programas sin un recolector de basura. Es otra forma de abordar el problema de las pérdidas de memoria en tu código.
El compilador de Rust verifica si un programa obedece las reglas de propiedad en el momento de la compilación. Si el programa sigue estas reglas, puede ejecutarse. Si no es así, el compilador se niega a producir un ejecutable.
Rust verifica las reglas de propiedad usando el prestador de cheques. El verificador de préstamo verifica el modelo de propiedad y decide si un valor en la memoria (pila o montón) está fuera del alcance o no. Si un valor está fuera de su alcance, no es accesible para otras partes del programa a menos que se tome prestado.
Las reglas de propiedad
En Rust, cada variable posee el valor con el que se inicializa y solo puede haber un propietario. Una vez que el propietario está fuera del alcance, el valor se descarta. Es importante entender los detalles de las reglas de propiedad.
La primera regla de propiedad es que cada variable posee su valor inicializado.
dejar propietario = Cuerda::de uno");
los dueño la variable anterior posee la cadena una y, a diferencia de lenguajes como Python y Go, ese valor se eliminará en la reasignación de variables.
La segunda regla de propiedad es que dos variables no pueden apuntar a la misma ubicación de memoria; cada valor puede tener un solo propietario.
dejar nuevo_propietario = propietario;
los Nuevo dueño La variable ahora posee el valor almacenado en la ubicación de memoria del dueño variable. Si intenta utilizar el dueño variable, el compilador entrará en pánico y se negará a generar un ejecutable.
En la mayoría de los lenguajes que usan recolectores de basura, dos variables pueden apuntar a la misma ubicación de memoria. Aquí hay un ejemplo de código JavaScript equivalente:
dejar propietario = "propietario";
dejar nuevo_propietario = propietario;
consola.log (nuevo_propietario);
Ejecutar el código JavaScript anterior funciona sin errores, y si hace lo mismo en Go o Python, su programa también funcionará sin errores.
La tercera regla de propiedad es que una vez que una variable está fuera del alcance declarado, el valor se elimina y la memoria se desasigna.
// una variable en un ámbito separado
{
dejar ejemplo = Cuerda::from("Aquí hay un nuevo alcance");
}
¡impresión!("{}", ejemplo)
No puede acceder a la ejemplo variable fuera de su alcance; intentar hacerlo hará que el compilador entre en pánico.
Propiedad en Funciones
Cuando pasa un valor a una función como argumento, la función puede acceder a esa variable aunque no se haya declarado en su alcance:
fnimpresora(valor: Cuerda) -> Cuerda {
devolver valor
}fnprincipal() {
dejar x = Cuerda::from("Imprime un valor"); // x posee el valor de la cadena
// la propiedad se traslada a la función de impresora aquí
¡impresión!("{} Los Resultado de Imprimir X es que -:", impresora (x));
}
La función puede acceder a esa variable porque Rust transfiere su propiedad a la función en el momento de la compilación.
Podría pensar que aún es posible usar la variable más adelante en su alcance original:
fnimpresora(valor: Cuerda) -> Cuerda {
devolver valor
}fnprincipal() {
dejar x = Cuerda::from("Imprime un valor");
¡impresión!("{} Los Resultado de Imprimir x es que -:", impresora (x));
// Tratando de usar la variable después de que se haya transferido la propiedad de su valor
imprimir!("{} no debería ser accesible", x)
}
Pero si intenta esto, el compilador entrará en pánico y se negará a producir un ejecutable:
Rust da prioridad a la reutilización del código
La reutilización de código es una práctica esencial, pero para practicar la reutilización de código, debe comprender las reglas de propiedad de Rust.
Rust es un lenguaje de programación muy flexible. Proporciona conceptos como préstamo, movimiento, copia y propiedad de clonación para la reutilización variable.