El Mago del Rust - User contributions [en]

Tipos de datos

2021-03-10T03:47:45Z

Lochi:

Todo valor en Rust es de un tipo específico. Rust necesita saber ese tipo al momento de compilar el programa, y muchas veces puede inferir el tipo. En otras ocasiones debemos indicarlo explícitamente, y si no lo hacemos produciremos un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error]] de compilación.

Hay dos categorías:
==Escalares==
Un tipo escalar representa un valor único, y existen cuatro tipos escalares: enteros, punto flotantes, booleanos, y caracteres.
===Enteros===
Un entero es un número sin una parte fraccional. Pueden tener signo o no, y ser de 8 a 128 bits. Si tiene signos, el tipo empieza con i y si no tiene signo empieza con u.

====Tamaños y signo====
El tipo empieza con i y u, y continúa con el tamaño en bits, desde 8 hasta 128 bits: i8, u8, i16, u16, y así sucesivamente hasta i128 y u128.

Se usa [[complemento a dos]] para representar los números negativos.

===Punto flotante===
Hay dos tipos primitivos de [[punto flotante]]: f32 (32 bits, precisión simple) y f64 (64 bits, doble precisión). Si no se especifica el tipo, se asume por defecto que es f64. Se usa el estándar [[IEEE-754]] de punto flotante.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let pi = 3.14; // se asume tipo f64
let as: f32 = 3.14; // esta variable es de tipo f32
}
</syntaxhighlight>

===Booleanos===
Una variable booleana puede ser o <code>true</code> o <code>false</code>, y ocupa un byte de almacenamiento.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let bandera = true;
let otra_bandera: bool = false;
}
</syntaxhighlight>
===Caracteres===
Para almacenar letras, se puede usar <code>char</code>, y se define con comilla única (no doble comilla o comillas que son para las cadenas de caracteres). Los caracteres ocupan 4 bytes de almacenamiento.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let p = 'p';
}
</syntaxhighlight>

==Compuestos==
Los tipos compuestos agrupan varios valores en un sólo tipo. Existen dos: tuples y arreglos.
===Tuples===
Agrupan diferentes tipos en un sólo tipo compuesto. Tienen un tamaño definido: no se pueden modificar de tamaño una vez creados.

Se crean usando paréntesis y separando la lista de valores con comas. Cada posición es un tipo, y no necesitan ser iguales.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let tuple: (i32, char) = (12,'d');
println!("El valor es {}",tuple.1);
}
</syntaxhighlight>

La salida del programa sería <code>d</code>. (<code>tuple.0</code> se refiere al i32, y <code>tuple.1</code> al caracter).

Otra forma es asignar parte de ese tuple a una variable, de la siguiente manera:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let tuple: (i32, char) = (12,'d');
let (a,b)=tuple;
println!("El valor es {}",b);
}
</syntaxhighlight>

===Arreglos===
En los arreglos, todos los valores deben ser del mismo tipo, y deben tener un tamaño fijo. En este ejemplo, el arreglo a tiene 3 valores:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a = [0,1,2];
}
</syntaxhighlight>

Los arreglos se definen estáticamente, por lo que están en el [[Stack|stack]] y no en el [[Heap|heap]]. Si se desea algo dinámico, se puede usar un <code>vector</code>.

Si se desea explicitar el tipo y el número de elemento se haría:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a: [i32;3] = [0,1,2];
}
</syntaxhighlight>

Si quieres inicializar todo un arreglo con un mismo valor puedes hacer esto:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a = [5;10]; //esto inicializa con 10 elementos con un valor de 5.
}
</syntaxhighlight>

Los elementos de un arreglo se accesan de la misma forma que en otros lenguajes: <code>a[0]</code> accesa su primer elemento, y así sucesivamente.

====Arreglos bidimensionales====
Se pueden definir explícitamente:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let mut state = [[0,0],[0,1]];
}
</syntaxhighlight>

También se pueden definir de esta forma, un arreglo de 8 por 16:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let mut arreglo: [[i32; 16]; 8];
}
</syntaxhighlight>

==String==
Un String está localizado en el [[Heap|heap]] y no en el [[Stack|stack]], por lo que puede cambiar de tamaño durante la ejecución del programa. Se crea de la siguiente forma:
<syntaxhighlight lang="rust" line='line' highlight="1">
let s = String::from("hola");
</syntaxhighlight>

Y se puede extender si le hacemos un push:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut s = String::from("hola");
s.push_str(", ¿cómo te va?");
println!("{}", s);
}
</syntaxhighlight>
Este programa creará el String y le agregará al final el mensaje ", ¿cómo te va?".

Control de flujo de ejecución

2021-03-09T03:43:30Z

Lochi:

Las dos estructuras más importantes para el control del flujo de ejecución son los lazos y la expresión <code>if</code>:

=Expresiones <code>if/else</code>=
Muy similar a otros lenguajes, se evalúa si es falso o verdadero una expresión. En este caso se evalúa si una variable es menor a 10 o no:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a < 10 {
println!("la expresión es verdadera");
}else {
println!("la exprexión es false");
}
}
</syntaxhighlight>

La expresión a evaluar debe ser de tipo <code>bool</code>, de lo contrario producirá un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error 308]]. Sobre comparaciones entre variables, se puede ver [[Comparaciones|acá]]

El <code>else</code> es opcional, y se pueden colocar varias expresiones <code>if/else</code> en cascada:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a == 10 {
println!("la variable es 10");
}else if a == 4 {
println!("la variable es 4");
}else if a == 7 {
println!("la variable es 7");
}else {
println!("la variable no es ni 10, 4 ni 7");
}
}
</syntaxhighlight>

Si debes poner muchos <code>if/else</code> en cascada, lo mejor sería usar un [[#Match]].

==Usando en <code>let</code>==
Como el <code>if</code> es una expresión, se puede utilizar en el lado derecho de un <code>let</code>:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
let b = 7;
let c = if a>b {3} else {1};
println!("El valor es {}",c);
}
</syntaxhighlight>

Al ejecutar este programa, la salida sería "1".

=Lazos con <code>loop</code>=
El comando <code>loop</code> causa que un bloque de código se repita infinitas veces a menos de que explícitamente se le ordene que termine. Este código nunca terminará:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
loop {
println!("hola");
}
}
</syntaxhighlight>

La única forma de que deje de imprimir "hola" es usando Control-C.

==Saliendo de un lazo con <code>break</code>==
Con <code>break</code> la iteración termina y se sale del lazo.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a=0;
loop {
a=a+1;
println!("{}",a);
if a == 100 {break;}
}
}

</syntaxhighlight>

En este programa, al llegar la impresión a 100, terminará el programa.

==Devolviendo un valor==
<code>loop</code> ejecuta una expresión varias veces y se puede utilizar el <code>break</code> para devolver un valor, por ejemplo en una asignación:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
let b= loop {
a=a+1;
if a == 100 {
break a;
}
};
println!("{}",b);
}

</syntaxhighlight>

=Lazos condicionales con <code>while</code>=
Una forma de tener un lazo con un condicional es usar <code>while</code>. El programa anterior modificado sería:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
while a != 100 {
a=a+1;
}
println!("{}",a);
}
</syntaxhighlight>

=Lazos con <code>for</code>=
Hay varias formas de usar <code>for</code> para crear un lazo con un iterador.

==Iterador con <code>..</code>==
Con un iterador <code>a..b</code>, los valores van desde a inclusive hasta b (excluyendolo):

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..10 {
println!("{}",a);
}
}
</syntaxhighlight>
En este ejemplo, se imprimirán los valores desde 1 hasta 9. En este caso la variable <code>a</code> no necesita ser declarada explícitamente antes.

Si quisiéramos que el iterador fuera desde a hasta b inclusive, podemos poner un <code>=</code> antes de la segunda variable:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..=10 {
println!("{}",a);
}
}
</syntaxhighlight>

==Iteradores==
Hay varios iteradores: <code>into_iter</code>, <code>iter</code> y <code>iter_mut</code>.
===<code>iter</code>===
Toma cada elemento de la colección para cada iteración.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = [0,1,2];
for x in a.iter() {
println!("{}",x);
}
}
</syntaxhighlight>
En este ejemplo, se imprime los números 0,1,2.

===<code>iter_iter</code>===
Toma cada elemento de la colección y lo saca de la misma. Al final del for, la colección estará vacía.

===<code>iter_mut</code>===
Toma cada elemento, permitiendo su modificación.

=Match=
<code>Match</code> permite encontrar patrones, que se pueden usar como un <code>switch</code> en el lenguaje C:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a=5;

match a {
1 => println!("uno"),
2 | 3 | 5 | 7 => println!("es un número primo"),
_ => println! ("cualquier otro número"),
}
}
</syntaxhighlight>

Cada opción está separada por una coma, y se usa | para considerar varias opciones a la vez.

Control de flujo de ejecución

2021-03-09T03:42:14Z

Lochi:

Las dos estructuras más importantes para el control del flujo de ejecución son los lazos y la expresión <code>if</code>:

=Expresiones <code>if/else</code>=
Muy similar a otros lenguajes, se evalúa si es falso o verdadero una expresión. En este caso se evalúa si una variable es menor a 10 o no:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a < 10 {
println!("la expresión es verdadera");
}else {
println!("la exprexión es false");
}
}
</syntaxhighlight>

La expresión a evaluar debe ser de tipo <code>bool</code>, de lo contrario producirá un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error 308]]. Sobre comparaciones entre variables, se puede ver [[Comparaciones|acá]]

El <code>else</code> es opcional, y se pueden colocar varias expresiones <code>if/else</code> en cascada:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a == 10 {
println!("la variable es 10");
}else if a == 4 {
println!("la variable es 4");
}else if a == 7 {
println!("la variable es 7");
}else {
println!("la variable no es ni 10, 4 ni 7");
}
}
</syntaxhighlight>

Si debes poner muchos <code>if/else</code> en cascada, lo mejor sería usar un [[#match]].

==Usando en <code>let</code>==
Como el <code>if</code> es una expresión, se puede utilizar en el lado derecho de un <code>let</code>:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
let b = 7;
let c = if a>b {3} else {1};
println!("El valor es {}",c);
}
</syntaxhighlight>

Al ejecutar este programa, la salida sería "1".

=Lazos con <code>loop</code>=
El comando <code>loop</code> causa que un bloque de código se repita infinitas veces a menos de que explícitamente se le ordene que termine. Este código nunca terminará:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
loop {
println!("hola");
}
}
</syntaxhighlight>

La única forma de que deje de imprimir "hola" es usando Control-C.

==Saliendo de un lazo con <code>break</code>==
Con <code>break</code> la iteración termina y se sale del lazo.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a=0;
loop {
a=a+1;
println!("{}",a);
if a == 100 {break;}
}
}

</syntaxhighlight>

En este programa, al llegar la impresión a 100, terminará el programa.

==Devolviendo un valor==
<code>loop</code> ejecuta una expresión varias veces y se puede utilizar el <code>break</code> para devolver un valor, por ejemplo en una asignación:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
let b= loop {
a=a+1;
if a == 100 {
break a;
}
};
println!("{}",b);
}

</syntaxhighlight>

=Lazos condicionales con <code>while</code>=
Una forma de tener un lazo con un condicional es usar <code>while</code>. El programa anterior modificado sería:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
while a != 100 {
a=a+1;
}
println!("{}",a);
}
</syntaxhighlight>

=Lazos con <code>for</code>=
Hay varias formas de usar <code>for</code> para crear un lazo con un iterador.

==Iterador con <code>..</code>==
Con un iterador <code>a..b</code>, los valores van desde a inclusive hasta b (excluyendolo):

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..10 {
println!("{}",a);
}
}
</syntaxhighlight>
En este ejemplo, se imprimirán los valores desde 1 hasta 9. En este caso la variable <code>a</code> no necesita ser declarada explícitamente antes.

Si quisiéramos que el iterador fuera desde a hasta b inclusive, podemos poner un <code>=</code> antes de la segunda variable:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..=10 {
println!("{}",a);
}
}
</syntaxhighlight>

==Iteradores==
Hay varios iteradores: <code>into_iter</code>, <code>iter</code> y <code>iter_mut</code>.
===<code>iter</code>===
Toma cada elemento de la colección para cada iteración.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = [0,1,2];
for x in a.iter() {
println!("{}",x);
}
}
</syntaxhighlight>
En este ejemplo, se imprime los números 0,1,2.

===<code>iter_iter</code>===
Toma cada elemento de la colección y lo saca de la misma. Al final del for, la colección estará vacía.

===<code>iter_mut</code>===
Toma cada elemento, permitiendo su modificación.

=Match=
<code>Match</code> permite encontrar patrones, que se pueden usar como un <code>switch</code> en el lenguaje C:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a=5;

match a {
1 => println!("uno"),
2 | 3 | 5 | 7 => println!("es un número primo"),
_ => println! ("cualquier otro número"),
}
}
</syntaxhighlight>

Cada opción está separada por una coma, y se usa | para considerar varias opciones a la vez.

Ownership - Pertenencia

2021-03-09T03:40:26Z

Lochi:

El Ownership o pertenencia es un concepto central en Rust y facilita el manejo de memoria, a diferencia de otros lenguajes que requieren un manejo más consciente de la memoria (y de su liberación con los recolectores de basura).

=Reglas del ownership=
#Cada valor en Rust tiene una variable que se llama su ''owner'' o propietario.
#Solamente puede existir un propietario en un momento determinado.
#Cuando el propietario sale del ámbito, el valor de borra.

=Ámbito de las variables=
El ámbito es el rango dentro de un programa en donde el item es válido. Por ejemplo, la variable <code>a</code> tiene su valor válido dentro del ámbito definido por las llaves:
<syntaxhighlight lang="rust" line='line' highlight="1">
{
let a = "hola";

//todo este es el ámbito de a
}
</syntaxhighlight>

Ownership - Pertenencia

2021-03-09T03:38:20Z

Lochi: /* Reglas del ownership */

Ownership - Pertenencia

2021-03-09T03:36:45Z

Lochi: Created page with "El Ownership o pertenencia es un concepto central en Rust y facilita el manejo de memoria, a diferencia de otros lenguajes que requieren un manejo más consciente de la memori..."

Main Page

2021-03-09T03:32:52Z

Lochi: /* Conceptos importantes en Rust */

Control de flujo de ejecución

2021-03-06T02:02:58Z

Lochi:

Las dos estructuras más importantes para el control del flujo de ejecución son los lazos y la expresión <code>if</code>:

=Expresiones <code>if/else</code>=
Muy similar a otros lenguajes, se evalúa si es falso o verdadero una expresión. En este caso se evalúa si una variable es menor a 10 o no:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a < 10 {
println!("la expresión es verdadera");
}else {
println!("la exprexión es false");
}
}
</syntaxhighlight>

La expresión a evaluar debe ser de tipo <code>bool</code>, de lo contrario producirá un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error 308]]. Sobre comparaciones entre variables, se puede ver [[Comparaciones|acá]]

El <code>else</code> es opcional, y se pueden colocar varias expresiones <code>if/else</code> en cascada:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a == 10 {
println!("la variable es 10");
}else if a == 4 {
println!("la variable es 4");
}else if a == 7 {
println!("la variable es 7");
}else {
println!("la variable no es ni 10, 4 ni 7");
}
}
</syntaxhighlight>

Si debes poner muchos <code>if/else</code> en cascada, lo mejor sería usar un [[match]].

==Usando en <code>let</code>==
Como el <code>if</code> es una expresión, se puede utilizar en el lado derecho de un <code>let</code>:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
let b = 7;
let c = if a>b {3} else {1};
println!("El valor es {}",c);
}
</syntaxhighlight>

Al ejecutar este programa, la salida sería "1".

=Lazos con <code>loop</code>=
El comando <code>loop</code> causa que un bloque de código se repita infinitas veces a menos de que explícitamente se le ordene que termine. Este código nunca terminará:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
loop {
println!("hola");
}
}
</syntaxhighlight>

La única forma de que deje de imprimir "hola" es usando Control-C.

==Saliendo de un lazo con <code>break</code>==
Con <code>break</code> la iteración termina y se sale del lazo.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a=0;
loop {
a=a+1;
println!("{}",a);
if a == 100 {break;}
}
}

</syntaxhighlight>

En este programa, al llegar la impresión a 100, terminará el programa.

==Devolviendo un valor==
<code>loop</code> ejecuta una expresión varias veces y se puede utilizar el <code>break</code> para devolver un valor, por ejemplo en una asignación:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
let b= loop {
a=a+1;
if a == 100 {
break a;
}
};
println!("{}",b);
}

</syntaxhighlight>

=Lazos condicionales con <code>while</code>=
Una forma de tener un lazo con un condicional es usar <code>while</code>. El programa anterior modificado sería:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
while a != 100 {
a=a+1;
}
println!("{}",a);
}
</syntaxhighlight>

=Lazos con <code>for</code>=
Hay varias formas de usar <code>for</code> para crear un lazo con un iterador.

==Iterador con <code>..</code>==
Con un iterador <code>a..b</code>, los valores van desde a inclusive hasta b (excluyendolo):

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..10 {
println!("{}",a);
}
}
</syntaxhighlight>
En este ejemplo, se imprimirán los valores desde 1 hasta 9. En este caso la variable <code>a</code> no necesita ser declarada explícitamente antes.

Si quisiéramos que el iterador fuera desde a hasta b inclusive, podemos poner un <code>=</code> antes de la segunda variable:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..=10 {
println!("{}",a);
}
}
</syntaxhighlight>

==Iteradores==
Hay varios iteradores: <code>into_iter</code>, <code>iter</code> y <code>iter_mut</code>.
===<code>iter</code>===
Toma cada elemento de la colección para cada iteración.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = [0,1,2];
for x in a.iter() {
println!("{}",x);
}
}
</syntaxhighlight>
En este ejemplo, se imprime los números 0,1,2.

===<code>iter_iter</code>===
Toma cada elemento de la colección y lo saca de la misma. Al final del for, la colección estará vacía.

===<code>iter_mut</code>===
Toma cada elemento, permitiendo su modificación.

=Match=
<code>Match</code> permite encontrar patrones, que se pueden usar como un <code>switch</code> en el lenguaje C:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a=5;

match a {
1 => println!("uno"),
2 | 3 | 5 | 7 => println!("es un número primo"),
_ => println! ("cualquier otro número"),
}
}
</syntaxhighlight>

Cada opción está separada por una coma, y se usa | para considerar varias opciones a la vez.

Control de flujo de ejecución

2021-03-06T01:57:39Z

Lochi:

Las dos estructuras más importantes para el control del flujo de ejecución son los lazos y la expresión <code>if</code>:

=Expresiones <code>if/else</code>=
Muy similar a otros lenguajes, se evalúa si es falso o verdadero una expresión. En este caso se evalúa si una variable es menor a 10 o no:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a < 10 {
println!("la expresión es verdadera");
}else {
println!("la exprexión es false");
}
}
</syntaxhighlight>

La expresión a evaluar debe ser de tipo <code>bool</code>, de lo contrario producirá un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error 308]]. Sobre comparaciones entre variables, se puede ver [[Comparaciones|acá]]

El <code>else</code> es opcional, y se pueden colocar varias expresiones <code>if/else</code> en cascada:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a == 10 {
println!("la variable es 10");
}else if a == 4 {
println!("la variable es 4");
}else if a == 7 {
println!("la variable es 7");
}else {
println!("la variable no es ni 10, 4 ni 7");
}
}
</syntaxhighlight>

Si debes poner muchos <code>if/else</code> en cascada, lo mejor sería usar un [[match]].

==Usando en <code>let</code>==
Como el <code>if</code> es una expresión, se puede utilizar en el lado derecho de un <code>let</code>:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
let b = 7;
let c = if a>b {3} else {1};
println!("El valor es {}",c);
}
</syntaxhighlight>

Al ejecutar este programa, la salida sería "1".

=Lazos con <code>loop</code>=
El comando <code>loop</code> causa que un bloque de código se repita infinitas veces a menos de que explícitamente se le ordene que termine. Este código nunca terminará:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
loop {
println!("hola");
}
}
</syntaxhighlight>

La única forma de que deje de imprimir "hola" es usando Control-C.

==Saliendo de un lazo con <code>break</code>==
Con <code>break</code> la iteración termina y se sale del lazo.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a=0;
loop {
a=a+1;
println!("{}",a);
if a == 100 {break;}
}
}

</syntaxhighlight>

En este programa, al llegar la impresión a 100, terminará el programa.

==Devolviendo un valor==
<code>loop</code> ejecuta una expresión varias veces y se puede utilizar el <code>break</code> para devolver un valor, por ejemplo en una asignación:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
let b= loop {
a=a+1;
if a == 100 {
break a;
}
};
println!("{}",b);
}

</syntaxhighlight>

=Lazos condicionales con <code>while</code>=
Una forma de tener un lazo con un condicional es usar <code>while</code>. El programa anterior modificado sería:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
while a != 100 {
a=a+1;
}
println!("{}",a);
}
</syntaxhighlight>

=Lazos con <code>for</code>=
Hay varias formas de usar <code>for</code> para crear un lazo con un iterador.

==Iterador con <code>..</code>==
Con un iterador <code>a..b</code>, los valores van desde a inclusive hasta b (excluyendolo):

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..10 {
println!("{}",a);
}
}
</syntaxhighlight>
En este ejemplo, se imprimirán los valores desde 1 hasta 9. En este caso la variable <code>a</code> no necesita ser declarada explícitamente antes.

Si quisiéramos que el iterador fuera desde a hasta b inclusive, podemos poner un <code>=</code> antes de la segunda variable:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..=10 {
println!("{}",a);
}
}
</syntaxhighlight>

==Iteradores==
Hay varios iteradores: <code>into_iter</code>, <code>iter</code> y <code>iter_mut</code>.
===<code>iter</code>===
Toma cada elemento de la colección para cada iteración.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = [0,1,2];
for x in a.iter() {
println!("{}",x);
}
}
</syntaxhighlight>
En este ejemplo, se imprime los números 0,1,2.

===<code>iter_iter</code>===
Toma cada elemento de la colección y lo saca de la misma. Al final del for, la colección estará vacía.

===<code>iter_mut</code>===
Toma cada elemento, permitiendo su modificación.

Control de flujo de ejecución

2021-03-03T03:34:51Z

Lochi: /* Iteradoradores */

Las dos estructuras más importantes para el control del flujo de ejecución son los lazos y la expresión <code>if</code>:

=Expresiones <code>if/else</code>=
Muy similar a otros lenguajes, se evalúa si es falso o verdadero una expresión. En este caso se evalúa si una variable es menor a 10 o no:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a < 10 {
println!("la expresión es verdadera");
}else {
println!("la exprexión es false");
}
}
</syntaxhighlight>

La expresión a evaluar debe ser de tipo <code>bool</code>, de lo contrario producirá un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error 308]]. Sobre comparaciones entre variables, se puede ver [[Comparaciones|acá]]

El <code>else</code> es opcional, y se pueden colocar varias expresiones <code>if/else</code> en cascada:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a == 10 {
println!("la variable es 10");
}else if a == 4 {
println!("la variable es 4");
}else if a == 7 {
println!("la variable es 7");
}else {
println!("la variable no es ni 10, 4 ni 7");
}
}
</syntaxhighlight>

Si debes poner muchos <code>if/else</code> en cascada, lo mejor sería usar un [[match]].

==Usando en <code>let</code>==
Como el <code>if</code> es una expresión, se puede utilizar en el lado derecho de un <code>let</code>:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
let b = 7;
let c = if a>b {3} else {1};
println!("El valor es {}",c);
}
</syntaxhighlight>

Al ejecutar este programa, la salida sería "1".

=Lazos con <code>loop</code>=
El comando <code>loop</code> causa que un bloque de código se repita infinitas veces a menos de que explícitamente se le ordene que termine. Este código nunca terminará:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
loop {
println!("hola");
}
}
</syntaxhighlight>

La única forma de que deje de imprimir "hola" es usando Control-C.

==Saliendo de un lazo con <code>break</code>==
Con <code>break</code> la iteración termina y se sale del lazo.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a=0;
loop {
a=a+1;
println!("{}",a);
if a == 100 {break;}
}
}

</syntaxhighlight>

En este programa, al llegar la impresión a 100, terminará el programa.

==Devolviendo un valor==
<code>loop</code> ejecuta una expresión varias veces y se puede utilizar el <code>break</code> para devolver un valor, por ejemplo en una asignación:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
let b= loop {
a=a+1;
if a == 100 {
break a;
}
};
println!("{}",b);
}

</syntaxhighlight>

=Lazos condicionales con <code>while</code>=
Una forma de tener un lazo con un condicional es usar <code>while</code>. El programa anterior modificado sería:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
while a != 100 {
a=a+1;
}
println!("{}",a);
}
</syntaxhighlight>

=Lazos con <code>for</code>=
Hay varias formas de usar <code>for</code> para crear un lazo con un iterador.

==Iterador con <code>..</code>==
Con un iterador <code>a..b</code>, los valores van desde a inclusive hasta b (excluyendolo):

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..10 {
println!("{}",a);
}
}
</syntaxhighlight>
En este ejemplo, se imprimirán los valores desde 1 hasta 9. En este caso la variable <code>a</code> no necesita ser declarada explícitamente antes.

Si quisiéramos que el iterador fuera desde a hasta b inclusive, podemos poner un <code>=</code> antes de la segunda variable:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..=10 {
println!("{}",a);
}
}
</syntaxhighlight>

==Iteradores==
Hay varios iteradores: <code>into_iter</code>, <code>iter</code> y <code>iter_mut</code>.
===<code>iter</code>===
Toma cada elemento de la colección para cada iteración.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = [0,1,2];
for x in a.iter() {
println!("{}",x);
}
}
</syntaxhighlight>
En este ejemplo, se impime los números 0,1,2.

Control de flujo de ejecución

2021-03-03T03:26:53Z

Lochi: /* Lazos con for */

Las dos estructuras más importantes para el control del flujo de ejecución son los lazos y la expresión <code>if</code>:

=Expresiones <code>if/else</code>=
Muy similar a otros lenguajes, se evalúa si es falso o verdadero una expresión. En este caso se evalúa si una variable es menor a 10 o no:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a < 10 {
println!("la expresión es verdadera");
}else {
println!("la exprexión es false");
}
}
</syntaxhighlight>

La expresión a evaluar debe ser de tipo <code>bool</code>, de lo contrario producirá un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error 308]]. Sobre comparaciones entre variables, se puede ver [[Comparaciones|acá]]

El <code>else</code> es opcional, y se pueden colocar varias expresiones <code>if/else</code> en cascada:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a == 10 {
println!("la variable es 10");
}else if a == 4 {
println!("la variable es 4");
}else if a == 7 {
println!("la variable es 7");
}else {
println!("la variable no es ni 10, 4 ni 7");
}
}
</syntaxhighlight>

Si debes poner muchos <code>if/else</code> en cascada, lo mejor sería usar un [[match]].

==Usando en <code>let</code>==
Como el <code>if</code> es una expresión, se puede utilizar en el lado derecho de un <code>let</code>:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
let b = 7;
let c = if a>b {3} else {1};
println!("El valor es {}",c);
}
</syntaxhighlight>

Al ejecutar este programa, la salida sería "1".

=Lazos con <code>loop</code>=
El comando <code>loop</code> causa que un bloque de código se repita infinitas veces a menos de que explícitamente se le ordene que termine. Este código nunca terminará:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
loop {
println!("hola");
}
}
</syntaxhighlight>

La única forma de que deje de imprimir "hola" es usando Control-C.

==Saliendo de un lazo con <code>break</code>==
Con <code>break</code> la iteración termina y se sale del lazo.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a=0;
loop {
a=a+1;
println!("{}",a);
if a == 100 {break;}
}
}

</syntaxhighlight>

En este programa, al llegar la impresión a 100, terminará el programa.

==Devolviendo un valor==
<code>loop</code> ejecuta una expresión varias veces y se puede utilizar el <code>break</code> para devolver un valor, por ejemplo en una asignación:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
let b= loop {
a=a+1;
if a == 100 {
break a;
}
};
println!("{}",b);
}

</syntaxhighlight>

=Lazos condicionales con <code>while</code>=
Una forma de tener un lazo con un condicional es usar <code>while</code>. El programa anterior modificado sería:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
while a != 100 {
a=a+1;
}
println!("{}",a);
}
</syntaxhighlight>

=Lazos con <code>for</code>=
Hay varias formas de usar <code>for</code> para crear un lazo con un iterador.

==Iterador con <code>..</code>==
Con un iterador <code>a..b</code>, los valores van desde a inclusive hasta b (excluyendolo):

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..10 {
println!("{}",a);
}
}
</syntaxhighlight>
En este ejemplo, se imprimirán los valores desde 1 hasta 9. En este caso la variable <code>a</code> no necesita ser declarada explícitamente antes.

Si quisiéramos que el iterador fuera desde a hasta b inclusive, podemos poner un <code>=</code> antes de la segunda variable:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..=10 {
println!("{}",a);
}
}
</syntaxhighlight>

==Iteradoradores==
Hay varios iteradores: <code>into_iter</code>, <code>iter</code> y <code>iter_mut</code>.
===<code>iter</code>===
Toma cada elemento de la colección para cada iteración.

Control de flujo de ejecución

2021-02-21T01:41:37Z

Lochi:

Las dos estructuras más importantes para el control del flujo de ejecución son los lazos y la expresión <code>if</code>:

=Expresiones <code>if/else</code>=
Muy similar a otros lenguajes, se evalúa si es falso o verdadero una expresión. En este caso se evalúa si una variable es menor a 10 o no:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a < 10 {
println!("la expresión es verdadera");
}else {
println!("la exprexión es false");
}
}
</syntaxhighlight>

La expresión a evaluar debe ser de tipo <code>bool</code>, de lo contrario producirá un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error 308]]. Sobre comparaciones entre variables, se puede ver [[Comparaciones|acá]]

El <code>else</code> es opcional, y se pueden colocar varias expresiones <code>if/else</code> en cascada:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a == 10 {
println!("la variable es 10");
}else if a == 4 {
println!("la variable es 4");
}else if a == 7 {
println!("la variable es 7");
}else {
println!("la variable no es ni 10, 4 ni 7");
}
}
</syntaxhighlight>

Si debes poner muchos <code>if/else</code> en cascada, lo mejor sería usar un [[match]].

==Usando en <code>let</code>==
Como el <code>if</code> es una expresión, se puede utilizar en el lado derecho de un <code>let</code>:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
let b = 7;
let c = if a>b {3} else {1};
println!("El valor es {}",c);
}
</syntaxhighlight>

Al ejecutar este programa, la salida sería "1".

=Lazos con <code>loop</code>=
El comando <code>loop</code> causa que un bloque de código se repita infinitas veces a menos de que explícitamente se le ordene que termine. Este código nunca terminará:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
loop {
println!("hola");
}
}
</syntaxhighlight>

La única forma de que deje de imprimir "hola" es usando Control-C.

==Saliendo de un lazo con <code>break</code>==
Con <code>break</code> la iteración termina y se sale del lazo.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a=0;
loop {
a=a+1;
println!("{}",a);
if a == 100 {break;}
}
}

</syntaxhighlight>

En este programa, al llegar la impresión a 100, terminará el programa.

==Devolviendo un valor==
<code>loop</code> ejecuta una expresión varias veces y se puede utilizar el <code>break</code> para devolver un valor, por ejemplo en una asignación:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
let b= loop {
a=a+1;
if a == 100 {
break a;
}
};
println!("{}",b);
}

</syntaxhighlight>

=Lazos condicionales con <code>while</code>=
Una forma de tener un lazo con un condicional es usar <code>while</code>. El programa anterior modificado sería:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let mut a =0;
while a != 100 {
a=a+1;
}
println!("{}",a);
}
</syntaxhighlight>

=Lazos con <code>for</code>=
Hay varias formas de usar <code>for</code> para crear un lazo con un iterador.

==Iterador con <code>..</code>==
Con un iterador <code>a..b</code>, los valores van desde a inclusive hasta b (excluyendolo):

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..10 {
println!("{}",a);
}
}
</syntaxhighlight>
En este ejemplo, se imprimirán los valores desde 1 hasta 9. En este caso la variable <code>a</code> no necesita ser declarada explícitamente antes.

Si quisiéramos que el iterador fuera desde a hasta b inclusive, podemos poner un <code>=</code> antes de la segunda variable:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
for a in 1..=10 {
println!("{}",a);
}
}
</syntaxhighlight>

Control de flujo de ejecución

2021-02-18T03:07:53Z

Lochi: /* Expresiones if/else */

Control de flujo de ejecución

2021-02-18T03:06:52Z

Lochi: /* Lazos condicionales con while */

Control de flujo de ejecución

2021-02-18T02:57:39Z

Lochi:

Control de flujo de ejecución

2021-02-18T02:56:49Z

Lochi: /* Saliendo de un lazo con break */

Control de flujo de ejecución

2021-02-18T02:46:13Z

Lochi: /* Lazos */

Control de flujo de ejecución

2021-02-16T03:16:30Z

Lochi:

Control de flujo de ejecución

2021-02-16T03:12:20Z

Lochi:

Control de flujo de ejecución

2021-02-15T03:26:36Z

Lochi:

Las dos estructuras más importantes para el control del flujo de ejecución son los lazos y la expresión <code>if</code>:

=Expresiones <code>if</code>=
Muy similar a otros lenguajes, se evalúa si es falso o verdadero una expresión. En este caso se evalúa si una variable es menor a 10 o no:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a < 10 {
println!("la expresión es verdadera");
}else {
println!("la exprexión es false");
}
}
</syntaxhighlight>

La expresión a evaluar debe ser de tipo <code>bool</code>, de lo contrario producirá un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error 308]].

El <code>else</code> es opcional, y se pueden colocar varias expresiones <code>if/else</code> en cascada:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main() {
let a = 5;
if a == 10 {
println!("la variable es 10");
}else if a == 4 {
println!("la variable es 4");
}else if a == 7 {
println!("la variable es 7");
}else {
println!("la variable no es ni 10, 4 ni 7");
}
}
</syntaxhighlight>

Si debes poner muchos <code>if/else</code> en cascada, lo mejor sería usar un [[match]].

Control de flujo de ejecución

2021-02-15T03:20:49Z

Lochi: Created page with "Las dos estructuras más importantes para el control del flujo de ejecución son los lazos y la expresión <code>if</code>: =Expresiones <code>if</code>= Muy similar a otros..."

Main Page

2021-02-12T03:40:00Z

Lochi:

Category:Advertencias

2021-02-12T03:38:53Z

Lochi: /* Advertencias Comunes */

=Advertencias Comunes=

* <code>warning: unused variable </code>
Esto ocurre cuando se declara una variable pero no se utiliza del todo. Puede ser porque:

#En realidad es una variable sin utilizar.
#Se escribió mal el identificador de la variable. Esto también produciría un error [[Errores_de_compilación#Error_en_identificadores_de_variables|E0425]] pues se estaría usando la variable que no fue declarada.

Category:Advertencias

2021-02-12T03:37:06Z

Lochi:

=Advertencias Comunes=

* <code>warning: unused variable </code>
Esto ocurre cuando se declara una variable pero no se utiliza del todo. Puede ser porque:
** En realidad es una variable sin utilizar
** Se escribió mal el identificador de la variable. Esto también produciría un error [[Errores_de_compilación#Error_en_identificadores_de_variables|E0425]] pues se estaría usando la variable que no fue declarada.

Category:Advertencias

2021-02-12T03:36:24Z

Lochi:

=Advertencias Comunes=

* <code>warning: unused variable </code>
Esto ocurre cuando se declara una variable pero no se utiliza del todo. Puede ser porque:
** En realidad es una variable sin utilizar
** Se escribió mal el identificador de la variable. Esto también produciría un error [[:Category:Errores#Error_en_identificadores_de_variables|E0425]] pues se estaría usando la variable que no fue declarada.

Category:Advertencias

2021-02-12T03:35:44Z

Lochi:

=Advertencias Comunes=

* <code>warning: unused variable </code>
Esto ocurre cuando se declara una variable pero no se utiliza del todo. Puede ser porque:
** En realidad es una variable sin utilizar
** Se escribió mal el identificador de la variable. Esto también produciría un error [[:Category:Errores]] pues se estaría usando la variable que no fue declarada.

Category:Advertencias

2021-02-12T03:35:31Z

Lochi: /* Advertencias Comunes */

=Advertencias Comunes=

* <code>warning: unused variable </code>
Esto ocurre cuando se declara una variable pero no se utiliza del todo. Puede ser porque:
** En realidad es una variable sin utilizar
** Se escribió mal el identificador de la variable. Esto también produciría un error [[Category:Errores]] pues se estaría usando la variable que no fue declarada.

Category:Advertencias

2021-02-12T03:34:58Z

Lochi: /* Advertencias Comunes */

=Advertencias Comunes=

* <code>warning: unused variable </code>
Esto ocurre cuando se declara una variable pero no se utiliza del todo. Puede ser porque:
** En realidad es una variable sin utilizar
** Se escribió mal el identificador de la variable. Esto también produciría un error [[Category:Errores|E0425]] pues se estaría usando la variable que no fue declarada.

Category:Advertencias

2021-02-12T03:34:11Z

Lochi: /* Advertencias Comunes */

=Advertencias Comunes=

* <code>warning: unused variable </code>
Esto ocurre cuando se declara una variable pero no se utiliza del todo. Puede ser porque:
** En realidad es una variable sin utilizar
** Se escribió mal el identificador de la variable. Esto también produciría un error [[Category:Errores#Errores _en_identificadores_de_variables|E0425]] pues se estaría usando la variable que no fue declarada.

Category:Advertencias

2021-02-12T03:30:49Z

Lochi:

=Advertencias Comunes=

* <code>warning: unused variable </code>
Esto ocurre cuando se declara una variable pero no se utiliza del todo. Puede ser porque:
** En realidad es una variable sin utilizar
** Se escribió mal el identificador de la variable. Esto también produciría un error E0425 pues se estaría usando la variable que no fue declarada.

Category:Advertencias

2021-02-12T03:27:37Z

Lochi: Created page with "=Advertencias Comunes="

=Advertencias Comunes=

Main Page

2021-02-12T03:27:15Z

Lochi:

<strong>Tutorial de Rust</strong>

=Introducción=
# [[¿Qué es Rust?]]
# [[Instalación]]
## [[Herramientas de edición de código]]
### [[Visual Studio Code]]
# [[Mi primer programa: Hola mundo]]
# [[Cargo]]

=Conceptos importantes en Rust=
#[[Comentarios]]
#[[Variables]]
#[[Tipos de datos]]
#[[Funciones]]
#[[Control de flujo de ejecución]]

=Errores=
* [[:Category:Errores|Errores comunes]]
** [[Errores de instalación]]
** [[Errores de compilación]]
** [[Errores de ejecución]]

=Advertencias=
* [[:Category:Advertencias|Advertencias comunes]]

Consult the [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents User's Guide] for information on using the wiki software.

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]

Comentarios

2021-02-12T03:23:41Z

Lochi:

=Por línea=
Todo caracter luego de <code>//</code> se considera un comentario y se ignora.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a=3; //esto se ignora
//esto también
}
</syntaxhighlight>

=Varias líneas=
Si se desea agregar varias líneas de comentarios (o hacer que el compilador ignore varias líneas de código), se puede usar <code>/*</code> y <code>*/</code>. Todo lo que se encuentre entre ambas es ignorado:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a=3; /*esto se ignora*/
/*
esto también es ignorado
let b=4; incluyendo esta línea

*/
}
</syntaxhighlight>

Comentarios

2021-02-12T03:20:55Z

Lochi:

Main Page

2021-02-08T03:09:01Z

Lochi: /* Conceptos importantes en Rust */

<strong>Tutorial de Rust</strong>

=Introducción=
# [[¿Qué es Rust?]]
# [[Instalación]]
## [[Herramientas de edición de código]]
### [[Visual Studio Code]]
# [[Mi primer programa: Hola mundo]]
# [[Cargo]]

=Conceptos importantes en Rust=
#[[Comentarios]]
#[[Variables]]
#[[Tipos de datos]]
#[[Funciones]]
#[[Control de flujo de ejecución]]

=Errores=
* [[:Category:Errores|Errores comunes]]
** [[Errores de instalación]]
** [[Errores de compilación]]
** [[Errores de ejecución]]

Consult the [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents User's Guide] for information on using the wiki software.

== Getting started ==
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Configuration settings list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Localise MediaWiki for your language]
* [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Learn how to combat spam on your wiki]

Funciones

2021-02-08T03:08:14Z

Lochi: /* Retorno de valores */

===main===
Main es la función principal de un programa de Rust: es su punto de inicio o entrada.

Rust utiliza la convención [[snake case]] para nombrar identificadores de funciones y variables.

Las definiciones de Rust empiezan con <code>fn</code> y tienen un conjunto de paréntesis y llaves para indicar el inicio y final del cuerpo de la función.

A diferencia de otros lenguajes, Rust solo necesita que una función esté definida en algún lugar del código fuente, no necesita estar antes o después del lugar donde se le invoca.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn una_funcion(){
println!("Otro hola!");
}
</syntaxhighlight>

=Parámetros=
Los parámetros o argumentos son las variables especiales que son parte de la función.

Una función, al invocar a otra, puede pasarle valores como en este ejemplo:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
una_funcion(10);
}

fn una_funcion(a: i32){
println!("El valor obtenido es {}",a);
}
</syntaxhighlight>

Se puede agregar más funciones, agregando identificadores de variables y tipos, separados por comas.

=Retorno de valores=
Las funciones puede devolver valores, declarando el tipo y usando una flecha <code>-></code>. El valor que se devolverá es la última expressión en el cuerpo de la función. Se puede usar <code>return</code> si se desea devolver antes del final.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn cinco() -> i32 {
5
}

fn main() {
let a = cinco();
println!("El valor de a es: {}", a);
}
</syntaxhighlight>

Si se desea pasar parámetros además de recibir algo devuelta de la función, se le agregarían las variables entre los paréntesis como es usual, antes de la flecha.

Acá hay que tener cuidado si se va a devolver un valor al final de una función: si se pone un punto y coma al final del 5 (en la función arriba), se producirá un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error 308]], pues se estará convirtiendo una expresión (<code>5</code>) en una declaración (<code>5;</code>);

Funciones

2021-02-08T03:05:53Z

Lochi: /* Retorno de valores */

Errores de compilación

2021-02-08T03:04:01Z

Lochi: /* Errores en el uso de las variables */

[[Category:Errores]]

=Errores en identificadores de variables=
<code>error[E0425]: cannot find value `x` in this scope</code>

Significa que estás usando una variable que no está definida. Causas probables:
#Escribiste mal el identificador de la variable (x en este caso).
#Escribiste mal el identificador en la definición de la variable original.

=Errores en caracteres=
<code>error[E0658]: non-ascii idents are not fully supported</code>

Significa que hay un caracter no válido en algún identificador:
#En tu código hay alguna tilde o ñ.

=Errores en el uso de las variables=
<code>error[E0282]: type annotations needed</code>

Significa que estás definiendo el compilador requiere más información de qué tipo queremos usar.
----
<code>error[E0308]: mismatched types</code>

#Significa que en la asignación de un valor a una variable, estás usando dos tipos diferentes de datos.
#Se esperaba una expresión en vez de una declaración, como cuando se pone un punto y coma (;) al final de una expresión que iba a ser devuelta por una función.
----
<code>error[E0384]: cannot assign twice to immutable variable</code>

Significa que trataste de reasignar un valor a una variable que es inmutable:
#Se te olvidó definir una variable como mutable <code>mut</code>.
#Hay dos variables con los nombres parecidos, uno mutable y otro inmutable, y te referistes a la variable equivocada.
----
----

Funciones

2021-02-08T03:01:44Z

Lochi:

Funciones

2021-02-08T02:50:27Z

Lochi: /* Parámetros */

Tipos de datos

2021-02-06T04:10:45Z

Lochi: /* Arreglos */

Todo valor en Rust es de un tipo específico. Rust necesita saber ese tipo al momento de compilar el programa, y muchas veces puede inferir el tipo. En otras ocasiones debemos indicarlo explícitamente, y si no lo hacemos produciremos un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error]] de compilación.

Hay dos categorías:
==Escalares==
Un tipo escalar representa un valor único, y existen cuatro tipos escalares: enteros, punto flotantes, booleanos, y caracteres.
===Enteros===
Un entero es un número sin una parte fraccional. Pueden tener signo o no, y ser de 8 a 128 bits. Si tiene signos, el tipo empieza con i y si no tiene signo empieza con u.

====Tamaños y signo====
El tipo empieza con i y u, y continúa con el tamaño en bits, desde 8 hasta 128 bits: i8, u8, i16, u16, y así sucesivamente hasta i128 y u128.

Se usa [[complemento a dos]] para representar los números negativos.

===Punto flotante===
Hay dos tipos primitivos de [[punto flotante]]: f32 (32 bits, precisión simple) y f64 (64 bits, doble precisión). Si no se especifica el tipo, se asume por defecto que es f64. Se usa el estándar [[IEEE-754]] de punto flotante.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let pi = 3.14; // se asume tipo f64
let as: f32 = 3.14; // esta variable es de tipo f32
}
</syntaxhighlight>

===Booleanos===
Una variable booleana puede ser o <code>true</code> o <code>false</code>, y ocupa un byte de almacenamiento.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let bandera = true;
let otra_bandera: bool = false;
}
</syntaxhighlight>
===Caracteres===
Para almacenar letras, se puede usar <code>char</code>, y se define con comilla única (no doble comilla o comillas que son para las cadenas de caracteres). Los caracteres ocupan 4 bytes de almacenamiento.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let p = 'p';
}
</syntaxhighlight>

==Compuestos==
Los tipos compuestos agrupan varios valores en un sólo tipo. Existen dos: tuples y arreglos.
===Tuples===
Agrupan diferentes tipos en un sólo tipo compuesto. Tienen un tamaño definido: no se pueden modificar de tamaño una vez creados.

Se crean usando paréntesis y separando la lista de valores con comas. Cada posición es un tipo, y no necesitan ser iguales.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let tuple: (i32, char) = (12,'d');
println!("El valor es {}",tuple.1);
}
</syntaxhighlight>

La salida del programa sería <code>d</code>. (<code>tuple.0</code> se refiere al i32, y <code>tuple.1</code> al caracter).

Otra forma es asignar parte de ese tuple a una variable, de la siguiente manera:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let tuple: (i32, char) = (12,'d');
let (a,b)=tuple;
println!("El valor es {}",b);
}
</syntaxhighlight>

===Arreglos===
En los arreglos, todos los valores deben ser del mismo tipo, y deben tener un tamaño fijo. En este ejemplo, el arreglo a tiene 3 valores:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a = [0,1,2];
}
</syntaxhighlight>

Los arreglos se definen estáticamente, por lo que están en el [[stack]] y no en el [[heap]]. Si se desea algo dinámico, se puede usar un <code>vector</code>.

Si se desea explicitar el tipo y el número de elemento se haría:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a: [i32;3] = [0,1,2];
}
</syntaxhighlight>

Si quieres inicializar todo un arreglo con un mismo valor puedes hacer esto:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a = [5;10]; //esto inicializa con 10 elementos con un valor de 5.
}
</syntaxhighlight>

Los elementos de un arreglo se accesan de la misma forma que en otros lenguajes: <code>a[0]</code> accesa su primer elemento, y así sucesivamente.

====Arreglos bidimensionales====
Se pueden definir explícitamente:

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let mut state = [[0,0],[0,1]];
}
</syntaxhighlight>

También se pueden definir de esta forma, un arreglo de 8 por 16:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let mut arreglo: [[i32; 16]; 8];
}
</syntaxhighlight>

Tipos de datos

2021-02-05T02:32:41Z

Lochi: /* Arreglos */

Todo valor en Rust es de un tipo específico. Rust necesita saber ese tipo al momento de compilar el programa, y muchas veces puede inferir el tipo. En otras ocasiones debemos indicarlo explícitamente, y si no lo hacemos produciremos un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error]] de compilación.

Hay dos categorías:
==Escalares==
Un tipo escalar representa un valor único, y existen cuatro tipos escalares: enteros, punto flotantes, booleanos, y caracteres.
===Enteros===
Un entero es un número sin una parte fraccional. Pueden tener signo o no, y ser de 8 a 128 bits. Si tiene signos, el tipo empieza con i y si no tiene signo empieza con u.

====Tamaños y signo====
El tipo empieza con i y u, y continúa con el tamaño en bits, desde 8 hasta 128 bits: i8, u8, i16, u16, y así sucesivamente hasta i128 y u128.

Se usa [[complemento a dos]] para representar los números negativos.

===Punto flotante===
Hay dos tipos primitivos de [[punto flotante]]: f32 (32 bits, precisión simple) y f64 (64 bits, doble precisión). Si no se especifica el tipo, se asume por defecto que es f64. Se usa el estándar [[IEEE-754]] de punto flotante.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let pi = 3.14; // se asume tipo f64
let as: f32 = 3.14; // esta variable es de tipo f32
}
</syntaxhighlight>

===Booleanos===
Una variable booleana puede ser o <code>true</code> o <code>false</code>, y ocupa un byte de almacenamiento.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let bandera = true;
let otra_bandera: bool = false;
}
</syntaxhighlight>
===Caracteres===
Para almacenar letras, se puede usar <code>char</code>, y se define con comilla única (no doble comilla o comillas que son para las cadenas de caracteres). Los caracteres ocupan 4 bytes de almacenamiento.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let p = 'p';
}
</syntaxhighlight>

==Compuestos==
Los tipos compuestos agrupan varios valores en un sólo tipo. Existen dos: tuples y arreglos.
===Tuples===
Agrupan diferentes tipos en un sólo tipo compuesto. Tienen un tamaño definido: no se pueden modificar de tamaño una vez creados.

Se crean usando paréntesis y separando la lista de valores con comas. Cada posición es un tipo, y no necesitan ser iguales.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let tuple: (i32, char) = (12,'d');
println!("El valor es {}",tuple.1);
}
</syntaxhighlight>

La salida del programa sería <code>d</code>. (<code>tuple.0</code> se refiere al i32, y <code>tuple.1</code> al caracter).

Otra forma es asignar parte de ese tuple a una variable, de la siguiente manera:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let tuple: (i32, char) = (12,'d');
let (a,b)=tuple;
println!("El valor es {}",b);
}
</syntaxhighlight>

===Arreglos===
En los arreglos, todos los valores deben ser del mismo tipo, y deben tener un tamaño fijo. En este ejemplo, el arreglo a tiene 3 valores:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a = [0,1,2];
}
</syntaxhighlight>

Los arreglos se definen estáticamente, por lo que están en el [[stack]] y no en el [[heap]]. Si se desea algo dinámico, se puede usar un <code>vector</code>.

Si se desea explicitar el tipo y el número de elemento se haría:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a: [i32;3] = [0,1,2];
}
</syntaxhighlight>

Si quieres inicializar todo un arreglo con un mismo valor puedes hacer esto:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a = [5;10]; //esto inicializa con 10 elementos con un valor de 5.
}
</syntaxhighlight>

Los elementos de un arreglo se accesan de la misma forma que en otros lenguajes: <code>a[0]</code> accesa su primer elemento, y así sucesivamente.

Tipos de datos

2021-02-05T01:57:21Z

Lochi: /* Compuestos */

Todo valor en Rust es de un tipo específico. Rust necesita saber ese tipo al momento de compilar el programa, y muchas veces puede inferir el tipo. En otras ocasiones debemos indicarlo explícitamente, y si no lo hacemos produciremos un [[Errores_de_compilación#Errores_en_el_uso_de_las_variables|error]] de compilación.

Hay dos categorías:
==Escalares==
Un tipo escalar representa un valor único, y existen cuatro tipos escalares: enteros, punto flotantes, booleanos, y caracteres.
===Enteros===
Un entero es un número sin una parte fraccional. Pueden tener signo o no, y ser de 8 a 128 bits. Si tiene signos, el tipo empieza con i y si no tiene signo empieza con u.

====Tamaños y signo====
El tipo empieza con i y u, y continúa con el tamaño en bits, desde 8 hasta 128 bits: i8, u8, i16, u16, y así sucesivamente hasta i128 y u128.

Se usa [[complemento a dos]] para representar los números negativos.

===Punto flotante===
Hay dos tipos primitivos de [[punto flotante]]: f32 (32 bits, precisión simple) y f64 (64 bits, doble precisión). Si no se especifica el tipo, se asume por defecto que es f64. Se usa el estándar [[IEEE-754]] de punto flotante.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let pi = 3.14; // se asume tipo f64
let as: f32 = 3.14; // esta variable es de tipo f32
}
</syntaxhighlight>

===Booleanos===
Una variable booleana puede ser o <code>true</code> o <code>false</code>, y ocupa un byte de almacenamiento.
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let bandera = true;
let otra_bandera: bool = false;
}
</syntaxhighlight>
===Caracteres===
Para almacenar letras, se puede usar <code>char</code>, y se define con comilla única (no doble comilla o comillas que son para las cadenas de caracteres). Los caracteres ocupan 4 bytes de almacenamiento.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let p = 'p';
}
</syntaxhighlight>

==Compuestos==
Los tipos compuestos agrupan varios valores en un sólo tipo. Existen dos: tuples y arreglos.
===Tuples===
Agrupan diferentes tipos en un sólo tipo compuesto. Tienen un tamaño definido: no se pueden modificar de tamaño una vez creados.

Se crean usando paréntesis y separando la lista de valores con comas. Cada posición es un tipo, y no necesitan ser iguales.

<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let tuple: (i32, char) = (12,'d');
println!("El valor es {}",tuple.1);
}
</syntaxhighlight>

La salida del programa sería <code>d</code>. (<code>tuple.0</code> se refiere al i32, y <code>tuple.1</code> al caracter).

Otra forma es asignar parte de ese tuple a una variable, de la siguiente manera:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let tuple: (i32, char) = (12,'d');
let (a,b)=tuple;
println!("El valor es {}",b);
}
</syntaxhighlight>

===Arreglos===
En los arreglos, todos los valores deben ser del mismo tipo, y deben tener un tamaño fijo. En este ejemplo, el arreglo a tiene 3 valores:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a = [0,1,2];
}
</syntaxhighlight>

Los arreglos se definen estáticamente, por lo que están en el [[stack]] y no en el [[heap]]. Si se desea algo dinámico, se puede usar un <code>vector</code>.

Si se desea explicitar el tipo y el número de elemento se haría:
<syntaxhighlight lang="rust" line='line' highlight="1">
fn main(){
let a: [i32;3] = [0,1,2];
}
</syntaxhighlight>

Tipos de datos

2021-02-04T03:29:25Z

Lochi: /* Compuestos */

Tipos de datos

2021-02-04T03:27:38Z

Lochi: /* Compuestos */

Tipos de datos

2021-02-04T03:21:16Z

Lochi:

Tipos de datos

2021-02-03T03:16:31Z

Lochi:

Tipos de datos

2021-02-03T03:13:20Z

Lochi:

Tipos de datos

2021-02-03T03:07:40Z

Lochi:

Tipos de datos

2021-01-28T03:47:24Z

Lochi: