Introducción al lenguaje de programación Rust

Rust es un lenguaje compilado estático ultrarrápido y eficiente en memoria con un sistema de tipo rico y un modelo de propiedad. Se puede utilizar para potenciar los servicios críticos para el rendimiento al tiempo que garantiza la seguridad de la memoria y de los subprocesos, lo que permite a los desarrolladores depurar en tiempo de compilación. Además de eso, Rust tiene una excelente documentación y un compilador fácil de usar con herramientas de primer nivel como administradores de paquetes integrados y multieditor con características como inspección de tipos y finalización automática. Rust previene todos los bloqueos, y es muy interesante que rust sea seguro por defecto como JavaScript, Ruby y Python. Esto es mucho más poderoso que C/C++ porque no podemos escribir el código paralelo incorrecto, nunca se puede ver la falla en el rust. Es muy rápido en la representación de una gran cantidad de paradigmas de programación muy bien. 

Pero surge la pregunta, ya que existen tantos lenguajes de programación como Python, C++, Java, etc., entonces, ¿por qué es necesario desarrollar un nuevo lenguaje de programación? La respuesta a esto es que el otro lenguaje de programación tiene mucho control sobre el hardware que está ejecutando, puede optimizarlo bien, traducirlo directamente a código ensamblador, pero no es muy seguro.

Entonces, rust nos proporciona todos los controles que podemos tener y todos los niveles de seguridad que podemos lograr.

Rust está usando Rust , lo que significa que todo el compilador estándar, las bibliotecas están escritas en Rust, hay un poco de uso del lenguaje de programación C, pero la mayoría de ellas es Rust. El gran proyecto de Rust es «servo» , es un proyecto para escribir el motor de diseño totalmente paralelo como cosas como un gecko como Firefox o WebKit en safari.

Servo construyó el motor de diseño algo para representar HTML de abajo hacia arriba.

Funciones en Rust:

Las funciones son el bloque de código reutilizable que puede realizar acciones relacionadas similares. Ya has visto una de las funciones más importantes del lenguaje: la función principal, que es el punto de entrada de muchos programas. También ha visto la palabra clave «fn», que le permite declarar nuevas funciones. El código de Rust usa el formato de serpiente como el estilo convencional para los nombres de funciones y variables. En el caso de la serpiente, todas las letras están en minúsculas y subrayan palabras separadas.

Sintaxis:

fn functionname(arguments){
  code
}

• Para crear una función necesitamos usar la palabra clave fn.
• El nombre de la función se escribe después de la palabra clave fn
• Los argumentos se pasan después del nombre de la función entre paréntesis
• Puede escribir el código de función en el bloque de funciones

Ejemplo: la siguiente función simplemente imprime “¡Hola, mundo!” en la consola:

fn main() {
   println!("Hello, world!");
}

Producción:

Hello, World!

Concepto de propiedad:

El concepto de propiedad es que cuando tienes algo puedes decidir pasárselo a otra persona, si tienes un libro y lo has terminado de leer puedes dárselo permanentemente a alguien y no preocuparte por eso. 

fn helper() -> Box<int> {
let three = box 3;
return three; //transfer ownership
}
fn main() {
// acquire ownership of return value
let my_three = helper();
}

Concepto de endeudamiento:

Los valores propios en rust se pueden tomar prestados para permitir su uso durante un cierto período de tiempo. El signo «&» representa la referencia prestada. Los valores prestados tienen una vida útil y son válidos solo durante ese tiempo. El endeudamiento impide moverse. Mientras haya un préstamo activo no puedo transferir la propiedad. Todavía lo tengo, pero no puedo transferirlo hasta que lo entregué para renunciar realmente a lo prestado. 

let a: ∫
{
let b =3; //b lifetime is not same as a
a =&b;
}  //

Aquí «a» y «b» tienen una vida útil diferente, por lo que no funcionará.

let a: ∫
let b=3;  // a and b have same lifetime
a = &b;

Aquí «a» y «b» tienen la misma vida, así que funcionará. Préstamo se puede anidar. A través de la clonación, los valores prestados pueden convertirse en propiedad.

Gestión de memoria en Rust:

1. Rust tiene una administración de memoria de grano fino, pero se administra automáticamente una vez que se crea.
2. En Rust, cuando asigna memoria, nunca tiene que liberarla realmente, puede decidir cuándo liberarla, pero nunca llamarla. Rust se encarga de eso automáticamente.
3. Cada variable tiene un alcance para el que es válida y se desasigna automáticamente una vez que sale del alcance.
4. En rust, a cada programa se le asigna memoria desde el sistema operativo.
5. Rust también tiene una memoria compartida donde podemos tener un dato de referencia, podemos usar la propiedad para realizar un seguimiento del recuento de referencias.

Memoria diferente:

Montón:

• Es el bloque de memoria más grande y está administrado por el modelo de propiedad de rust.
• En este lugar, se almacenan todos los datos dinámicos.

Pila:

• Todos los valores en rust se asignan en la pila.
• En este momento, la memoria estática se asigna de forma predeterminada.
• Hay una pila por subproceso.
• Incluye estructuras y punteros a datos dinámicos.

Mutabilidad:

Los valores en rust son inmutables de forma predeterminada y deben etiquetarse como mutables (si es necesario).

Ejemplo:

let x = 2;
x = 9; //it will show an error

El ejemplo anterior mostrará un error porque no lo hemos etiquetado como mutable.

let mut x = 2;
x = 9;  //work correctly

Esto funcionará bien ya que lo hemos etiquetado como mutable. Como en este caso lo estamos mutando explícitamente.

Estructura en Rust

La estructura es un tipo de datos definido por el usuario en rust que se usa para combinar diferentes elementos de datos de un tipo diferente. La estructura define los datos como un par clave-valor. La palabra clave struct se usa para definir estructuras en Rust.

Sintaxis: 

struct Name_of_structure {
  field1:data_type,
  field2:data_type,
  field3:data_type
}

Ejemplo:

struct Employee {
  name: String,
  company: String,
  employee_id: u32,
  profile: String
 
}
fn main() {
  let value = Employee {
    name: String::from("Geek"),
    company: String::from("Geeksforgeeks.org"),
    employee_id: 007,
    profile:String::from("Manager"),
 
  };
  println!("Employee: {} of {} Company bearing EmployeeID {} is of {} level.",
    value.name,
    value.company,
    value.employee_id,
    value.profile);
}

Producción:

Employee: Geek of Geeksforgeeks.org Company bearing EmployeeID 7 is of Manager level.

Este es un ejemplo de cómo creamos estructuras en rust. Esto compilará perfectamente.

Tupla:

Una tupla en rust es un tipo de datos compuesto heterogéneo finito , lo que significa que puede almacenar más de un valor a la vez. En las tuplas, no hay un método incorporado para agregar elementos a una tupla. Podemos usar el índice para obtener el valor de una tupla, y tampoco podemos iterar sobre una tupla usando for loop.

Las tuplas en Rust se definen usando corchetes pequeños como se muestra a continuación:

Syntax: ("geeksforgeeks", 1, 'geek')

Ejemplo:

// Rust program to get value from tuple
// using index
fn main() {
    let gfg = ("cp", "algo", "FAANG", "Data Structure");
    
      // complete tuple
    println!("complete tuple = {:?} ", gfg );
    
      // first value
    println!("at 0 index = {} ", gfg.0 );
    
      // second value
    println!("at 0 index = {} ", gfg.1 );
    
      // third value
    println!("at 0 index = {} ", gfg.2 );
    
      // fourth value
    println!("at 0 index = {} ", gfg.3 );
}

Producción:

complete tuple = ("cp", "algo", "FAANG", "Data Structure") 
at 0 index = cp 
at 0 index = algo 
at 0 index = FAANG 
at 0 index = Data Structure 

Sistema de tipo de rust:

En Rust, cada variable, valor y elemento tiene un tipo. El tipo define cuánta memoria contiene y qué operación se puede realizar en el valor. La siguiente tabla indica todos los tipos en Rust:

Ventajas y desventajas del rust:

ventajas:

1. Depuración y prueba rápidas: Rust es un lenguaje muy rápido y admite una depuración rápida y efectiva.
2. Rust admite código más complejo en comparación con otros lenguajes, por lo que podemos lograr más con menos código.
3. Permite el desarrollo multiplataforma.
4. Facilidad de integración: Rust se puede integrar fácilmente con C y muchos otros lenguajes de programación famosos.
5. Rust es más seguro que otros lenguajes de programación.
6. Existe una amplia comunidad de desarrolladores que admiten Rust.

Desventajas:

1. Debido a la complejidad, puede llevar más tiempo aprender Rust.
2. En rust, el código puede ser menos eficiente y también lleva más tiempo compilarlo.
3. Como es más complejo, puede llevar más tiempo completar las aplicaciones escritas en Rust.
4. Es un lenguaje nuevo, por lo que llevará más tiempo extenderse y es posible que los trabajos en rust no sean tantos como en otros lenguajes de programación populares.
5. En algunos casos, el rust puede perder memoria y volverse más lento que un lenguaje de programación popular.
6. Difícil de mantener debido a su gran base de código.