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!(" --------");
}
Inicia tu camino con Rust
Bienvenida al Curso Básico de Rust
Rust: un lenguaje amado por los desarrolladores
Instalando Rust en MacOS o Linux
Instalando Rust en Windows
Domina las bases de Rust
Creando un nuevo proyecto en Rust
Variables de Rust y cómo mostrarlas en pantalla
Recibiendo datos del usuario
Condicionales
Ciclo Loop
Primer proyecto: calculadora digital
Descripción del proyecto
Cargo (dependencias)
¿Qué significa unwrap?
Creando nuestra calculadora
Estructuras y funciones en Rust
Arrays y Ciclo For en Rust
Las funciones en Rust
Segundo proyecto: videojuego de texto
Descripción del proyecto: videojuego de texto
Creación y descripción del entorno
Estructuras básicas, narrativa y opciones de Rust
Interacción con el entorno y datos del usuario
Esto es solo el comienzo
Únete a la comunidad, Rustacean
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Iniciar sesiónRecursos
Conozcamos dos nuevos conceptos que cualquier lenguaje de programación también poseen, y que por supuesto Rust implementa a su manera.
Array de datos en Rust
En Rust, un array de datos es denominado Vector y puedes declarar uno y utilizarlo de la siguiente manera:
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());
println!("{:?}", my_arr);
}
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:
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());
println!("{}", my_arr[2]); // Platzi!
}
Ten cuidado de no acceder a un Ãndice no existente en el array. Para conocer la cantidad de elementos en el mismo, puedes hacer un len():
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());
println!("{}", my_arr.len()); // 3
}
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.
Contribución creada por: Kevin Fiorentino.
Aportes 8
Preguntas 2
Ordenar por:
Suavecito.
<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();
}
>
ciclo for
for i in 0..10 { println!("i {}",i);}for word in words { println!("{}",word);}
Y los arrays se utilizan creando un Vector
let mut my_arr: Vec<String> = Vec::new();
y se agregan valores asÃ
my_arr.push("Texto".to_string());
se accede al valor en base cero
println!("{}",my_arr[0]);
asi o mas simple?
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.
Array es la estructura de datos y vector es Abstract Data Type.
Por ende un array tambien puede ser mutable con el uso de mut por ejemplo.
let mut numbers: [i32; 5] = [1, 2, 3, 4, 5];
fn main() {
println!("Hey! Introduce yourself");
let mut data: Vec<String> = Vec::new();
let questions = vec![
"Please introduce your name:",
"Please introduce your age:",
"Please introduce your country:",
];
for ask in questions {
println!("{}", ask);
let mut answer = String::new();
std::io::stdin().read_line(&mut answer).unwrap();
data.push(answer.trim().to_string())
}
println!("{:?}", data);
println!(
"Hello, my name is {}. I'm {} years old, and I'm from {}.",
data[0], data[1], data[2],
);
}
fn main() {
let mut _arr:Vec<i32>=Vec::new();//Declaramos i32 para pasarlo a un numero entero
let mut i=0;
while i<=7{
println!("Digita un numero: ");
let mut numero:String=String::new();
std::io::stdin().read_line(&mut numero).unwrap();
let mut _numero:i32=numero.trim().parse().unwrap();
_arr.push(_numero);//del arreglo lo pasamos a agragar numeros ingresados
i+=1
}
//creamos contadores diferente para cada par e impar
let mut _count_p:i32=0;
let mut _count_i:i32=0;
//Usamos for para recorrer la lista de los nuemeros ingresados
for j in _arr.iter(){
let res:i32= j % 2;//Operacion modulo % para conocer residuos.
if res == 0{
_count_p+=1;//contador de pares
}else if res ==1 {
_count_i+=1;//Contador de impares
}
}
println!("Total de Pares: {_count_p}");
println!("Total de Impares: {_count_i}");
}
Footer
© 2022 GitHub, Inc.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?
o inicia sesión.