No tienes acceso a esta clase

¬°Contin√ļa aprendiendo! √önete y comienza a potenciar tu carrera

Aprende todo un fin de semana sin pagar una suscripci√≥n ūüĒ•

Aprende todo un fin de semana sin pagar una suscripci√≥n ūüĒ•

Regístrate

Comienza en:

5D
19H
9M
1S

Arrays y Ciclo For en Rust

14/20
Recursos

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:

¬ŅQuieres ver m√°s aportes, preguntas y respuestas de la comunidad?

o inicia sesión.

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!("       --------");
}

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.