No tienes acceso a esta clase

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

Aprende Inglés, Programación, AI, Ciberseguridad y más a precio especial.

Antes: $249

Currency
$209
Suscríbete

Termina en:

1 Días
11 Hrs
12 Min
58 Seg

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 11

Preguntas 2

Ordenar por:

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

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.

atentamente, su IA favorita ChatGPT<3

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.


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.

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]);
```txt use regex::Regex; fn main() { //Regex let re_add = Regex::new(r"(\d+)\s?\+\s?(\d+)").unwrap(); let re_mul = Regex::new(r"(\d+)\s?\*\s?(\d+)").unwrap(); let re_res = Regex::new(r"(\d+)\s?\-\s?(\d+)").unwrap(); let re_div = Regex::new(r"(\d+)\s?\/\s?(\d+)").unwrap(); let div = false; //traer datos del usuario println!("Ingrese su expresion"); let mut expresion = String::new(); std::io::stdin().read_line(&mut expresion).unwrap(); //Multiplicacion loop{ let caps = re_mul.captures(expresion.as_str()); if caps.is_none(){ break; } let caps = caps.unwrap(); let cap_expresion = caps.get(0).unwrap().as_str(); let val_izq : i32 = caps.get(1).unwrap().as_str().parse().unwrap(); let val_der: i32 = caps.get(2).unwrap().as_str().parse().unwrap(); let mult = val_izq * val_der; expresion = expresion.replace(cap_expresion, &mult.to_string()); } //Suma loop{ //Aplicar operaciones let caps = re_add.captures(expresion.as_str()); if caps.is_none(){ break; } let caps = caps.unwrap(); let cap_expresion = caps.get(0).unwrap().as_str(); let val_izq : i32 = caps.get(1).unwrap().as_str().parse().unwrap(); let val_der: i32 = caps.get(2).unwrap().as_str().parse().unwrap(); let suma = val_izq + val_der; expresion = expresion.replace(cap_expresion, &suma.to_string()); } //Resta loop{ //Aplicar operaciones let caps = re_res.captures(expresion.as_str()); if caps.is_none(){ break; } let caps = caps.unwrap(); let cap_expresion = caps.get(0).unwrap().as_str(); let val_izq : i32 = caps.get(1).unwrap().as_str().parse().unwrap(); let val_der: i32 = caps.get(2).unwrap().as_str().parse().unwrap(); let resta = val_izq - val_der; expresion = expresion.replace(cap_expresion, &resta.to_string()); } //Division loop{ let caps = re_div.captures(expresion.as_str()); if caps.is_none(){ break; } let caps = caps.unwrap(); let cap_expresion = caps.get(0).unwrap().as_str(); let val_izq : i32 = caps.get(1).unwrap().as_str().parse().unwrap(); let val_der: i32 = caps.get(2).unwrap().as_str().parse().unwrap(); if val_der != 0{ let divi = val_izq / val_der; let div = true; expresion = expresion.replace(cap_expresion, &divi.to_string()); } else { println!("No existe division entre 0"); break; } } //Mostrar Resultado if div == true{ println!("El resultado es:{} ",expresion); } } ```

Mejorando el código de Hackerman

use std::io;

fn array() {
    let vector = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let result = vector.iter().map(|x| x.to_string()).collect::<Vec<String>>();
    println!("{:?}", result);
}

fn control_program() {
    println!("---My first use for a cicles in rust----");

    println!("Insert word:");
    let mut word = String::new();
    io::stdin().read_line(&mut word).unwrap();

    println!("Vector:");
    array();
}

fn main() {
    control_program();
}

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],
    );
}