├── cargo ├── miproyecto │ ├── src │ │ └── main.rs │ └── Cargo.toml └── README.md ├── hello-rust └── hello-rust.rs ├── bucles ├── bucles1.rs ├── bucles2.rs └── README.md ├── variables ├── variables1.rs ├── variables2.rs ├── variables3.rs └── README.md ├── cadenas ├── cadenas2.rs ├── cadenas1.rs └── README.md ├── arrays-tuplas ├── arrays-tuplas2.rs ├── arrays-tuplas1.rs └── README.md ├── if ├── if-else.rs └── README.md ├── modulos ├── modulos1.rs └── README.md ├── structs-enums ├── structs-enums2.rs ├── structs-enums1.rs └── README.md ├── .gitignore ├── funciones ├── funciones1.rs └── README.md ├── option-result ├── option-result2.rs ├── option-result1.rs └── README.md ├── gestion-memoria ├── gestion-memoria1.rs ├── gestion-memoria2.rs └── README.md ├── LICENSE ├── README.md └── makefile /cargo/miproyecto/src/main.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | println!("Hello, world!"); 3 | } 4 | -------------------------------------------------------------------------------- /hello-rust/hello-rust.rs: -------------------------------------------------------------------------------- 1 | /** 2 | * Hola Mundo en Rust. 3 | * 4 | * Autor: Victor Suarez 5 | */ 6 | 7 | fn main(){ 8 | println!("Hello Rust"); 9 | } -------------------------------------------------------------------------------- /bucles/bucles1.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 5: Bucles for 2 | * Mostrar el doble de los 10 primeros numeros 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn main(){ 7 | //TODO: Calcular el doble de los 10 primeros numeros. 8 | } -------------------------------------------------------------------------------- /variables/variables1.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 1: declaracion de variables 2 | * Declarar una variable en Rust. 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn main(){ 7 | let x=1; 8 | 9 | println!("x es igual a: {}", x); 10 | } -------------------------------------------------------------------------------- /cadenas/cadenas2.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 11: Cadenas en Rust 2 | * Modificar este ejercicio para que compile 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn main(){ 7 | 8 | let x:&str="Hola mundo"; 9 | let x1:String=x; 10 | println(x1); 11 | } -------------------------------------------------------------------------------- /variables/variables2.rs: -------------------------------------------------------------------------------- 1 | /** 2 | * Ejercicio 2: Declarar una variable con tipado 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn main(){ 7 | let x; //TODO: Declarar esta variable como f32 y asignarle un valor 8 | 9 | println!("x es igual a: {}", x); 10 | } -------------------------------------------------------------------------------- /cargo/miproyecto/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "miproyecto" 3 | version = "0.1.0" 4 | authors = ["zerasul "] 5 | edition = "2018" 6 | 7 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 8 | 9 | [dependencies] 10 | -------------------------------------------------------------------------------- /arrays-tuplas/arrays-tuplas2.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 12: Tuplas en Rust 2 | * Mostrar correctamente la información de la tupla 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn main(){ 7 | let t:(&str,i32)=("Victor", 33); 8 | 9 | println!("Nombre: {}, edad: {}", nombre, edad); 10 | } -------------------------------------------------------------------------------- /cadenas/cadenas1.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 10: Cadenas en Rust 2 | * Modificar este ejercicio para que compile 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn mifuncion(let x:&str){ 7 | println!(x); 8 | } 9 | 10 | fn main(){ 11 | 12 | let x:String="Hola Mundo"; 13 | 14 | mifuncion(x); 15 | } -------------------------------------------------------------------------------- /if/if-else.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 4: Uso de condicionales 2 | * Usar una condicional If-else para controlar el flujo del programa. 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn main(){ 7 | let edad = 18; 8 | 9 | //TODO: Mostrar un mensaje indicando si se es mayor de edad o no. 10 | 11 | } -------------------------------------------------------------------------------- /variables/variables3.rs: -------------------------------------------------------------------------------- 1 | /** 2 | * Ejercicio 3: Declarar una variable mutable 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn main(){ 7 | let x:i32 = 5; //TODO: Declarar esta variable como mutable. 8 | 9 | println!("x es igual a: {}", x); 10 | x=1; 11 | println!("x ahora es igual a: {}",x); 12 | } -------------------------------------------------------------------------------- /arrays-tuplas/arrays-tuplas1.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 11: Arrays en Rust 2 | * Mostrar el doble de los primeros 10 numeros y el triple del numero 11 al 20 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn main(){ 7 | let a:[i32,20]=[0..20]; 8 | 9 | //TODO: mostrar el doble del 0 al 10 y el triple del 11 al 20. 10 | } -------------------------------------------------------------------------------- /modulos/modulos1.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 16: Modulos 2 | * Ejecuta la funcion del modulo mimodulo 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | pub mod mimodulo{ 7 | pub fn mifuncion(x:i32)->i32{ 8 | 2*x 9 | } 10 | } 11 | 12 | fn main(){ 13 | let x=2; 14 | 15 | //TODO: Llamar al modulo 16 | 17 | } -------------------------------------------------------------------------------- /structs-enums/structs-enums2.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 14: Enums en Rust 2 | * Mostrar la informacion del Enum 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | enum miEnum{ 7 | Valor1(i32), 8 | Valor2(i32,i32,i32), 9 | Valor3{r:i32,g:i32,b:i32} 10 | }; 11 | 12 | fn main(){ 13 | //TODO: Crear una variable enum y usando match mostrar por pantalla los distintos valores. 14 | } -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Generated by Cargo 2 | # will have compiled files and executables 3 | **/target/ 4 | 5 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries 6 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html 7 | Cargo.lock 8 | 9 | # These are backup files generated by rustfmt 10 | **/*.rs.bk 11 | 12 | **/*.exe 13 | **/*.pdb -------------------------------------------------------------------------------- /bucles/bucles2.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 6: Bucles loop 2 | * Usando un bucle loop calcular los cuadrados de los numeros 3 | * hasta que el resultado sea 64. 4 | * Autor: Victor Suarez 5 | */ 6 | 7 | fn main(){ 8 | 9 | let mut a:i32= 0; 10 | loop{ 11 | 12 | println!("El cuadrado de {} es {}", a, a*a); 13 | //TODO: Parar el bucle 14 | a+=1; 15 | } 16 | } -------------------------------------------------------------------------------- /if/README.md: -------------------------------------------------------------------------------- 1 | # If-Else 2 | 3 | En Rust podemos encontrar estructuras de control condicionales; en este apartado veremos la condicional simple ```if-else```; más adelante veremos la condicional ```match```. 4 | 5 | Seguidamente se muestra un ejemplo de if-else: 6 | 7 | ```rust 8 | if a>=0 { 9 | println!("a es mayor a igual que 0"); 10 | }else{ 11 | println!("a es menor que 0"); 12 | } 13 | ``` -------------------------------------------------------------------------------- /funciones/funciones1.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 7: declaracion de funciones 2 | * Declarar una funcion que calcule el doble para un numero par 3 | * y el triple para un numero impar. 4 | * Autor: Victor Suarez 5 | */ 6 | 7 | //TODO: Declarar la funcion 8 | 9 | fn main(){ 10 | 11 | println!("El doble de 2 es: {}",doble_triple(2)); 12 | println!("El triple de 3 es: {}", doble_triple(3)); 13 | } -------------------------------------------------------------------------------- /option-result/option-result2.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 16: Result 2 | * Escribir el codigo que falta 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn mifuncion(x:i32)->Result{ 7 | 8 | if x>0 { 9 | //devolver OK y devolver el cubo del parametro recibido 10 | }else{ 11 | //Devolver Err 12 | } 13 | } 14 | 15 | fn main(){ 16 | 17 | let x=5; 18 | 19 | match mifuncion(x) { 20 | //TODO escribir para controlar cada caso 21 | } 22 | } -------------------------------------------------------------------------------- /gestion-memoria/gestion-memoria1.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 8: gestion memoria Rust 2 | * Modificar este ejercicio para que compile 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn anyadir_uno(v:Vec,x:i32)->Vec{ 7 | 8 | v.push(x); 9 | v 10 | } 11 | 12 | fn main(){ 13 | let v0 = Vec::new(); 14 | let v1=anyadir_uno(v0, 3); 15 | 16 | println!("El valor de v0 es: {:?}",v0); //para formatear un vector se usa {:?} 17 | println!("El valor de v1 es: {:?}",v1); 18 | } -------------------------------------------------------------------------------- /structs-enums/structs-enums1.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 13: Structs en Rust 2 | * Mostrar la información de un struct que tenga de información el nombre y la edad. 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | struct Persona{ 7 | //TODO:Rellenar el struct 8 | } 9 | 10 | impl Persona{ 11 | fn mostrarinfo(self){ 12 | //TODO: Mostrar por pantalla el nombre y la edad de la persona 13 | } 14 | } 15 | 16 | fn main(){ 17 | let p:Persona=Persona{nombre: String::from("Victor"), edad: 33}; 18 | 19 | p.mostrarinfo(); 20 | } -------------------------------------------------------------------------------- /gestion-memoria/gestion-memoria2.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 9: gestion memoria Rust 2 | * Modificar este ejercicio para que compile 3 | * Autor: Victor Suarez 4 | */ 5 | 6 | fn anyadir_uno(v:&Vec,x:i32)->Vec{ 7 | 8 | let mut v=v.clone(); 9 | v.push(x); 10 | v 11 | } 12 | 13 | fn main(){ 14 | let v0 = Vec::new(); 15 | let v1=anyadir_uno(&v0, 3); 16 | 17 | println!("El valor de v0 es: {:?}",v0); //para formatear un vector se usa {:?} 18 | v1.push(4); 19 | println!("El valor de v1 es: {:?}",v1); 20 | } -------------------------------------------------------------------------------- /option-result/option-result1.rs: -------------------------------------------------------------------------------- 1 | /* Ejercicio 15: Option 2 | * Crear una funcion que devuelva el cuadrado de un numero positivo; en caso de establecer un negativo devolver None. 3 | * Autor: Victor Suarez 4 | */ 5 | //TODO: definir y escribir la funcion 6 | 7 | //fn mifuncion.... 8 | 9 | 10 | fn main(){ 11 | 12 | let x:i32=-2; 13 | 14 | match mifuncion(x) { 15 | Some(n) => println!("El cuadrado de {} es: {}", x,n), 16 | None => println!("No se permite llamar a la función con numeros negativos") 17 | } 18 | } -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Victor Suarez 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /bucles/README.md: -------------------------------------------------------------------------------- 1 | # Bucles 2 | 3 | En Rust, existen 3 tipos de bucles; ```for```, ```while``` y ```loop```. 4 | 5 | ## For 6 | 7 | El bucle for, permite realizar una serie de acciones de forma repetitiva un número definido de veces. 8 | 9 | ```rust 10 | for n in 0..10{ 11 | println!("Iteración {}", n); 12 | } 13 | ``` 14 | 15 | aunque puede usarse para iterar en colecciones: 16 | 17 | ```rust 18 | for a in collection.iter(){ 19 | println!("Objeto de la coleccion: {}",a) 20 | } 21 | ``` 22 | 23 | ## While 24 | 25 | Este bucle permite realizar acciones mientras se cumpla una condición: 26 | 27 | ```rust 28 | let mut a:u16=0; 29 | 30 | while a < 18{ 31 | println!("a vale: {}",a); 32 | a+=1; 33 | } 34 | ``` 35 | 36 | ## loop 37 | 38 | Este es un bucle infinito que estará funcionando mientras no se rompa el bucle con la instrucción ```break```. 39 | 40 | ```rust 41 | let mut a:u16=0; 42 | loop{ 43 | 44 | println!("a vale: {}",a); 45 | a+=1; 46 | if a>=18{ 47 | break; 48 | } 49 | 50 | } 51 | ``` 52 | 53 | **NOTA:** También existe la instrucción ```continue``` que parará la ejecución de la pasada actual del bucle y continuará a la siguiente. -------------------------------------------------------------------------------- /variables/README.md: -------------------------------------------------------------------------------- 1 | # Variables 2 | 3 | En Rust, para declarar una variable se utiliza la palabra reservada ```let```. 4 | 5 | ```rust 6 | let x = 1; 7 | ``` 8 | 9 | En este caso, hemos definido una variable sin tipado; el compilador infiere el tipo y lo asigna; siendo este de tipo ```i32``` (Entero con signo de 32 bits). Seguidamente se muestran los tipos de dato para números: 10 | 11 | | Tipo | Descripcion | 12 | | ---- | ----------- | 13 | | ```i32```,```i64```,```i16```,... | Entero con signo (32,64,16 bits,...) | 14 | | ```u32```,```u64```,```u16```,... | Entero sin signo (32,64,16 bits,...) | 15 | | ```f32```,```f64```,... | Coma flotante (32,64 bits,...) | 16 | 17 | Para definir un tipo de dato se usan los dos puntos después del nombre de la variable. 18 | 19 | ```rust 20 | let x:u16=8; 21 | ``` 22 | 23 | ## Mutabilidad 24 | 25 | Por defecto las variables en Rust se definen como inmutables; esto quiere decir, que no puede cambiar su valor; ejemplo: 26 | 27 | ```rust 28 | 29 | fn main(){ 30 | let x=5; 31 | ... 32 | x=1;//ERROR; no se puede cambiar de valor 33 | ... 34 | } 35 | ``` 36 | 37 | Para poder crear una variable para que pueda cambiar su valor, se añade la palabra reservada ```mut``` tras el ```let```. 38 | 39 | ```rust 40 | fn main(){ 41 | let mut x=5; 42 | ... 43 | x=1;//Ahora no da error. 44 | ... 45 | } 46 | ``` -------------------------------------------------------------------------------- /cadenas/README.md: -------------------------------------------------------------------------------- 1 | # Cadenas (Strings) 2 | 3 | Una cadena de caracteres es una sucesion de caracteres que se almacenan en memoria. En rust, podemos utilizarlos de dos formas. 4 | 5 | ## Literales 6 | 7 | Los literales en Rust, se definen en un texto entre comillas dobles ```"```. Estos se definen como el tipo de dato ```&str```; este tipo de cadenas son inmutables y estaticos; es decir que se almacenan en tiempo de compilación. 8 | 9 | ```rust 10 | let st="Hola Mundo"; //literal estatico se almacena en tiempo de ejecucion. 11 | ``` 12 | 13 | ## Strings 14 | 15 | Sin embargo, no siempre sabemos la lontigud o cuando va a estar almacenada nuestra cadena en memoria; por lo que se utilizará el tipo ```std::String```; para poder almacenar estas cadenas mutables. 16 | 17 | ```rust 18 | let mut cadena:String=String::from("Hola Mundo");//Almacenamos la cadena "Hola mundo como mutable" 19 | ``` 20 | 21 | ## Conversion de tipos 22 | 23 | Para poder convertir un tipo ```&str``` a ```String```, pueden usarse las siguientes funciones. 24 | 25 | ```rust 26 | let x:String=String::from("Hola Mundo"); //Convertir de &str a String, creando una nueva cadena. 27 | ``` 28 | 29 | ```rust 30 | let x:String= String::from("Hola Mundo"); 31 | let x1:&str=&x;//Convertir de String a &str 32 | ``` 33 | 34 | ```rust 35 | let x:String= "Hola mundo".to_string();//Convertir de &str a String. 36 | ``` 37 | -------------------------------------------------------------------------------- /modulos/README.md: -------------------------------------------------------------------------------- 1 | # Modulos 2 | 3 | Un modulo en Rust, es una coleccion de funciones y datos (structs,enums,etc...); que nos permiten organizar nuestro código; gracias a estos modulos podemos utilizar en caso necesario otros modulos y reutilizar nuestro código de forma sencilla; seguidamente se muestra como crear un modulo en Rust: 4 | 5 | ```rust 6 | mod mimodulo{ 7 | .... 8 | } 9 | ``` 10 | 11 | Los modulos normalmente, se almacenan en distintas carpetas y pueden estar anidados para organizar mejor las distintas funcionalidades de nuestro modulo. 12 | 13 | ```rust 14 | mod modulopadre{ 15 | mod modulohijo{ 16 | ... 17 | } 18 | } 19 | ``` 20 | 21 | Para poder cargar y usar todas las funcionalidades que nos provee un modulo usaremos la instrucción ```use```: 22 | 23 | ```rust 24 | use std::convert::f64 25 | ``` 26 | 27 | Otro aspecto a tener en cuenta es la visibilidad de las funciones y modulos; ya que muchas veces solo queremos que ciertas funciones puedan ser usada por nuestro modulo; es por ello, que se utiliza la palabra reservada ```pub``` para definir las funciones y modulos publicos. Por defecto son privados y solo pueden ser usados por su modulo y sus hijos. 28 | 29 | ```rust 30 | pub mod modulopadre{ //Modulo publico 31 | 32 | pub fn mifuncion(x:i32)->i32{//funcion publica 33 | ... 34 | } 35 | mod modulohijo{//modulo privado 36 | ... 37 | } 38 | } 39 | ``` 40 | 41 | -------------------------------------------------------------------------------- /funciones/README.md: -------------------------------------------------------------------------------- 1 | # Funciones 2 | 3 | En Rust, podemos definir funciones para poder dividir nuestro programa en distintas partes. La sintaxis para crear una función es la siguiente: 4 | 5 | ```rust 6 | fn name(param1:type1, param2: type2,paramn: typen) -> return_type{ 7 | ... 8 | } 9 | ``` 10 | 11 | Como vemos es obligatorio que todo parámetro tenga un tipo asociado y que tenga además un tipo de vuelta. 12 | 13 | ## Llamar a una función 14 | 15 | Para llamar a una función, simplemente se usa el nombre de esta y los parametros que necesita: 16 | 17 | ```rust 18 | fn main(){ 19 | ... 20 | mifuncion(3); 21 | ... 22 | } 23 | ``` 24 | 25 | ## Parámetros 26 | 27 | Como hemos podido ver en el ejemplo anterior, a las funciones se les puede pasar parámetros; pudiendose pasar de dos formas: 28 | 29 | * Por valor: se crea una copia de la variable y se pasa a la función. Veremos con más detalle este proceso en la gestión de memoria. 30 | * Por referencia: Se pasa una referencia la variable. Veremos con más detalle este proceso en la gestión de memoria. 31 | 32 | ```rust 33 | fn mifuncion(param1:i32)->i32{ //Paso de parametro por valor 34 | ... 35 | ``` 36 | 37 | ```rust 38 | fn mifuncion(param1:&i32){//Paso de parametro por referencia 39 | ... 40 | ``` 41 | 42 | ## Devolver un dato de la función 43 | 44 | Para poder devolver un dato, es imprescindible definir de que tipo será en la declaración de esta, usando el operador ```->```. 45 | 46 | En Rust, la ultima variable referenciada en una ejecución de una función, se toma como dato de respuesta de la función; ejemplo: 47 | 48 | ```rust 49 | fn doble(x:i32)->i32{ 50 | 2*x //Notese que no hay ; al final 51 | } 52 | ``` 53 | 54 | Sin embargo, tambien puede usarse la instrucción ```return```; Ejemplo: 55 | 56 | ```rust 57 | fn doble(x:i32)->i32{ 58 | return 2*x; 59 | } 60 | ``` -------------------------------------------------------------------------------- /arrays-tuplas/README.md: -------------------------------------------------------------------------------- 1 | # Arrays y Tuplas 2 | 3 | En esta seccion vamos a ver como generar colecciones tanto homogeneas (Arrays), como heterogeneas en Rust. 4 | 5 | ## Arrays 6 | 7 | Un Array es una coleccion homogenea de información del mismo tipo, almacenados de forma contigua. En Rust, se deben inicializar todos los componentes del array para poder tener la propiedad del valor correctamente. 8 | 9 | ```rust 10 | let a:[i32;5]=[0,1,2,3,4]; 11 | ``` 12 | 13 | Como vemos en el anterior ejemplo, se debe definir de que tipo será el array y cuantas posiciones se compone este. Los Arrays en Rust comienzan por la posición ```0```. 14 | 15 | ```rust 16 | let a:[i32;100]=[0;99];//podemos usar rangos para inicializar los array. 17 | ``` 18 | 19 | Podemos usar el bucle ```for```, para recorrer este array: 20 | 21 | ```rust 22 | let a:[i32;100]=[0;99]; 23 | for i in a{ 24 | println!("{}",i); 25 | } 26 | ``` 27 | 28 | Para acceder a una posicion del array se puede usar el operador ```[]```. No olvidar que los incides son en base 0. 29 | 30 | ```rust 31 | let a:[i32:4]=[0,1,2,3]; 32 | println!("{}",a[1]);//1 33 | ``` 34 | 35 | ### Slices 36 | 37 | Podemos usar un ```slice```, para poder obtener una parte de un array; para ello se usa el operador ```&``` y un rango de posiciones: 38 | 39 | ```rust 40 | let a:[i32;100]=[0;99]; 41 | 42 | let suba=&a[0..50];//Obtiene los 50 primeras posiciones de a. 43 | ``` 44 | 45 | ## Tuplas 46 | 47 | Las tuplas son listas ordenadas heterogeneas; de tal forma que no tienen que tener todos los elementos el mismo tipo. 48 | 49 | ```rust 50 | let t:(i32,i32,f64)=(2,3,3.124);//Una tupla compuesta por 3 elementos, 2 i32 y 1 f64. 51 | ``` 52 | 53 | Para acceder a las posiciones de la tupla se usa el operador ```.```; seguido de la pisición, empezando por 0. 54 | 55 | ```rust 56 | let t:(i32,i32,i16)=(1,2,3); 57 | println!("{}"t.0);//1 58 | ``` 59 | 60 | ### Deconstruir una tupla 61 | 62 | Podemos deconstruir una tupla para poder obtener cada posicion y poder operar con ellas. 63 | 64 | ```rust 65 | let t:(&str,i32):("Hola",2); 66 | let (name,x) = t; 67 | println!("name: {}, x: {}",name,x); 68 | ``` -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Laboratorio de Iniciación a Rust 2 | 3 | ![imagen](https://github.com/user-attachments/assets/1d06ef12-ce5b-4dd2-80ac-e4e1049ac8c3) 4 | 5 | 6 | Laboratorio de Introducción a Rust; en este repositorio, encontrará ejercicios e información, para iniciarse en el lenguaje de programación [Rust](https://www.rust-lang.org/). 7 | 8 | En este repositorio encontrarás ejercicios que te ayudaran a iniciarte en este lenguaje de programación; tanto a aprender su sintaxis, como a aprender las principales características que posee. 9 | 10 | Antes de nada, se deben instalar las distintas herramientas para poder utilizar Rust; por lo que recomendamos seguir las [instrucciones de la página oficial](https://www.rust-lang.org/tools/install). 11 | 12 | En cada carpeta encontrarás un fichero ```README```, con información y uno o varios ficheros con extensión ```.rs```; los cuales contienen ejercicios para resolver. 13 | 14 | Para compilar cada ejercicio y generar el binario, usaremos el compilador de rust ```rustc```. 15 | 16 | ```bash 17 | rustc fichero.rs 18 | ``` 19 | **NOTA:** Más adelante se usará el gestor ```cargo``` que es el que nos ayudará a generar nuestros binarios. 20 | 21 | Para poder saber la resolución de cada ejercicio, hay una rama especial de este repositorio llamada ```soluciones```. 22 | 23 | Seguidamente se muestra la tabla de contenidos de este repositorio: 24 | 25 | * [Hello World](hello-rust). 26 | * [Variables](variables). 27 | * [if-else](if). 28 | * [Bucles](bucles). 29 | * [Funciones](funciones). 30 | * [Gestión de memoria con Rust](gestion-memoria). 31 | * [Cadenas](cadenas). 32 | * [Arrays y Tuplas](arrays-tuplas). 33 | * [Structs y Enums](structs-enums). 34 | * [Option y Result](option-result). 35 | * [Modulos](modulos). 36 | * [Cargo](cargo). 37 | 38 | ## Licencia 39 | 40 | Todo el codigo fuente de este repositorio se considera con licencia MIT. Para más información consulte el fichero de licencia. 41 | 42 | El contenido descrito en este repositorio, se considera licencia Creative Commons ![cc4.0-bysca](https://i.creativecommons.org/l/by-sa/4.0/88x31.png) . Puede ver una copia de la licencia en el siguiente [enlace](http://creativecommons.org/licenses/by-sa/4.0/). 43 | -------------------------------------------------------------------------------- /option-result/README.md: -------------------------------------------------------------------------------- 1 | # Option y Result 2 | 3 | En Rust, existen 2 tipos especiales que nos pueden ayudar la hora de manejar distintos resultados de una misma función; ya sea debido por ejemplo a un error o que pueda devolver un dato vacío. 4 | 5 | ## Option 6 | 7 | Option es un tipo de dato que nos permite definir 2 opciones posibles; ```Some```y ```None```. De tal forma que en caso de que una operación tenga éxito, puede devolver el caso de ```Some``` o ```None``` en caso contrario. El tipo Option, tiene un tipo parametrizado que define en caso de que devuelva algo, el dato que tiene asignado. 8 | 9 | ```rust 10 | fn mifuncion(x:i32)-> Option{ 11 | 12 | if x>0 { 13 | Some(4) 14 | }else{ 15 | None 16 | } 17 | } 18 | ``` 19 | 20 | En el caso anterior por ejeplo, vemos que la función ```mifuncion```, devuelve un tipo ```Option``` con un tipo ```i32```; vemos como la función, puede devolver ```Some``` o ```None```; para establecer que devuelve un ```Some``` podemos establecer el valor devuelto entre parentesis. 21 | 22 | Para poder manejar los datos devueltos, podemos usar la estructura de control ```match```: 23 | 24 | ```rust 25 | let x=mifuncion(4); 26 | 27 | match x { 28 | Some(x) => println!("x vale {}", x), 29 | None => println!("Ha devuelto None") 30 | } 31 | ``` 32 | 33 | 34 | ## Result 35 | 36 | Otro tipo de dato especial es ```Result```, el cual nos permite definir que ocurre cuando una operación devuelve un dato correcto o uno erroneo. En este caso se pueden definir los dos casos devolviendo dos tipos de datos en función si ha dado ```Ok``` o ```Err```. Ejemplo: 37 | 38 | ```rust 39 | fn mifuncion(x:i32)-> Result{//A diferencia de Option, aquí hay dos tipos parametrizados; uno para OK y otro para Err. 40 | if x>=0 { 41 | Ok(4) 42 | }else{ 43 | Err("Ha ocurrido un error".to_string()) 44 | } 45 | } 46 | ``` 47 | 48 | Este tipo de dato se utiliza para poder controlar tanto los casos de éxito como los errores a la hora de manipular estos. 49 | 50 | ```rust 51 | match mifuncion(-1){ 52 | Ok(x) => println!("Ha devuelto: {}", x), 53 | Err(err) => println!("Ha ocurrido un error: {}", err), 54 | }; 55 | ``` -------------------------------------------------------------------------------- /cargo/README.md: -------------------------------------------------------------------------------- 1 | # Cargo 2 | 3 | Cargo es el gestor de dependencias y construccion que utiliza Rust; normalmente se instala al instalar Rust, y permite generar tanto nuestros programas, como crear librerías que podemos publicar en el repositorio de paquetes de Rust e incluso descargar dependencias de este. 4 | 5 | Hasta ahora, hemos estado utilizando el compilador de Rust, para poder compilar nuestros programnas; esta práctica no es recomendable ya que siempre es mejor realizando a través de cargo; ya que entre otras cosas, nos ayudará a organizar nuestro codigo e incluso a ejecutar tests. 6 | 7 | Por ejemplo para crear un nuevo proyecto con cargo, utilizaremos el siguiente comando: 8 | 9 | ```bash 10 | cargo init miproyecto 11 | ``` 12 | 13 | Esto generará un proyecto nuevo, y creara una carpeta llamada miproyecto; que contiene los siguientes elementos: 14 | 15 | * Carpeta SRC: Carpeta con los fuentes de nuestro proyecto. 16 | * Cargo.toml: Es el manifiesto de nuestro proyecto y es donde definiremos los datos de este e incluso las dependencias que tiene. 17 | 18 | Veamos un Ejemplo: 19 | 20 | ``` 21 | [package] 22 | name = "miproyecto" 23 | version = "0.1.0" 24 | authors = ["zerasul "] 25 | edition = "2018" 26 | 27 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 28 | 29 | [dependencies] 30 | ``` 31 | 32 | Como vemos hay 2 apartados; el primero con la etiqueta ```[package]``` contiene la información de nuestro proyecto; y la segunda, contiene las dependencias que tendrá nuestro proyecto. 33 | 34 | Una vez que tenemos creado nuestro proyecto, podemos compilarlo con la opción ```build```; ejemplo: 35 | 36 | ```bash 37 | cargo build 38 | ``` 39 | 40 | El cual nos devuelve lo siguiente: 41 | 42 | ```bash 43 | Compiling miproyecto v0.1.0 (E:\development\introrust\cargo\miproyecto) 44 | Finished dev [unoptimized + debuginfo] target(s) in 0.90s 45 | ``` 46 | 47 | En este caso al no especificar nada realiza una compilación sin optimizar; Si queremos optimizar usaremos la opción ```--release```; obteniendo el binario optimizado. 48 | 49 | **NOTA:** En la carpeta target, se encontrará los binarios compilados. 50 | 51 | Para más información acerca de ```cargo```, puede ir a la página oficial de [Rust](https://doc.rust-lang.org/cargo/). 52 | 53 | Este es el final del laboratorio de Rust; Si quieres saber más, puedes ir a la página oficial de Rust, o aprender con ejercicios usando el tutorial [Rustlings](https://github.com/fmoko/rustlings). -------------------------------------------------------------------------------- /makefile: -------------------------------------------------------------------------------- 1 | RUSTC = rustc 2 | CARGO = cargo build 3 | CHANGEDIR_VARIABLES = cd variables 4 | CHANGEDIR_IFELSE = cd if 5 | CHANGEDIR_BUCLES = cd bucles 6 | CHANGEDIR_FUNCIONES= cd funciones 7 | CHANGEDIR_GESTMEMORIA = cd gestion-memoria 8 | CHANGEDIR_CADENAS = cd cadenas 9 | CHANGEDIR_ARRAYS= cd arrays-tuplas 10 | CHANGEDIR_STRUCTS= cd structs-enums 11 | CHANGEDIR_OPTION= cd option-result 12 | CHANGEDIR_MODULES = cd modulos 13 | CHANGEDIR_CARGO = cd cargo/miproyecto 14 | 15 | all: variables if-else bucles funciones gestion-memoria cadenas arrays-tuplas structs-enums option-result modulos cargo 16 | 17 | variables: variables1.rs variables2.rs variables3.rs 18 | 19 | variables1.rs: 20 | ${CHANGEDIR_VARIABLES} && ${RUSTC} variables1.rs 21 | 22 | variables2.rs: 23 | ${CHANGEDIR_VARIABLES} && ${RUSTC} variables2.rs 24 | 25 | variables3.rs: 26 | ${CHANGEDIR_VARIABLES} && ${RUSTC} variables3.rs 27 | 28 | if-else: 29 | ${CHANGEDIR_IFELSE} && ${RUSTC} if-else.rs 30 | 31 | bucles: bucles1.rs bucles2.rs 32 | 33 | bucles1.rs: 34 | ${CHANGEDIR_BUCLES} && ${RUSTC} bucles1.rs 35 | 36 | bucles2.rs: 37 | ${CHANGEDIR_BUCLES} && ${RUSTC} bucles2.rs 38 | 39 | funciones: funciones1.rs 40 | 41 | funciones1.rs: 42 | ${CHANGEDIR_FUNCIONES} && ${RUSTC} funciones1.rs 43 | 44 | gestion-memoria: gestion-memoria1.rs gestion-memoria2.rs 45 | 46 | gestion-memoria1.rs: 47 | ${CHANGEDIR_GESTMEMORIA} && ${RUSTC} gestion-memoria1.rs 48 | 49 | gestion-memoria2.rs: 50 | ${CHANGEDIR_GESTMEMORIA} && ${RUSTC} gestion-memoria2.rs 51 | 52 | cadenas: cadenas1.rs cadenas2.rs 53 | 54 | cadenas1.rs: 55 | ${CHANGEDIR_CADENAS} && ${RUSTC} cadenas1.rs 56 | 57 | cadenas2.rs: 58 | ${CHANGEDIR_CADENAS} && ${RUSTC} cadenas2.rs 59 | 60 | arrays-tuplas: arrays-tuplas1.rs arrays-tuplas2.rs 61 | 62 | arrays-tuplas1.rs: 63 | ${CHANGEDIR_ARRAYS} && ${RUSTC} arrays-tuplas1.rs 64 | 65 | arrays-tuplas2.rs: 66 | ${CHANGEDIR_ARRAYS} && ${RUSTC} arrays-tuplas2.rs 67 | 68 | structs-enums: structs-enums1.rs structs-enums2.rs 69 | 70 | structs-enums1.rs: 71 | ${CHANGEDIR_STRUCTS} && ${RUSTC} structs-enums1.rs 72 | structs-enums2.rs: 73 | ${CHANGEDIR_STRUCTS} && ${RUSTC} structs-enums2.rs 74 | 75 | option-result: option-result1.rs option-result2.rs 76 | 77 | option-result1.rs: 78 | ${CHANGEDIR_OPTION} && ${RUSTC} option-result1.rs 79 | 80 | option-result2.rs: 81 | ${CHANGEDIR_OPTION} && ${RUSTC} option-result2.rs 82 | 83 | modulos: modulos1.rs 84 | 85 | modulos1.rs: 86 | ${CHANGEDIR_MODULES} && ${RUSTC} modulos1.rs 87 | 88 | cargo: cargo1 89 | 90 | cargo1: 91 | ${CHANGEDIR_CARGO} && ${CARGO} 92 | 93 | clean: 94 | rm **/*.pdb 95 | rm **/*.exe 96 | -------------------------------------------------------------------------------- /gestion-memoria/README.md: -------------------------------------------------------------------------------- 1 | # Gestión de memoria en Rust 2 | 3 | Una de las principales características de Rust es su gestión de memoria ya que nos garantiza en tiempo de compilación, que la memoria esta correctamente gestionada gracias a una serie de reglas que hay que tener en cuenta. 4 | 5 | Es muy importante conocer estos conceptos ya que serán necesarios para poder crear nuestros programas o librerías de forma segura. 6 | 7 | ## Ambito (Scope) 8 | 9 | En todo momento, una variable estará definido dentro de un ambito ya sea una función, o en un bloque de código. Cuando se sale de este ambito las variables que son definidas en este ambito son eliminadas. Esta comprobación se hace en tiempo de ejecución. Ejemplo: 10 | 11 | ```rust 12 | fn mifuncion(x:i32)->i32{ 13 | let y:i32=5; 14 | y*x//Tanto la variable x como la variable y estan definidas en el ambito de la función y serán eliminadas en cuanto termine la función. 15 | } 16 | ``` 17 | 18 | 19 | ## Propiedad del valor (Ownership) 20 | 21 | Uno de los principales conceptos de Rust es la propiedad del valor; es decir, cada valor almacenado en memoria, tiene asignado un propietario (ownership) de forma que este valor solo estará disponible dentro de su ambito. 22 | 23 | ```rust 24 | let x:Vec=Vec::new(); 25 | 26 | let x1=x; 27 | 28 | println("x vale {} y x1 vale {}",x,x1);//ERROR, el propietario del valor x ahora es x1; no puede usarse directamente. 29 | ``` 30 | 31 | ### Mover o Copiar el valor 32 | 33 | Para poder utilizar el valor de las variables sin que nos de error debido a no tener el propietario del valor. Para ello, podemos usar 2 soluciones: 34 | 35 | 1. Mover el valor 36 | 37 | Cuando la variable se trata de un tipo básico, el propio compilador mueve la propiedad de este valor a una nueva variable. 38 | 39 | ```rust 40 | let x:i32=0; 41 | let x1:i32=x; //El compilador ha movido el valor de una variable a otra. 42 | ``` 43 | 44 | 2. Copiar un valor (clonar) 45 | 46 | Cuando la variable se trata de un Objeto o tipo no básico, podemos clonar este objeto (si tiene implementada esta opción). 47 | 48 | ```rust 49 | let x:Vec= Vec::new(); 50 | 51 | let x1=x.clone(); //Se clona el objeto para hacer una copia. 52 | ``` 53 | 54 | ### Tomar Prestado (Borrowing) 55 | 56 | En algunas ocasiones, no es muy eficiente tener que copiar o clonar las variables de forma que en Rust, podemos usar referencias para poder "tomar prestada" la propiedad del valor. Para crear una referencia utilizaremos el operador ```&```. 57 | 58 | ```rust 59 | let x:Vec=Vec::new(); 60 | 61 | let x1=&x; //toma prestado la propiedad de x. 62 | ``` 63 | 64 | Sin embargo, las referencias por defecto son inmutables; por lo que si queremos también poder modificar el valor de este nos dará un error. Es por ello, que se pueden crear referencias mutables. 65 | 66 | ```rust 67 | let x:Vec=Vec::new(); 68 | 69 | let x1=&x; 70 | 71 | x1.push(1);//ERROR; Referencia inmutable 72 | ``` 73 | 74 | ```rust 75 | let x:Vec=Vec::new(); 76 | 77 | let x1=&mut x; 78 | 79 | *x1.push(1); // En este caso el operador * se utiliza para referenciar al valor que este referencia (en este caso x). 80 | ``` 81 | 82 | -------------------------------------------------------------------------------- /structs-enums/README.md: -------------------------------------------------------------------------------- 1 | # Structs y Enums 2 | 3 | ## Structs 4 | En Rust, como en otros lenguajes como C, se permite definir estructuras de datos compuestas de tal forma que podemos definir nuestros propios tipos. 5 | 6 | ```rust 7 | struct Persona{ 8 | nombre: String, 9 | edad: i32 10 | }; 11 | ``` 12 | 13 | Como vemos en el anterior ejemplo, para definir un Struct, se usa la palabra reservada ```struct``` seguido del nombre y la definición de este entre ```{}```. 14 | 15 | Para definir una variable de un tipo de Struct, se usa el nombre de este: 16 | 17 | ```rust 18 | let p:Persona; 19 | ``` 20 | 21 | Además, para acceder a los campos de un struct, usaremos el operador ```.``` seguido del nombre de este. 22 | 23 | ```rust 24 | let p:Persona; 25 | 26 | p.nombre=String::from("Victor"); 27 | ``` 28 | 29 | Aunque también podemos inicializar directamente el Struct: 30 | 31 | ```rust 32 | let p =Persona { nombre: String::from("Victor"), edad:33}; 33 | ``` 34 | 35 | ### Ampliar funcionalidad a un struct 36 | 37 | Podemos añadir metodos a un Struct para que puedan darnos funcionalidades extras; como por ejemplo inicializar un nuevo struct,etc... Estos metodos pueden ser estáticos o funciones del struct. 38 | 39 | ```rust 40 | impl Persona{ 41 | fn new()->Persona{ //Metodo Estatico 42 | let p =Persona{ nombre:String::new(), edad=0}; 43 | p 44 | } 45 | 46 | fn show_properties(self){ 47 | println!("Nombre: {}, edad: {}", self.nombre, self.edad); 48 | } 49 | } 50 | ``` 51 | 52 | Para poder usar estos métodos: 53 | 54 | ```rust 55 | ... 56 | let p:Persona= Persona::new();//Uso del metodo estatico para generar una nueva persona 57 | p.show_properties();//Uso del metodo del struct persona 58 | ... 59 | ``` 60 | 61 | ## Enums 62 | 63 | Un Enum, es un tipo de dato que puede tener distintos estados posibles; En Rust se define de la siguiente forma: 64 | 65 | ```rust 66 | enum Mienum{ 67 | Valor1, 68 | Valor2, 69 | Valor3 70 | }; 71 | ``` 72 | Sin embargo, en Rust podemos asociar información adicional a cada estado de un Enum: 73 | 74 | ```rust 75 | enum Mienum{ 76 | Valor1(i32), 77 | Valor2{x:i32,y:i32}, 78 | Valor3 79 | }; 80 | ``` 81 | 82 | Como podemos ver se puede definir en formato Struct o simplemente añadiendo un dato entre parentesis (como una tupla). 83 | 84 | Ahora vamos a ver como se crea una variable con un valor de un Enum: 85 | 86 | ```rust 87 | let v1:Mienum=Mienum::Valor1(3); //V1 es de tipo Mienum con valor 3. 88 | ``` 89 | 90 | También podemos añadir funciones a un Enum: 91 | 92 | ```rust 93 | impl Mienum{ 94 | fn show(&self){ 95 | println!("{:?}", &self); 96 | } 97 | } 98 | ``` 99 | 100 | ### Match 101 | 102 | A la hora de hablar de las estructuras de control condicionales, hemos mencionado la estructura ```match```; esta estructura nos va a permitir, en función del valor de una variable realizar una serie de acciones; e incluso poder establecer el valor de otra variable. Este es una de las estructura de control más importantes de Rust y que nos permitirá controlar por ejemplo los errores de nuestros programas, como veremos más adelante con las estructuras de ```Option```o ```Result```. 103 | 104 | ```rust 105 | ... 106 | let m=Mienum::Valor1(3); 107 | 108 | match m{ 109 | Mienum::Valor1(n) => println!("El valor de n es: {}", n), 110 | Mienum::Valor2{x:x,y:y} => pritnln!("x vale: {} e y vale: {}", x,y), 111 | Mienum::Valor3 => println!("Valor 3") 112 | }; 113 | ``` 114 | --------------------------------------------------------------------------------