Utiliza la palabra reservada Vec para tipar tu array y declarar uno nuevo. Hazlo mutable con mut para poder hacer un .push() y guardar un nuevo elemento dentro.
Finalmente, puedes imprimir todos los valores del vector con "{:?}" en un println!() como con cualquier otra variable.
Ciclo For en Rust
Así como puedes usar un loop para repetir la ejecución de un mismo código fuente, y detenerlo con break, también puedes crear un típico FOR como en cualquier otro lenguaje de programación. La principal diferencia está en que un loop puede ser infinito, mientras que un for la cantidad de iteraciones es finito.
Presta atención a su sintaxis:
fnmain(){for i in0..10{println!("Iteración número {}", i);}}
Aquí declaramos un for de 10 iteraciones y mostramos por consola el número de iteración.
Array y ciclos For
Los arrays, o vectores, y los ciclos de iteración for están muy relacionados, ya que puedes recorrer un array fácilmente con un for.
fnmain(){letmut my_arr:Vec<String>=Vec::new(); my_arr.push("¡Bienvenido".to_string()); my_arr.push("a".to_string()); my_arr.push("Platzi!".to_string());for word in my_arr {println!("{}", word);}}
Cada iteración del for, imprimirá cada valor del array.
También puedes acceder al valor individual de un array a través del índice del elemento:
Ahora ya conoces lo básico para trabajar con arrays, ciclos for y relacionar ambos en Rust. Tu conocimiento en el lenguaje continúa ampliándose y tienes más herramientas para desarrollar tus aplicaciones.
Utiliza la palabra reservada Vec para tipar tu array y declarar uno nuevo. Hazlo mutable con mut para poder hacer un .push() y guardar un nuevo elemento dentro.
Finalmente, puedes imprimir todos los valores del vector con "{:?}" en un println!() como con cualquier otra variable.
Ciclo For en Rust
Así como puedes usar un loop para repetir la ejecución de un mismo código fuente, y detenerlo con break, también puedes crear un típico FOR como en cualquier otro lenguaje de programación. La principal diferencia está en que un loop puede ser infinito, mientras que un for la cantidad de iteraciones es finito.
Presta atención a su sintaxis:
fn main() {
for i in 0..10 {
println!("Iteración número {}", i);
}
}
Aquí declaramos un for de 10 iteraciones y mostramos por consola el número de iteración.
Array y ciclos For
Los arrays, o vectores, y los ciclos de iteración for están muy relacionados, ya que puedes recorrer un array fácilmente con un for.
fn main() {
let mut my_arr: Vec<String> = Vec::new();
my_arr.push("¡Bienvenido".to_string());
my_arr.push("a".to_string());
my_arr.push("Platzi!".to_string());
for word in my_arr {
println!("{}", word);
}
}
Cada iteración del for, imprimirá cada valor del array.
También puedes acceder al valor individual de un array a través del índice del elemento:
Ahora ya conoces lo básico para trabajar con arrays, ciclos for y relacionar ambos en Rust. Tu conocimiento en el lenguaje continúa ampliándose y tienes más herramientas para desarrollar tus aplicaciones.
fn main() {
println!(" ----------");
println!(" Data table");
println!(" ----------");
let mut data_name:Vec<String> = Vec::new();
let mut data_last_name:Vec<String> = Vec::new();
let mut data_age:Vec<String> = Vec::new();
let mut data_country:Vec<String> = Vec::new();
let mut option_user:String = String::new();
loop {
let mut name:String = String::new();
let mut last_name:String = String::new();
let mut age:String = String::new();
let mut country:String = String::new();
println!("What is your name?");
std::io::stdin().read_line(&mut name).unwrap();
name = name.trim().to_string();
data_name.push(name);
println!("What is your last name?");
std::io::stdin().read_line(&mut last_name).unwrap();
last_name = last_name.trim().to_string();
data_last_name.push(last_name);
println!("How old are you?");
std::io::stdin().read_line(&mut age).unwrap();
age = age.trim().to_string();
data_age.push(age);
println!("Where are you from?");
std::io::stdin().read_line(&mut country).unwrap();
country = country.trim().to_string();
data_country.push(country);
loop {
println!("----------------------------------------");
option_user ="".trim().to_string();
println!("Press 'E' to exit or 'C' to continue...");
std::io::stdin().read_line(&mut option_user).unwrap();
option_user = option_user.trim().to_string();
println!("----------------------------------------");
if option_user == "E" || option_user == "e" || option_user == "C" || option_user == "c"{
break;
}
println!("'{}': It is not a valid option, try again", option_user);
}
if option_user == "E" || option_user == "e"{
break;
}
}
println!("Name Last name Age Country");
println!("-----------------------------------");
for i in 0..data_name.len(){
println!("{} {} {} {}",data_name[i], data_last_name[i], data_age[i],data_country[i]);
}
println!(" --------");
println!(" GOOD BYE");
println!(" --------");
}
Un array en Rust es una colección fija de elementos del mismo tipo, donde la longitud del array se especifica en tiempo de compilación y no puede ser modificada en tiempo de ejecución. Los arrays se definen utilizando la sintaxis [Tipo; longitud]. Por ejemplo, let mi_array: [i32; 5] = [1, 2, 3, 4, 5]; define un array de 5 elementos de tipo i32.
Por otro lado, un vector en Rust es una colección dinámica de elementos del mismo tipo, cuya longitud puede cambiar en tiempo de ejecución. Los vectores se definen utilizando la sintaxis Vec<Tipo>. Por ejemplo, let mi_vector: Vec<i32> = vec![1, 2, 3, 4, 5]; define un vector de 5 elementos de tipo i32.
En cuanto a su uso, los arrays son útiles cuando se sabe de antemano la cantidad exacta de elementos que se necesitan y no se espera que esta cantidad cambie. Los vectores, por otro lado, son útiles cuando la cantidad de elementos que se necesitan puede cambiar en tiempo de ejecución, o cuando se necesita agregar o eliminar elementos de manera eficiente.
fn main() {
let mut names: Vec<String> = Vec::new();
for i in 1..4 {
let mut name = String::new();
println!("Enter name #{}:", i);
std::io::stdin().read_line(&mut name).unwrap();
name = name.trim().to_string();
names.push(name);
}
// print the names one after the other
for name in names {
println!("Hello, {}!", name);
}
}
Los arrays son mejores en cuanto a rendimiento al momento de acceder a un valor, más eficiente en cuanto a memoria por tener un tamaño definido, incluso al no tener un sobrehead dinamico(que no lo tiene por no ser de tamaño dinámico).
Los vectores son buenos al momento de pensar en la flexibilidad porque su tamaño puede variar.
<use std::io::{stdin};
fn main() {
//fill array
fn fill_array(word:String){
//Vars
println!("---------------");
println!("List word");
let mut my_arr: Vec<String> = Vec::new();
my_arr.push(word.to_string());
for word in my_arr{
println!("{}", word);
}
println!("---------------");
}
//request user
fn request_user_word(){
println!("Insert word:");
let mut word:String = String::new();
stdin().read_line(&mut word).unwrap();
fill_array(word.to_string());
}
//Next sintaxis
fn array() {
let array = [0,1,2,3,4,5,6,7,8,9];
for i in array{
println!("{}",i);
}
}
//Control program
fn control_program(){
println!("---My first use for a cicles in rust----");
request_user_word();
println!("-------------------");
println!("Array");
array();
println!("-------------------");
}
//Start program
control_program();
}
>
5:26 - El iterador, se le debe añadir el carácter guion bajo ' _ ' antes de la 'i', para que al momento de ejecutar o compilar código, no salga error:
//invocar el ciclo for
for _i in 0..5 {
//se debe poner '_i' para que el compilador no genere error
println!("INTRODUCE TU NOMBRE: -");
let mut nombre = String::new();
std::io::stdin().read_line(&mut nombre).unwrap();
//METODO PUSH PARA AGREGAR UN ELEMENTO AL VECTOR
nombres.push(nombre);
}
