Rust: un vistazo más

 

En este post continuaremos con lo visto en el post anterior. Como hemos visto, éste lenguaje es parecido a lenguajes como Python o sin exagerar a Golang.
Crear un hola mundo no implica saber matemática avanzada.
holamundo.rs

fn main(){
  println!("Alquimista de código");
}

Las estructuras de control son las que se usan normalmente en cualquier lenguaje:
1. Secuenciales.
2. Condicionales.
3. Iterativas.

estructuras.rs

fn main(){
  println!("\tProgramando en Rust");
 
  if 45 > 33 && 56 == 66{
      println!("A");
  }else if !false || 7 > 4{
      println!("B");
  }else{
      println!("C");
  }

  let entrada = match codigo{
    "A" => {println!("Aqui no"); "Aqui no"},
    "B" => "Aqui tampoco",
    "C" => "Aqui menos",
    _ => "La entrada es por la puerta de frente!"
  };
  println!("Salida: {}",entrada);

  const TAM = 10;
  let mut contador = TAM;
  
  while contador > 0{
    contador-=1;
    println!("contador {}",contador);
  }
  contador = 0;

  loop{
    contador+=1;
    println!("contador {}",contador);
    if contador == 5{
      break;
    }
  }

  for n in 0..10{
    println!("No. {}",n);
  }

}

En el ejemplo anterior podemos observar las estructuras de control y cómo se declaran las constantes y las variables "mutables".
Cualquier lenguaje de programación que se respete debe tener funciones para manipular cadenas y/o realizar operaciones matemáticas, y Rust no podía ser la excepción.
matematicas.rs

fn main(){
    let x = 9;
    let y = 2;
	println!("Suma de {:?} y {:?} es {:?}",x,y,x+y);
	println!("Resta de {:?} y {:?} es {:?}",x,y,x-y);
	println!("Producto de {:?} y {:?} es {:?}",x,y,x*y);
	println!("Division de {:?} y {:?} es {:?}",x,y,x/y);
	println!("Residuo de {:?} y {:?} es {:?}",x,y,x%y);
	println!("Absoluto  de -5: {:?}",-5i32.abs());
	println!("Potencia de 9: {:?}",9i32.pow(2));
	println!("Raiz de 36: {:?}",36f64.sqrt());
	println!("Cubo de 3: {:?}",3f64.cbrt());
	println!("Redondeo de 1.23333: {:?}",1.23333f64.round());
	println!("Redondeo de 1.25643: {:?}",1.25643f64.ceil());
	println!("e^x: {:?}",2f64.exp());
	println!("ln: {:?}",2f64.ln());
	println!("log10(): {:?}",2f64.log10());
	println!("x a radianes: {:?}",90f64.to_radians());
	println!("x a grados: {:?}",3.1415f64.to_degrees());
	println!("Max: {:?}",4f64.max(5f64));
	println!("Min: {:?}",9f64.min(6f64));
	println!("Seno: {:?}",3.1415f64.sin());
	println!("Coseno: {:?}",3.1415f64.cos());
	println!("Tangente: {:?}",3.1415f64.tan());
}

cadenas.rs

fn main(){
  cadenas();	
}

fn cadenas(){
	let cadena = "ABC";
	println!("Cadena: {}",cadena);

	if cadena == "BCA"{
		println!("Aqui no pasa");
	}else if cadena == "ABD"{
		println!("Aqui no pasa");
	}else{
		println!("Aqui pasa");
	}

	let hola = String::from("Hola, mundo");
	println!("{}",hola);

	let mut cadena_mutable = String::from("FERROCARRILERO");
	cadena_mutable.push_str(" & ");
	cadena_mutable.push_str("JOHN CALLAGER!");
	println!("Cadena: {}",cadena_mutable);

        println!("{:?}",cadena);
        println!("{}",cadena.replace("B","-"));
        if cadena.len() == 3{
           println!("La longitud de la cadena es de 3 caracteres");
        }
        let holamundo = "Hola, mundo!!";
        for n in holamundo.split_whitespace(){
          println!("{}",n);
        }

        for n in cadena_mutable.split("&"){
          println!("{}",n.trim());
        }
        

}

En el primer programa (matematicas.rs) podemos observar algunas de las funciones(sin, sqrt, abs, etc.) y operaciones matemáticas (+,-,/,*,%) que podemos realizar. En el segundo (cadenas.rs), observamos algunas de las operaciones con cadena que permite el lenguaje (trim, split, replace, etc.).
ejecuta.sh

#!/bin/bash

# Compilar y ejecutar programa Rust 

echo Compilando $1
rustc $1
nombre=$1
ejecutable="${nombre##*/}"
echo Archivo generado y ejecutable ${ejecutable%.*}
./${ejecutable%.*}

Este programa en Bash nos servirá para compilar y ejecutar. Para usarlo abrimos una terminal y tecleamos:

$ ./ejecuta.sh programa.rs

Hasta el próximo post.
Enlaces:
https://tourofrust.com/00_es.html
https://lucumr.pocoo.org/2015/5/27/rust-for-pythonistas/