Rust – Array

AN Array en la programación de Rust es una colección de elementos de tamaño fijo indicada por [T; N] donde T es el tipo de elemento y N es el tamaño constante de tiempo de compilación de la array.

Podemos crear una array de 2 maneras diferentes:

1. Simplemente una lista con cada elemento [a, b, c].
2. Repita la expresión [N, X]. Esto creará una array con N copias de X.

[X,0] está permitido, pero puede causar algunos problemas frenéticos, por lo que si usa este tipo de expresión, tenga en cuenta los efectos secundarios. El tamaño de array de 0 a 32 implementa el rasgo predeterminado si su tipo lo permite. Las implementaciones de rasgos son de hasta 32 tamaños. Una array no es iterable en sí misma.

Sintaxis:

ArrayType : [ Type ; Expression ]

Una array se escribe como:

let array: [i32; 3] = [4, 5, 6];

Características de una array:

Las características de una array se enumeran a continuación:

• Los bloques de memoria en la array están en orden secuencial.
• Una vez que se crea una array, no se puede cambiar su tamaño, lo que significa que la array es estática.
• El elemento de la array está representado por el bloque de memoria.
• Para identificar los elementos de la array, usamos un número entero único conocido como subíndice.
• Poner valores en el elemento de la array se conoce como inicialización de la array.
• Los valores del elemento de array se pueden actualizar o modificar, pero no se pueden eliminar.

Declaración e inicialización de arrays:

Los impuestos adicionales que se indican a continuación se pueden usar para declarar e inicializar una array en Rust:

Syntax1: let variable_name = [value_1,value_2,value_3];

Syntax2: let variable_name:[dataType;array_size] = [value_1,value_2,value_3];

Syntax3: let variable_name:[dataType;array_size] = [default_value_for_elements,array_size];

El valor del tipo de datos se obtiene del tipo de datos de la primera variable de la array.

Imprimir elementos de un Simple Array

 Para imprimir todos los valores en la array, use la sintaxis {:?} de la función println!() . Para calcular el tamaño de la array podemos usar la función len() .

Ejemplo 1: Elementos de impresión en la array

#![allow(unused)]
fn main() {
let mut array: [i32; 5] = [0; 5];
  
array[1] = 1;
array[2] = 2;
array[3] = 3;
array[4] = 4;
assert_eq!([1, 2 , 3 ,4], &array[1..]);
  
// This loop prints: 0 1 2 3 4
for x in &array {
   print!("{} ", x);
}
}

Producción: 

0 1 2 3 4

Ejemplo 2: Elementos de impresión en la array

fn main(){
  let arr:[i32;5] = [1,2,3,4,5];
  println!("array is {:?}",arr);
  println!("array size is :{}",arr.len());
}

Producción:

array is [1, 2, 3, 4, 5]
array size is :5

Trabajar con arreglos sin tipo de datos:

El siguiente programa declara una array de 5 elementos. Aquí no estamos definiendo explícitamente el tipo de datos durante la declaración de variables. Entonces, la array será de tipo entero. Para calcular el tamaño de la array podemos usar la función len().

fn main(){
  let arr = [1,2,3,4,5];
  println!("array is {:?}",arr);
  println!("array size is :{}",arr.len());
}

Producción:

array is [1, 2, 3, 4, 5]
array size is :5

Valores predeterminados de la array:

Vamos a crear una array e inicializar todos los valores con el valor predeterminado 0.

fn main() {
  let gfg_array:[i32;5] = [0;5];
  println!("array is {:?}",gfg_array);
  println!("array size is :{}",gfg_array.len());
}

Producción:

array is [0, 0, 0, 0, 0]
array size is :5

Trabajando con bucles en Array:

El siguiente ejemplo itera a través de una array e imprime los índices y sus valores correspondientes. El bucle recupera valores del índice 0 al 4 (índice del último elemento de la array).

En este ejemplo, un bucle itera una array e imprime el índice y el valor. Loop recupera el valor de 0 a 5

fn main(){
  let gfg_array:[i32;5] = [1,2,3,4,5];
  println!("array is {:?}",gfg_array);
  println!("array size is :{}",gfg_array.len());
  
  for index in 0..5 {
     println!("index is: {} & value is : {}",index,gfg_array[index]);
  }
}

Producción:

array is [1, 2, 3, 4, 5]
array size is :5
index is: 0 & value is : 1
index is: 1 & value is : 2
index is: 2 & value is : 3
index is: 3 & value is : 4
index is: 4 & value is : 5

Usando la función iter() en Arrays:

La función iter() obtiene valores de todos los elementos de una array.

fn main(){
  
let arr:[i32;5] = [1,2,3,4,5];
  println!("array is {:?}",arr);
  println!("array size is :{}",arr.len());
  
  for val in arr.iter(){
     println!("value is :{}",val);
  }
}

Producción:

array is [1, 2, 3, 4, 5]
array size is :5
index is: 0 & value is : 1
index is: 1 & value is : 2
index is: 2 & value is : 3
index is: 3 & value is : 4
index is: 4 & value is : 5

Concepto de array mutable:

Para declarar la array mutable usamos la tecla » mut «. Los arreglos mutables son aquellos arreglos cuyos elementos pueden ser alterados. Vea el siguiente ejemplo para una mejor comprensión.

fn main(){
  let mut arr:[i32;5] = [1,2,3,4,5];
  arr[1] = 0;
  println!("{:?}",arr);
}

Producción:

[1, 0, 3, 4, 5]

Hemos actualizado el valor de la array en el número de índice «1» e imprimimos el valor.

Pasar arrays como parámetros a funciones:

Podemos pasar una array como parámetro mediante una llamada por valor o una llamada por referencia a una función.

Ejemplo 1: pasar por valor

fn main() {
  let gfg_array = [1,2,3,4];
  change_array(gfg_array);
  
  print!("Original array {:?}",gfg_array);
}
fn change_array(mut gfg_array:[i32;4]){
  for i in 0..4 {
     gfg_array[i] = 0;
  }
  println!("Changed array {:?}",gfg_array);
}

Producción:

Changed array [0, 0, 0, 0]
Original array [1, 2, 3, 4]

Ejemplo 2: Pasar por referencia

#![allow(unused)]
  
fn main() {
  let mut gfg_array = [1,2,3,4,5];
  change_array(&mut gfg_array);
  print!("Original array {:?}",gfg_array);
}
fn change_array(gfg_array:&mut [i32;5]){
  for i in 0..5 {
     gfg_array[i] = 0;
  }
  println!("Changed array {:?}",gfg_array);
}

Producción:

Changed array [0, 0, 0, 0, 0]
Original array [0, 0, 0, 0, 0]