Condicionales
Clase 8 de 20 • Curso de Rust básico
Contenido del curso
Jesus David Zapata Betancourth
student•
hace 4 años
Santiago Moreno
student•
hace 3 años
Edward Rodriguez
student•
hace 2 años
Clase 8 de 20 • Curso de Rust básico
Contenido del curso
Jesus David Zapata Betancourth
Santiago Moreno
Edward Rodriguez
Andersson Johan Ramirez Mosquera
Hecot Pulido
Jecsham Castillo
José Alberto Mata Mena
Edward Rodriguez
Leandro Ariel Labiano Ramo
Leandro Ariel Labiano Ramo
Hecot Pulido
Eder Irineo Tassin
Hecot Pulido
Eder Irineo Tassin
Carlos Nexans
Víctor Andrés Córdova Poma
Víctor Andrés Córdova Poma
Víctor Andrés Córdova Poma
Jose Daniel Sarmiento
Jorge Montoya
Juan Matus
Cristian Rodrigo Sánchez
Nicolas Leonardo Anicama Espinoza
Rodrigo Andrés Moreno Pertúz
Roberto Antonio Berrospe Machin
Alexander Ramirez
Misrain Ramirez Benavidez
ALEJANDRO RIAÑO VELASCO
Mauricio Sebastian Gutierrez Perdomo
José de Jesús Hernández Vázquez
Jose Luis Luevano Hernandez
José Porfirio Carrillo Echenique
fn main() { println!("Esta es tu última oportunidad. Después, ya no podrás echarte atrás. Si tomas la pastilla azul, fin de la historia. Despertarás en tu cama y creerás lo que quieras creerte. Si tomas la roja, te quedas en el País de las Maravillas y yo te enseñaré hasta dónde llega la madriguera de conejos. Recuerda lo único que te ofrezco es la verdad. Nada más."); println!("Qué pastilla tomarás? roja o azul?"); let mut opcion: String = String::new(); std::io::stdin().read_line(&mut opcion).unwrap(); let pastilla: &str = opcion.trim(); if pastilla == "roja" { println!("Muy bien, Neo. Sígueme...."); } else if pastilla == "azul" { println!("Como prefieras. No nos veremos nunca mas...."); } else { println!("Tal parece que no eres el Neo que pensábamos."); } }
Sublime
returbina...
Se pueden hacer asignaciones de variables con condicionales ternarios
let variable = if true { "Enabled" } else { "Disabled" };
¡Muy bueno! Aunque es un arma de doble filo, puede hacer el código un poco más difícil de leer, pero es bueno saberlo.
Bueno saberlo En ruby y python se usa mucho
use std::io; fn main() { let pildora_roja: &str = "🔴"; let pildora_azul: &str = "🔵"; let mut opcion: String = String::new(); println!("¿Cual pildora deseas tomar?"); println!("1 - Pildora roja {}", pildora_roja); println!("2 - Pildora azul {}", pildora_azul); io::stdin().read_line(&mut opcion).unwrap(); let op_int: u8 = opcion.trim().parse().unwrap(); if op_int == 1 { println!("Elegiste la pildora {}", pildora_roja) } else if op_int == 2 { println!("Elegiste la pildora {}", pildora_azul) }else{ println!("Opción invalida") } }
realmente... eres el rey de reyes
Dato : Rust tiene un comando para formatear el codigo completamente, se logra con $ rustfmt nombreArchivo .rs
Ejemplo:
fn main() { //Obtener la edad desde la consola, println!("Introduce tu edad: "); let mut edad: String = String::new(); std::io::stdin().read_line(&mut edad).unwrap(); let edad_int: u8 = edad.trim().parse().unwrap(); if edad_int < 18 { println!("Eres menor de edad"); } else { println!("Eres mayor de edad"); } println!("Hola tiene {}", edad_int); }
Usando rustfmt main .rs
fn main() { //Obtener la edad desde la consola, println!("Introduce tu edad: "); let mut edad: String = String::new(); std::io::stdin().read_line(&mut edad).unwrap(); let edad_int: u8 = edad.trim().parse().unwrap(); if edad_int < 18 { println!("Eres menor de edad"); } else { println!("Eres mayor de edad"); } println!("Hola tiene {}", edad_int); }
Si usas vscode también lo puedes hacer desde un shortcut: On Windows Shift + Alt + F On macOS Shift + Option + F On Linux Ctrl + Shift + I
Muchas gracias por compartir c:
Dejo mi aporte de lo que estuve probando
use chrono::prelude::*; fn obtener_edad(ano_nacimiento: u32) -> u32 { let mut edad: u32 = 0; let utc_now: DateTime<Utc> = Utc::now(); let ano_actual = utc_now.year() as u32; if ano_nacimiento > 0 { edad = ano_actual - ano_nacimiento as u32; } return edad; } fn es_mayor_edad(edad: u32) -> bool { return edad >= 18; } fn main() { println!("Ingrese su nombre"); let mut nombre_input: String = String::new(); std::io::stdin().read_line(&mut nombre_input).unwrap(); nombre_input = nombre_input.trim().to_string().to_uppercase(); println!("Ingrese su año de nacimiento: "); let mut ano_input: String = String::new(); std::io::stdin().read_line(&mut ano_input).unwrap(); let ano_nacimiento_int: u32 = ano_input.trim().parse().unwrap(); let edad: u32 = obtener_edad(ano_nacimiento_int); if es_mayor_edad(edad) { println!("{} es mayor de edad", nombre_input); } else { println!("{} es menor de edad", nombre_input); } println!("Nombre: {} - Edad: {}", nombre_input, edad); }
Ohhh este es muy bueno 😌, usaste chrono para obtener la edad
Sisi, fue lo que encontré dentro de crates. io jaja
En el instante 9:10. Esto se puede realizar por las propiedades de la logica. En particular el teorema shunting, que permite reemplazar una expresión lógica por otra equivalente
p => q => r es equivalente a p && q => r
Lease p => q como “Si p entonces q”. Si estas aprendiendo a programar eventualmente te servirá aprender lógica simbólica y sus propiedades. Con esta herramienta se puede escribir código más simples y además, probar formalmente que las condiciones son correctas.
Estaba intentando crear un loop para que cuando el usuario una variable que no se sea un número deba colocar la variable denuevo, pero no resulta como esperaba. Esperaba que la variable age va ser alterada cada vez que el usuario digite algo en la consola, pero ello no pasa, porque se queda con la primera variable que se le colocó. ¿Por qué su valor de age no varía?
Código
use std::io::{stdin}; fn main(){ let mut age: String = String::new(); let mut is_number: bool = true; while is_number { println!("Digit your name"); stdin().read_line(&mut age).unwrap(); match age.trim().parse::<i8>() { Ok(value) => { is_number = false; println!("You are {value} years old"); } Err (error) => println!("error: {error}\nTry writing a number."), } } }
Lo resolví de casualidad, se le debe colocar age.clear() al finalizar el loop. Sin embargo, no entiendo aún el porque, debo estudiar como funciona read_line y la asignación de memoria con Rust.
use std::io::{stdin}; fn main(){ let mut is_number: bool = true; let mut age: String = String::new(); while is_number { stdin().read_line(&mut age).unwrap(); match age.trim().parse::<i8>() { Ok(value) => { is_number = false; println!("You are {value} years old"); } Err (error) => println!("error: {error}\nTry writing a number."), } age.clear(); //Esto es lo nuevo. } }
Mejoré un poco el código usando loop, que es usado para crear un loop infinito en Rust, además, de crear una función que pida le pida la edad al usuario. Aún sigo sin entender porque limpiar la variable age xd, pero tengo una sospecha de que en runtime al asignar un valor a una variable mutable se le debe limpiar para asignar a otro espacio de memoria. En cambio, en compile time se puede cambiar a donde apunta una variable las veces que se quiera sin necesidad de limpiarlo. Es lo que yo creo, pero no estoy seguro.
use std::io::{stdin}; fn main(){ let age: u8 = get_age(); println!("the user is {age} years old.") } fn get_age() -> u8{ let mut input: String = String::new(); loop { println!("Digit your age"); stdin().read_line(&mut input).unwrap(); match input.trim().parse::<u8>() { Ok(value) => { return value; } Err (error) => { println!("error: {error}\nTry writing a number."); } } input.clear(); continue; } }
use std::io::stdin; use std::string::*; /// This function reads a line from the console and returns it as a String fn get_info_from_console() -> String { let mut input:String = String::new(); stdin().read_line(&mut input).expect("Failed to read line"); input } fn main() { println!("Bienvenido de nuevo Neon, ¿qué color te gustaría que fuera tu mundo? Azul o rojo?"); let eleccion:String= get_info_from_console().trim().to_lowercase().to_string() ; match eleccion.as_str() { "azul" => println!("Has elegido el mundo matrix. "), "rojo" => println!("Has elegido el mundo real."), _ => println!("No has elegido un color válido"), } }
Reto
fn main(){ pildoras(); } fn pildoras(){ println!("Hola bienvenido, que pastillas desea tomar, azul o roja?"); let mut pastillas: String = String::new(); std::io::stdin().read_line(&mut pastillas).unwrap(); pastillas = pastillas.trim().to_lowercase(); if pastillas == "azul"{ println!("Felicidades, usted elijio pastillas azules") } else if pastillas == "roja"{ println!("Felicidades, usted elijio pastillas rojas") } else{ println!("Lo sentimos, no tenemos esa pastilla") } }
fn main() { let mut pill: String = String::new(); println!("Do you want a blue pill or red pill?"); std::io::stdin().read_line(&mut pill).unwrap(); // lowercase the input to make it easier to compare pill = pill.to_lowercase(); if pill == "blue\n" || pill == "b\n" { println!("You'll have free coffee forever!"); } else if pill == "red\n" || pill == "r\n" { println!("You are going to live without coffee and code for life."); } else { println!("Game over. I'd suggest you start running."); } }
mi aporte:
fn main() { println!("Como es tu nombre?"); let mut nombre: String = String::new(); std::io::stdin().read_line(&mut nombre).unwrap(); nombre = nombre.trim().to_string(); println!("{}, esta es tu última oportunidad. Después, ya no podrás echarte atrás. Si tomas la pastilla azul, fin de la historia. Despertarás en tu cama y creerás lo que quieras creerte. Si tomas la roja, te quedas en el País de las Maravillas y yo te enseñaré hasta dónde llega la madriguera de conejos. Recuerda lo único que te ofrezco es la verdad. Nada más.", nombre); // eleccion println!("Qué pastilla tomarás? roja o azul?"); let mut opcion: String = String::new(); std::io::stdin().read_line(&mut opcion).unwrap(); let pastilla: &str = opcion.trim(); if pastilla == "roja" { println!("Muy bien,{}. Sígueme....", nombre); } else if pastilla == "azul" { println!("Como prefieras {}. No nos veremos nunca mas....", nombre); } else { println!("{}, tal parece que no eres lo que pensábamos.", nombre); } } ```fn main() { println!("Como es tu nombre?"); let mut <u>nombre</u>: String = String::new(); std::io::stdin().read\_line(\&mut <u>nombre</u>).unwrap(); <u>nombre</u> = <u>nombre</u>.trim().to\_string(); println!("{}, esta es tu última oportunidad. Después, ya no podrás echarte atrás. Si tomas la pastilla azul, fin de la historia. Despertarás en tu cama y creerás lo que quieras creerte. Si tomas la roja, te quedas en el País de las Maravillas y yo te enseñaré hasta dónde llega la madriguera de conejos. Recuerda lo único que te ofrezco es la verdad. Nada más.", <u>nombre</u>);   // eleccion println!("Qué pastilla tomarás? roja o azul?"); let mut <u>opcion</u>: String = String::new(); std::io::stdin().read\_line(\&mut <u>opcion</u>).unwrap(); let pastilla: \&str = <u>opcion</u>.trim();   if pastilla == "roja" { println!("Muy bien,{}. Sígueme....", <u>nombre</u>); } else if pastilla == "azul" { println!("Como prefieras {}. No nos veremos nunca mas....", <u>nombre</u>); } else { println!("{}, tal parece que no eres lo que pensábamos.", <u>nombre</u>); }}
XD el diálogo completo
fn main() { let age_int: i8 = get_age(); age_evaluator(age_int); } fn get_age() -> i8 { println!("Insert age: \n"); let mut age : String = String::new(); std::io::stdin().read_line(&mut age).unwrap(); let age_int: i8 = age.trim().parse().unwrap(); return age_int; } fn age_evaluator(age_int: i8) -> () { if age_int < 18 { println!("You are not old enough"); } else { println!("You are old enough"); } }
use std::io::stdin; fn main() { let mut str_pildora: String = String::new(); //Limpiar la pantalla print!("\x1B[2J\x1B[1;1H"); //Mostrar mensaje inicial println!(" ¡The Matrix Has You! Te ofrezco dos opciones, y recuerda, no hay vuelta atrás... 🔵 Píldora Azul, se termina la historia, te despiertas en tu cama, y crees lo que quieras creer; es decir, continúas en el estado actual, viviendo la vida sin saber su significado, huyendo de la verdad para que permanezca todo cómo está. Mañana te despertarás en tu cama sin preocuparte por tu destino o cualquier tipo de idea profunda... 🔴 Pildora Roja, te quedarás en la tierra de las marabillas, y te mostraré que tan profundo puede ser el agujero de conejo; aprenderás sobre las mentiras que se establecieron en el mundo, para que las puedas romper y obtener así la verdadera libertad... Recuerda, todo lo que te ofrezco es la verdad, nada mas... Escribe el color de la pildora deseas tomar, ¿Azul o Roja?:"); //Leer la Pildora Elegida desde el Standard Input... stdin().read_line(&mut str_pildora).unwrap(); //Remover EOL, y convertir a minúsculas str_pildora = str_pildora.trim().to_string().to_lowercase(); //Limpiar la pantalla print!("\x1B[2J\x1B[1;1H"); //Evaluar que píldora eligió if str_pildora == "azul" { println!("🔵 Píldora Azul: Que desilución 😩\nPensé que eras tú...\nTendré que seguir mi búsqueda...\n👋 Adiós...\n\n") } else if str_pildora == "roja" { println!("🔴 Pildora Roja: ¡Lo sabía! 😃\nSigueme...Trinity prepara el programa de reastreo...\n🧉🧉🧉🧉🧉🧉🧉🧉🧉🧉🧉🧉🧉🧉🧉...\n¡Bienvenid@, al mundo real! 👽 🛸\n\n"); } else { println!("{str_pildora}: Lo siento 😞...\nTienes el don, pero parece que estás esperando algo; quizás tu siguente vida...\n ☠️\n\n"); } }
Lo que noté es que en la clase anterior a la variable nombre igual permite meterle valores numéricos y lo acepta, recurrí a chatgpt y me dio un código limpio con un loop y errores personalizados estilo oracle y python : use std::io::{self, Write};
fn main() {
// Pedir el nombre
println!("Por favor introduce tu nombre:");
let mut nombre = String::new();
io::stdin()
.read_line(&mut nombre)
.expect("Error leyendo el nombre");
let nombre = nombre.trim();
// Loop para pedir la edad hasta que sea válida
let edad_int: u8 = loop {
print!("Por favor introduce tu edad: ");
io::stdout().flush().unwrap(); // asegura que el mensaje aparezca antes de leer
let mut edad = String::new();
io::stdin()
.read_line(&mut edad)
.expect("Error leyendo la edad");
// Intentar convertir a número
match edad.trim().parse::<u8>() {
Ok(num) => break num, // número válido, salir del loop
Err(_) => {
println!("Edad inválida. Por favor introduce un número entre 0 y 255.");
continue; // vuelve a pedir
}
}
};
println!("Hola, bienvenido/a {} de {} años", nombre, edad_int);
}
fn main() { println!("Introduzca su nombre: "); let mut nombre : String = String::new(); std::io::stdin().read_line(&mut nombre).unwrap(); nombre = nombre.trim().to_string(); // obener la edad de la consola println!("Hola, Bienvenido {}, tu tienes que escoger entre pildora Roja y Azúl", nombre ); let mut pildora : String = String::new(); std::io::stdin().read_line(&mut pildora).unwrap(); pildora = pildora.trim().to_string(); if pildora == "Roja" { println!("Hola, Bienvenido {} tu escogiste la pildora {}, Serás millonario", nombre, pildora); }else if pildora == "Azúl" { println!("Hola, Lo siento {} tu ecogiste la pildora {}, NO puedes correr tan rápido", nombre, pildora); } if pildora != "Roja" && pildora != "Azúl" { println!("Hola, Lo siento la has liado"); } }
fn main() {
println!("Introduzca su nombre: ");
let mut <u>nombre</u> : String = String::new();
std::io::stdin().read_line(&mut <u>nombre</u>).unwrap();
<u>nombre</u> = <u>nombre</u>.trim().to_string();
// obener la edad de la consola
println!("Hola, Bienvenido {}, tu tienes que escoger entre pildora Roja y Azúl", <u>nombre</u> );
let mut <u>pildora</u> : String = String::new();
std::io::stdin().read_line(&mut <u>pildora</u>).unwrap();
<u>pildora</u> = <u>pildora</u>.trim().to_string();
if <u>pildora</u> == "Roja" {
println!("Hola, Bienvenido {} tu escogiste la pildora {}, Serás millonario", <u>nombre</u>, <u>pildora</u>);
}else if <u>pildora</u> == "Azúl" {
println!("Hola, Lo siento {} tu ecogiste la pildora {}, NO puedes correr tan rápido", <u>nombre</u>, <u>pildora</u>);
}
if <u>pildora</u> != "Roja" && <u>pildora</u> != "Azúl" {
println!("Hola, Lo siento la has liado");
}
}
Este sería la solución a la selección de las píldoras:
Aca mi solucion:
use std::io::{self, Write}; fn main() { loop { println!("Che, Neo, ¿Que pildora queres?"); println!("1: roja"); println!("2: azul"); let pildora = get_input().unwrap().to_lowercase(); if pildora == "roja"{ println!("Te vas para fuera de la matrix, mijo."); break; } else if pildora == "azul"{ println!("Bueno, volves pal wacal."); break; } else { println!("Pildora invalida. Mira, el profe Hector dijo que la matrix explotaba, pero como en 31 minutos, volvio a empezar una matrix exactamente igual.") } } } fn get_input() ->io::Result<String>{ let mut input = String::new(); io::stdout().flush()?; io::stdin().read_line(&mut input)?; Ok(input.trim().to_string()) }
Esta es mi solución
fn main() {
println!("Que pastilla tomaras NEO?");
let mut <u>pastilla</u>:String = String::new();
std::io::stdin().read_line(&mut <u>pastilla</u>).unwrap();
if <u>pastilla</u>.trim() == "roja" {
println!("Bienvenido al mundo real");
} else if <u>pastilla</u>.trim() == "azul" {
println!("Sigue en la matrix");
} else {
println!("NOOOOOOOOO ESA NO");
println!("*se mueren todos*");
}
}
No me juzgue:
fn main() { let mut name: String = String::new(); let mut city: String = String::new(); let mut age: String = String::new(); println!("Hello, world! Whats your name?"); std::io::stdin().read_line(&mut name).unwrap(); println!("Where do you live?"); std::io::stdin().read_line(&mut city).unwrap(); println!("How old are you?"); std::io::stdin().read_line(&mut age).unwrap(); let age: u8 = age.trim().parse().unwrap(); if age < 18 { return println!("You are a minor. Access to the table dance club is denied."); } println!("Hello, {} from {}! Welcome to the club.", name.trim(), city.trim()); }