{"id":23870035,"url":"https://github.com/fabriziojordan/hello-cargo","last_synced_at":"2026-06-20T17:31:57.761Z","repository":{"id":270766230,"uuid":"909553318","full_name":"FabrizioJordan/hello-cargo","owner":"FabrizioJordan","description":"Un pequeño tutorial/guía de Rust. También te sirve si te olvidas de algo medio simple.","archived":false,"fork":false,"pushed_at":"2025-01-12T02:58:05.000Z","size":971,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-01-12T03:27:27.592Z","etag":null,"topics":["guide","guidelines","rust","rustlang","tutorial","tutorials"],"latest_commit_sha":null,"homepage":"","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/FabrizioJordan.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-12-29T03:56:42.000Z","updated_at":"2025-01-12T02:58:08.000Z","dependencies_parsed_at":"2025-01-03T21:30:28.779Z","dependency_job_id":"f20f8e82-561d-4963-ac4a-a651e32b84ef","html_url":"https://github.com/FabrizioJordan/hello-cargo","commit_stats":null,"previous_names":["fabriziojordan/hello-cargo"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/FabrizioJordan%2Fhello-cargo","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/FabrizioJordan%2Fhello-cargo/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/FabrizioJordan%2Fhello-cargo/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/FabrizioJordan%2Fhello-cargo/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/FabrizioJordan","download_url":"https://codeload.github.com/FabrizioJordan/hello-cargo/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":240215686,"owners_count":19766456,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["guide","guidelines","rust","rustlang","tutorial","tutorials"],"created_at":"2025-01-03T13:34:11.731Z","updated_at":"2025-11-12T17:04:48.312Z","avatar_url":"https://github.com/FabrizioJordan.png","language":"Rust","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Para entender todo esto:\n\n## Compilar y ejecutar \n\nRust es un lenguaje de compilación. Por ende se debe compilar antes para poder ejecutarse.\n\nPara compilar:\n```\nrustc main.rs\n```\nEsto crea un archivo llamado main sin extensión.\n\nPara ejecutar:\n```\n./main\n```\n\n\n## Declarar variables\n\nEn Rust, todas las variables son inmutables por defecto.\nOsea que si se asigna un valor a una variable este valor no se puede volver a cambiar.\n \nVariables inmutables por defecto:\n\n```\nlet valor = 10;\n```\n\n¿Cómo se puede volver mutable una variable? Fácil, sólo hay que añadir un \"mut\" antes del nombre de la variable \n\nVariables mutables:\n```\nlet mut valor2 = 10;\n```\n\n\nAhora, algo que usa en Rust son las referencias a otra variable.\n\n\u0026 es una referencia a una variable, pero la referencia es inmutable\n\nEjemplo:\n\n```\nlet x = 10;\nlet y = \u0026x;\n\n// si se hace un println! de los dos\n// tanto \"x\" como \"y\" darán 10, pero \"y\" no se puede mutar\n```\n\n\u003cbr\u003e\n\n## Tipos de variables (o dato)\n\nPara aprender sobre inmutabilidad y mutabilidad (importante en Rust) ve al anterior punto (Declarar variables). \n\n\u003cbr\u003e\n\n### Números: \n\n\nLos tipos de variables numéricas se dividen en enteros y de punto flotante. \nHay que recordar que Rust es un lenguaje explícito y extricto, por lo cual sí o sí las variables que usan un tipo de dato número deben usar estas opciones para ser seguro y tener el mejor rendimiento en el código.\n\n\u003cbr\u003e\nEjemplos:\n\n\u003cbr\u003e\nCon \"i\" ;\n\n\u003cbr\u003e\ni128 : (el \"128\" habla de ser un número de máximo 128 bits, no bytes)\n\n\u003cbr\u003e\ni32 : (el \"i\" significa que el número puede ser positivo o negativo)\n\n\u003cbr\u003e\ni32 : (\"i32\" puede almacenar valores desde -2,147,483,648 hasta 2,147,483,647),\n\n\u003cbr\u003e\nisize :  (entero con signo cuyo tamaño depende de la arquitectura del sistema, si tu sistema es de 32 bits entonces este número será de 32 bits y lo mismo para 64 bits)\n\n\u003cbr\u003e\nCon \"u\" ;\n\n\u003cbr\u003e\nu32 : (la \"u\" significa sin signo, osea que sólo puede ser positivo)\n\nu32 : (\"u32\" puede almacenar valores desde 0 hasta 4,294,967,295),\n\nusize : (entero sin signo cuyo tamaño depende de la arquitectura del sistema, si tu sistema es de 32 bits entonces este número será de 32 bits y lo mismo para 64 bits)\n\n\u003cbr\u003e\nPara crear variables con estos tipos;\n\ni32:\n```\nlet num1: i32 = -10\nlet num2: i32 = 10\n```\n\nu32:\n```\nlet num3: u32 = 10\n```\n\n\u003cbr\u003e\n\n\n### Char y String (también \u0026str):\n\n#### Char:\n\nChar sólo permite crear una variable de un único carácter.\n\nEjemplo:\n```\nlet emoji: char = '🦀';\n```\n\u003cbr\u003e\n\n\n#### String y \u0026str, ¿que signfica cada uno?\n\nString (y \u0026str) es un tipo de variable muy complejo.\n\nString es un tipo de dato (aunque en realidad es una referencia) parecida a otros lenguajes, aunque puede \"mutar\" (en realidad es dinámica), osea que puede crecer y cambiar de tamaño. Por lo cual no es realmente mutable.\n\nEjemplos;\n\nPara crear una cadena vacía de String:\n\n```\nlet mut s = String::new();\n\n// se usa mut ya que no tendría sentido crear una cadena de texto vacía inmutable \n```\n\n```\nlet s = String::from(\"Hola\");\n\n// se convierte una cadena de texto literal a un tipo de dato String\n```\n\n\n#### \u0026str (o string slice):\n\n\u0026str es una referencia a una cadena de texto, pero inmutable por defecto.\n\u0026str se utiliza comúnmente para trabajar con literales de cadena y para pasar cadenas de texto como referencias sin necesidad de copiar los datos.\n\n\nEjemplos;\n\n```\nlet saludo: \u0026str = \"Hola, mundo!\";\n```\n\n\nAcá un ejemplo de lo explicado, que \u0026str es para trabajar con cedenas de texto que son referencias.\n\n```\nlet s = String::from(\"Hola, mundo!\");\nlet parte: \u0026str = \u0026s[0..4]; // \"Hola\"\n```\n\n\n### bool (o también llamado tipo booleano):\n\nCasi igual a otros lenguajes, el tipo booleano puede ser \"true\" o \"false\".\nNormalmente se usan para if, else, while (obligatorio) y match.\n\n\n```\nlet es_verdadero: bool = true;\nlet es_falso: bool = false;\n```\n\n\u003cbr\u003e\n\n## Tipos de structs (y tuplas)\nAlgunos son cómo objetos en JS y otros lenguajes.\nEn esta parte también te dejo las tuplas.\n\n\n### Tuplas:\nAntes de seguir con el resto de estructuras de datos te dejo las tuplas (parecido a un objeto de JavaScript).\n\nLas tuplas pueden contener elementos de diferentes tipos, estando agrupados juntos. Las tuplas son útiles para agrupar un pequeño número de valores heterogéneos.\nLas tuplas se definen cómo cualquier variable, u objeto en caso de JavaScript.\n\n```\nlet tupla: (i32, f64, bool) = (42, 3.14, true);\n```\n\nLas tuplas son sólo pedazos de código que se declaran y se usan (a diferencia de las estructuras de tupla).\n\nDejo un código como ejemplo de DOS formas que se tienen para acceder a los elementos dentro de una tupla.\n\n```\n// Acceder a los elementos de la tupla por su posición\nlet (x, y, z) = tupla;\nprintln!(\"x: {}, y: {}, z: {}\", x, y, z);\n\n// También se puede acceder a los elementos usando índices\nprintln!(\"El primer valor es: {}\", tupla.0);\nprintln!(\"El segundo valor es: {}\", tupla.1);\nprintln!(\"El tercer valor es: {}\", tupla.2);\n```\n\n\n### Estructuras (structs):\n\nAlgunos tipos de structs son, structs clásicas, structs de tupla y structs unitarios. \nLas estructuras serían parecido a usar POO (programación orientada a objetos) en JavaScript u otros lenguajes. Por lo cual se crean instancias de estas structs.\n\n\nSobre todo voy a usar ejemplos para estos casos.\n\n\n### Estructura de tipo Tupla:\nSe acceden a los valores de la instancia por posición (tuple.0 = primer valor).\n\n```\nstruct Color(u8, u8, u8);\n```\nSon cómo las tuplas pero tienen nombre y se definen cómo el resto de estructuras (struct).\nLos campos de esta estructura no tienen nombre, sólo posiciones cómo las tuplas.\n\nSon bastante útiles para usar un grupo de elementos (del mismo tipo) sin necesidad de nombres para cada campo.\n\nEjemplo \n```\nstruct Color(u8, u8, u8);\n\nlet rojo = Color(255, 0, 0);\n\n// Acceder a los elementos de la estructura de tupla por su posición\nprintln!(\"Rojo: {}, Verde: {}, Azul: {}\", rojo.0, rojo.1, rojo.2);\n```\n\n\n### Estructura clásicas:\nCampos con nombres. Muy parecidas a los objetos en otros lenguajes.\nSe acceden a los valores de la instancia por campos con nombre.\n\nAsí se definen:\n```\nstruct Persona {\n    nombre: String,\n    edad: u8,\n    es_estudiante: bool,\n}\n```\n\nAsí se usan:\n```\nlet persona = Persona {\n    nombre: String::from(\"Alice\"),\n    edad: 30,\n    es_estudiante: true,\n};\n\nprintln!(\"Nombre: {}\", persona.nombre);\n```\n\n\n### Estructuras unitarias:\nNo tienen campos. Se utilizan sobre todo para implementar traits en tipos que no tienen datos asociados. Cómo esto es más complejo lo dejo para otra guía.\n\nSe definen así:\n```\nstruct Unit_Struct;\n```\n\nEjemplo\nBásicamente se usan para por ejemplo darles comportamientos específicos a diferentes roles de usuario.\n```\nstruct Admin;\nstruct Guest;\n\n// código más complejo dando compotamiento usando traits.\n```\n\n### Enum\n\n\u003ca id=\"item_enum\"\u003e\u003c/a\u003e\n\n¿Qué es un enum? \n\nUn enum es un tipo de dato, sirve para tener sus posibles variantes, o también llamados conjuntos de valores fijos.\n\nEs un tipo de dato personalizado, por lo cual todas sus variantes pueden ser personalizadas.\n\nEjemplo:\n\n```\nenum TipoDeComputador {\n    PC,\n    Laptop,\n}\n```\n\nVamos a seguir este ejemplo un poco más, como si tuvieramos dos opciones en una venta.\n\n```\n\nenum TipoDeComputador {\n    PC,\n    Laptop,\n}\n\nstruct VentaDeComputador {\n    tipo: TipoDeComputador,\n    valor: String,\n}\n\nlet computador_sobremesa = VentaDeComputador{\n    tipo: TipoDeComputador::PC,\n    valor: String::from(\"12000\")\n};\n\nlet computador_laptop = VentaDeComputador{\n    tipo: TipoDeComputador::Laptop,\n    valor: String::from(\"6200\")\n};\n\n```\n\nLo que hacemos en este caso es crear un enum, con dos variantes, si es una PC de sobremesa o si es una Laptop. \n\nLuego creamos un struct clásico (casi que un objeto) donde el tipo de computador será si o si una de las variantes del enum creado anteriormente, y por último instanciamos el struct creando dos ejemplos.\n\n## Funciones\n\nCreación de una función.\nLas funciones se crean con la palabra clave \"fn\".\n\n```\nfn main(){}\n```\n\nPara crear la función main.\n\n\n### Importaciones y funciones públicas\n\nPara importar y poder ejecutar una función de otro archivo se debe hacer pública dicha función a usar.\n\nSi en un archivo tenemos la función main y la queremos ejecutar desde el archivo principal (main) debemos hacer esto:\n\n1. Debemos volver pública la función.\n   Así se hace una función pública:\n   ```\n   pub(crate) fn nombre_función(){}\n   ```\n2. Luego debemos añadir el archivo donde está la función pública.\n   ```\n   mod nombre_archivo;\n   ```\n   Si se necesita un archiv que está en una subcarpeta:\n   ```\n   #[path = \"subcarpeta/archivo.rs\"] mod nombre_función;\n   ```\n3. Ahora se debe ejecutar la función.\n   Se puede ejecutar la función desde cualquier parte del código.\n   ```\n   nombre_archivo::nombre_función;\n   ```\n\nAquí te dejo un ejemplo:\n\n```\n// se añade el archivo y la función\n#[path = \"exercises/exercise3.rs\"] mod exercise3;\n// se ejecuta la función\nexercise3::main();\n```\n\n\n## Bucles, flujos de control, etc.\n\nHay varios bucles que conozco.\nLoop, While y For.\n\n\n### Loop: Bucle infinito.\n\nAunque loop es un bucle infinito, este tiene la opción de parar.\nPara parar un loop se usa la instrucción \"break;\"\n\nPueden haber varios \"break\" en todo el loop (aunque no tendrían sentido si no se usan dentro de condicionales)\nSi un sólo \"break\" devuelve un valor (cómo lo hace return, osea \"break valor;\") entonces todos los otros deben hacerlo.\nSi no se devuelve nada de forma explícita, entonces el programa lo hará. El programa devuelve cómo mínimo una tupla vacía, osea ().\n\nLa sintaxis de loop es:\n\n```\nloop {\n    // código\n}\n```\n\nOtro agregado de ```loop``` es el uso del ```continue```.\n\nCuando necesitas que en medio de una iteración del \"loop\" se pase de largo el resto del código pero que no pare de iterar (cómo lo hace ```break;```), entonces se puede usar ```continue;```\n\nOsea básicamente si uno quiere en medio de una iteración parar la actual, e ir a la siguiente, se puede usar ```continue```.\n\nAcá te dejo un ejemplo:\n\n```\n// loop medio simple (con continue)\n\n    // las dos siguientes líneas son para conseguir un número al azar\n    use rand::Rng;\n    let azar_numero = rand::thread_rng().gen_range(1..=100);\n    \n    let mut num_actual = 0;\n    loop { \n        println!(\"El número actual es: {}\", num_actual);\n        if num_actual == azar_numero {\n            continue;\n        }\n        num_actual += 1;\n    }\n```\n\n\n### While: Expresión condicional.\n\nWhile funciona con condicional, por lo cual se ejecuta si la \n\nLa sintaxis de while es:\n```\nwhile condición {\n    // código\n}\n```\n\n### For: Iteraciones.\n\nFor funciona de dos formas. Siempre se ejecuta un número determinado de veces.\nSe puede iterar sobre una colección de elementos, osea sobre una matriz, un vector o un mapa hash.\nEn estos casos, se usa una variable temporal cómo en otros lenguajes para almacenar el valor de cada iteracion.\n\nEjemplo 1:\n```\nlet big_birds = [\"ostrich\", \"peacock\", \"stork\", \"heron\", \"flamingo\"];\n    for bird in big_birds.iter(){\n        println!(\"The bird is: {}\", bird);\n    }\n```\nSe usa \".iter()\" para iterar entre los elementos.\nY la variable temporal es \"bird\"\n\n\nOtra forma de iterar es sobre un rango.\nSe usa \"..\" para crear un rango abierto, osea que no incluye el valor final.\nY se usa \"..=\" para crear un rango cerrado, el cual sí incluye el valor final.\n\n```\n// con ..\nfor number in 1..6{ // comienza en 1 y termina en 5\n        println!(\"The number is: {}\", number);\n    }\n\n// con ..=\nfor number in 1..=6{ // comienza en 1 y termina en 6\n    println!(\"The number is: {}\", number);\n}\n```\n\n\n\u003cbr\u003e\n\u003cbr\u003e\n\nSi buscas los bucles for, while y loop están en:\n\nsrc \u003e control\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ffabriziojordan%2Fhello-cargo","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ffabriziojordan%2Fhello-cargo","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ffabriziojordan%2Fhello-cargo/lists"}