No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Recibiendo datos del usuario

7/20
Recursos

Aportes 19

Preguntas 3

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Pequeño dato, Rust tiene como estandar usar snake case para declaraciones, en caso de que no la utilices te lo señalizara como un warning en tiempo de compilacion.

fn main() {
// snake case work fine
 let var_en_snake_case: u8 = 8 ;
 
 //Camel Case, Warning in compilation time
 let varEnCamelCase: u8 = 8;
}

Tipos de números en Rust. (básico)

Enteros con signo (Desde i8 hasta i128)

  • i8 <- entero con signo de 8bits.
  • i16<- entero con signo de 16bits.
  • i32 <- entero con signo de 32bits (es el que rust infiere por defecto cuando no le establecemos un tipo).
  • i64 <- entero con signo de 64bits.

También tenemos los números sin signos, para estos números tenemos el doble de tamaño(hacia la derecha).

Un ejemplo para que se entienda mejor:

fn main(){
    // el rango de un numero entero con signo abarca desde -127 hasta 127
    let temp_sign: i8 = -30; // tranquilo, no va a explotar.
    // el rango de un numero sin signo es mayor debido a que ya no tenemos los numeros con signo.
    let temp_usign: u8 = 255; // aqui puede que explote si usas un signo.
    println!("temperatura {} {}", temp_sign, temp_usign);
  
}

Enteros sin signo (Desde u8 hasta u128)

  • u8 <- entero sin signo de 8bits.
  • u16<- entero sin signo de 16bits.
  • u32 <- entero sin signo de 32bits.
  • u64 <- entero sin signo de 64bits.

Espero que hayan entendido un poco sobre esto, Rust tiene muchos de datos que espero nos muestren pronto en el curso :p

Se puede desestructurar las librerias importanto solo el componente que se va a utilizar con la palabra reservada use

use std::io;

fn main() {
    println!(
        "Hello {}, you have {} years old!",
        &get_name_from_user(),
        &get_age_from_user()
    );
}

fn get_name_from_user() -> String {
    println!("Please insert your name");

    let mut name = String::new();

    io::stdin()
        .read_line(&mut name)
        .expect("Failed to read line");

    name.trim().to_string()
}

fn get_age_from_user() -> u8 {
    println!("Please insert your age");

    let mut age = String::new();

    io::stdin()
        .read_line(&mut age)
        .expect("Failed to read line");

    age.trim().parse().unwrap()
}

Quise de una vez usar funciones

fn main() {
    let nombre: String = solicitar_info("cual es tu nombre?");
    let pais: String = solicitar_info("de que pais vienes?");

    println!("Hola {} como esta el clima en {}?", nombre, pais);
}

fn solicitar_info(pregunta: &str) -> String {
    println!("Pregunta: {}", pregunta);
    let mut respuesta: String = String::new();

    std::io::stdin().read_line(&mut respuesta).unwrap(); 
    return respuesta.trim().to_string()
}

Así lo hice yó

<code> 
fn main() {

    println!("Bienvenido al aeropuerto imaginario");
    println!("De que pais vienes?");

    let mut country = String::new();
    std::io::stdin().read_line(&mut country).unwrap();

    println!("Cual es tu nombre");

    let mut name = String::new();

    std::io::stdin().read_line(&mut name).unwrap();

    println!("Cual estu edad");

    let mut age: String = String::new();
   
    std::io::stdin().read_line(&mut age).unwrap();

    let age_int: u8 = age.trim().parse().unwrap();
    
    // dias
    let mut days: String = String::new();

    println!("Cuantos dias estarás aqui?");

    std::io::stdin().read_line(&mut days).unwrap();

    println!("Hola {}, de {} años, disfruta tu estancia de {} dias en imaginalandia", name, age_int, days);
}

El tema de el &str y String por ejemplo, así como otros lenguajes, &str hace referencia al contenido de un tipo de dato nativo y el contenido de una posición de memoria, mientras que el String sería como un Objeto en POO,

Algo del reto y un poco de búsqueda jeje

fn main() {
    let mut country: String = String::new();

    println!("Where are you from?");
    std::io::stdin().read_line(&mut country).unwrap();

    match country.as_str().trim() {
        "chile" => println!("Hola po!"),
        "peru" => println!("Hola pe!"),
        "argentina" => println!("Hola che!"),
        "brazil" => println!("Oi, tudo bem?"),
        _ => println!("Hello world"),
    }
}

La lista podria crecer…

fn preguntar_nombre_y_pais() {
println!("Por favor introduce tu nombre: ");
let mut nombre: String = String::new();
std::io::stdin().read_line(&mut nombre).unwrap();

println!("Por favor introduce tu nombre: ");
let mut pais: String = String::new();
std::io::stdin().read_line(&mut pais).unwrap();
println!(“Hola, {} eres de {}”, nombre.trim(), pais.trim());
}

fn main() {
    let name_nightclub:String = "Coco Bongo".to_string();

    println!("");
    println!("{}",name_nightclub);
    println!("----------");
    println!("");

    println!("Please enter your name...");
    let mut name: String = String::new();
    std::io::stdin().read_line(&mut name).unwrap();
    name = name.trim().to_string();

    println!("What country  are you from {}?", name);
    let mut country: String = String::new();
    std::io::stdin().read_line(&mut country).unwrap();
    country = country.trim().to_string();

    println!("Please enter your age...");
    let mut age: String = String::new();
    std::io::stdin().read_line(&mut age).unwrap();
    
    let age_int:u8=age.trim().parse().unwrap();


    println!("");
    println!("Hello {} from {}, you are {} years old.",name,country,age_int);
    println!("");
    println!("  Welcome to {}", name_nightclub);

}

Aqui cumpliendo el reto

fn main() {
    println!("Please! Enter your name: ");
    let mut name : String = String::new();
    std::io::stdin().read_line(&mut name).unwrap();
    name = name.trim().to_string();

    println!("Please! Enter your age: ");
    let mut age : String = String::new();
    std::io::stdin().read_line(&mut age).unwrap();

    let age_int : u8 = age.trim().parse().unwrap();

    println!("Please! Enter your country of origin: ");
    let mut country : String = String::new();
    std::io::stdin().read_line(&mut country).unwrap();
    country = country.trim().to_string();

    println!("Hello Welcome {} you age is {} years old and your country origin is {}", name, age_int, country);
}

Mi aporte al reto

fn main() {
    let mut name: String = String::new();

    println!("Hello, please tell me your name:");
    std::io::stdin().read_line(&mut name).unwrap();
    name = name.trim().to_string();
    println!("Welcome {}!", name);
    println!("How old are you?");
    let mut input_age: String = String::new();
    std::io::stdin().read_line(&mut input_age).unwrap();
    println!("Where are you from?");
    let mut origin: String = String::new();
    std::io::stdin().read_line(&mut origin).unwrap();
    origin = origin.trim().to_string();

    let years_in_future: u8 = 31;
    let age_in_future: u8 = input_age.trim().parse::<u8>().unwrap() + years_in_future;
    println!(
        "Nice to meet you {} from {}, you will be {} years old in {} years.",
        name, origin, age_in_future, years_in_future
    );
}

Aquí dejo mi solución al ejercicio propuesto por el profesor:

fn main() {
    let name: String = ask_user_for("Por favor ingresa tu nombre: ");
    let city: String = ask_user_for("Por favor ingresa tu ciudad: ");
    println!("Hola, {}. Gracias por usar el script desde {}.", name, city);
}

fn ask_user_for(label: &str) -> String {
    let mut user_answer: String = String::new();
    println!("{}", label);
    std::io::stdin().read_line(&mut user_answer).unwrap();
    user_answer.trim().to_string()
}

Leyendo un poco más sobre variables en Rust, me di cuenta que se soporta shadowing.
 
Shadowing nos permite declarar una nueva variable, incluso con un tipo diferente, que tenga el mismo nombre de otra variable declarada anteriormente en el bloque de código o en un bloque superior.
 
Esto nos permite que en lugar de hacer:

// Obtener la edad del usuario
println!("Por favor introduce tu edad: ");
let mut age: String = String::new();
std::io::stdin().read_line(&mut age).unwrap();

// Convertir la edad a un número
let age_int: u8 = age.trim().parse().unwrap();

Podamos hacer:

// Obtener la edad del usuario
println!("Por favor introduce tu edad: ");
let mut age: String = String::new();
std::io::stdin().read_line(&mut age).unwrap();

// Convertir la edad a un número
let age: u8 = age.trim().parse().unwrap();

Sin necesidad de tener mantener el valor del age como String a futuro en nuestro código.
 
Esto puede ser útil para mejorar la legibilidad, en lugares donde no sea necesario seguir haciendo uso de la variable original sino de la parseada.

fn main() {
    //crear las variables
    let mut nombre=String::new();
    let mut ciudad=String::new();
    
    //Se gurdan las variables que el usuario Introduzca. 
    println!("Digita tu nombre: ");
    std::io::stdin().read_line(&mut nombre).expect("Solo letras");
    nombre=nombre.trim().to_string();//Evita saltos de Linea. 
    println!("Digita tu ciudad: ");
    std::io::stdin().read_line(&mut ciudad).expect("Solo letras");
    ciudad=ciudad.trim().to_string();//evita saltos de Linea

    //Se imprime el resultado Final
    println!("Su nombre es {nombre}, y vive en {ciudad}");
    
    


}

Reto

fn main(){
   form_foraneo()
}

fn form_foraneo(){
    println!("Happy coding, ingresa por favor tu nombre: ");
    let mut nombre: String = String::new();
    std::io::stdin().read_line(&mut nombre).unwrap();
    nombre = nombre.trim().to_string();
    println!("Happy coding, ingresa por favor tu pais de origen: ");
    let mut pais: String = String::new();
    std::io::stdin().read_line(&mut pais).unwrap();
    pais = pais.trim().to_string();
    print!("Hola, bienvenido {} tu pais de origen es {} ", nombre,pais);
}
fn main() {
    let min_temp: i8 = -21;
    let max_temp: i8 = 38;

    let mut input_name: String = String::new();
    let mut input_age: String = String::new();

    println!("Por favor introduzca su nombre:");
    std::io::stdin().read_line(&mut input_name).unwrap();

    println!("Por favor introduzca su edad:");
    std::io::stdin().read_line(&mut input_age).unwrap();

    let name: &str = input_name.trim();
    let age: u8 = input_age.trim().parse().unwrap();
    
    say_hello(name, age);
    print_temp(min_temp, max_temp);
}

fn say_hello(name: &str, age: u8) {
    return println!("Bienvenido {}, tienes {} anios", name, age)
}

fn print_temp(min_temp: i8, max_temp: i8) {
    return println!("La temperatura maxima en Deggendorf fue de {} y la mas alta fue de {}", min_temp, max_temp)
}