Los operadores en general se utilizan para realizar operaciones sobre valores y variables. Estos son símbolos estándar utilizados con el propósito de operaciones lógicas y aritméticas. En este artículo, veremos diferentes tipos de operadores de Rust. Los operadores le dicen al compilador o intérprete que realice una operación matemática, lógica o relacional específica.
Los siguientes son los tipos de operadores en Rust:
- Operadores aritméticos
- Operadores de comparación
- Operadores logicos
- Operadores bit a bit
- Operadores de asignación compuesta
Operadores aritméticos
Los operadores aritméticos se utilizan para realizar operaciones matemáticas como suma, resta, multiplicación y división.
Supongamos que A=40 y B=20
S.No | Operador | Explicación | Ejemplo |
---|---|---|---|
1 | + (suma) | Devuelve la suma de dos operandos | A+B=60 |
2 | -(Sustracción) | Devuelve la diferencia de los valores (restar el operando derecho del izquierdo) | AB=20 |
3 | *(Multiplicación) | Devuelve el producto de los valores. | A*B=800 |
4 | /(División) | Divide el operando izquierdo por el derecho y devuelve el cociente | A/B=2 |
5 | %(Módulo) | Divide el operando izquierdo por el derecho y devuelve el resto | A%B=0 |
Ejemplo:
Rust
fn main() { let x = 20 ; let y = 4; let mut result:i32; // addition of two operands result = x + y; println!("Sum: {} ",result); // the difference of the values result = x - y; println!("Difference: {} ",result) ; // the product of the values result = x*y ; println!("Product: {} ",result) ; // Divide left operand by right one // and returns the quotient result = x/y ; println!("Quotient: {} ",result); // Divide left operand by right one // and returns the remainder result = x%y ; println!("Remainder: {} ",result); }
Producción:
Sum: 24 Difference: 16 Product: 80 Quotient: 5 Remainder: 0
Operadores de comparación
Los operadores de comparación son los operadores que comparan valores y devuelven verdadero o falso según las condiciones.
Supongamos que A=40 y B=20
S.No | Operador | Explicación | Ejemplo |
---|---|---|---|
1 | > | Mas grande que | (A>B) es verdadero |
2 | < | Menos que | (A<B) es falso |
3 | == | Igual a | (A==B) es falso |
4 | != | No igual a | (A!=B) es Verdadero |
5 | >= | Mayor que e igual a | (A>=B) es Verdadero |
6 | <= | menor que e igual a | (A<=B) es falso |
Ejemplo:
Rust
fn main() { let a = 4; let b = 5; // performing a series of comparisons // using comparision operators // is equal to let c = a == b; // is not equal to let d = a != b; // is less than let e = a < b; // is greater than let f = a > b; // is less than or equa to let g = a <= a; // is greater than or equal to let h = a >= a; println!("a: {}, b: {}, c: {0} == {1} is {}, d: {0} != {1} is {}, e: {0}<{1} is {}, f: {0}>{1} is {}, g: {0}<={0} is {}, h: {0}>={0} is {}", a, b, c, d, e, f, g, h); }
Producción:
a: 4, b: 5, c: 4 == 5 is false, d: 4 != 5 is true, e: 4<5 is true, f: 4>5 is false, g: 4<=4 is true, h: 4>=4 is true
Operadores logicos
Los operadores lógicos se utilizan para combinar dos o más condiciones. Los operadores lógicos también devuelven un valor booleano.
Supongamos que A=1 y B=0
S.No | Operador | Explicación | Ejemplo |
---|---|---|---|
1 | && | El operador devuelve verdadero solo si todas las expresiones especificadas devuelven verdadero | (A&&B) es falso |
2 | || | El operador devuelve verdadero si al menos una de las expresiones especificadas devuelve verdadero | (A||B) es verdadero |
3 | ! |
El operador devuelve el inverso del resultado de la expresión. Por ejemplo: !(>5) devuelve falso !(A >10 ) es verdadero Operadores bit a bit |
!(A||B) es falso |
Ejemplo:
Rust
fn main() { let a = false; let b = true; let c = !a; let d = a && b; let e = a || b; println!(" a: {}, b: {}, c: !{0} is {}, d: {0} && {1} is {}, e: {0} || {1} is {}", a, b, c, d, e); }
Producción:
a: false, b: true, c: !false is true, d: false && true is false, e: false || true is true
Operadores bit a bit
Bitwise es un nivel de operaciones que implica trabajar con bits individuales, que son las unidades de datos más pequeñas en una computadora. Cada bit tiene un único valor binario: 0 o 1.
Supongamos que A=2 y B=3
S.No | Operador | Explicación | Ejemplo |
---|---|---|---|
1 | & (Y bit a bit) | Realiza una operación booleana AND en cada bit de sus argumentos enteros. | (A&B) es 2 |
2 | | (BitWise O) | Realiza una operación OR booleana en cada bit de sus argumentos enteros. | (A|B) es 3 |
3 | ^ (XOR bit a bit) |
Realiza una operación OR exclusiva booleana en cada bit de sus argumentos enteros. OR exclusivo significa que el operando uno es verdadero o el operando dos es verdadero, pero no ambos. |
(A^B) es 1 |
4 | ! (Bitbit no) | Es un operador unario y opera invirtiendo todos los bits del operando. | !A es 2 |
5 | << (Desplazamiento a la izquierda) |
Mueve todos los bits de su primer operando a la izquierda el número de lugares especificado en el segundo operando. Los nuevos bits se rellenan con ceros. Desplazar un valor dejado una posición equivale a multiplicarlo por 2, desplazar dos posiciones equivale a multiplicar por 4, y así sucesivamente. |
(B<<1) es 6 |
6 | >> (Desplazamiento a la derecha) | Operador binario de desplazamiento a la derecha. El valor del operando izquierdo se mueve hacia la derecha el número de bits especificado por el operando derecho. | (B >> 1) es 1 |
7 | >>> (desplazamiento a la derecha con cero) | Este operador es como el operador >>, excepto que los bits desplazados a la izquierda siempre son cero. | (A>>>1) es 1 |
Ejemplo:
Rust
fn main() { let a = 1; let b = 2; // Bitwise AND, 0 (01 && 10 -> 00) let c = a & b; // Bitwise OR, 3 (01 || 10 -> 11) let d = a | b; // Bitwise exclusive OR, 3 (01 != 10 -> 11) let e = a ^ b; // Left-shift, 4 let f = a << b; // 16 a->'01'+"0000" ->'10000' let f2 = a << 4; // Right-shift, 0 let g = a >> b; // 0 '11111' -> remove 4 bits from the end ->'1' let g2 = 31 >> 4; // Bitwise NOT let h = !a; println!(" a: {a}, b: {b}, c: {a} & {b} is {c}, d: {a} | {b} is {d}, e: {a} ^ {b} is {e}, f: {a} << {b} is {f}, f2: {a} << 4 is {f2}, g: {a} >> {b} is {g}, g2: {a} >> {b} is {g2}, h: !{a} = {h}", a=a, b=b, c=c, d=d, e=e, f=f, f2=f2, g=g, g2=g2, h=h); }
Producción:
a: 1, b: 2, c: 1 & 2 is 0, d: 1 | 2 is 3, e: 1 ^ 2 is 3, f: 1 << 2 is 4, f2: 1 << 4 is 16, g: 1 >> 2 is 0, g2: 1 >> 2 is 1, h: !1 = -2
Operadores de asignación compuesta
Los operadores de asignación compuesta realizan la operación especificada por el operador adicional y luego asignan el resultado al operando izquierdo. Por ejemplo, una expresión de asignación compuesta como
expression1 += expression2
Supongamos que A=4
S.No | Operador | Explicación | Ejemplo |
---|---|---|---|
1 | += | Adición y asignación aritmética | A+=2 es 6 |
2 | -= | Resta y asignación aritmética | A-=2 es 2 |
3 | *= | Multiplicación y asignación aritmética | A*=2 es 8 |
4 | /= | División aritmética y asignación | A/=2 es 2 |
5 | %= | Resto aritmético y asignación | A%=2 es 0 |
6 | <<= | Desplazamiento a la izquierda y asignación | A<<=1 es 0 |
7 | >>= | Desplazamiento a la derecha y asignación | A>>=1 es 2 |
8 | &= | AND bit a bit y asignación | A&=2 es 0 |
9 | |= | OR bit a bit y asignación | A|=2 es 6 |
10 | ^= | OR exclusivo bit a bit y asignación | A^=2 es 1 |
Ejemplo:
Rust
fn main() { let mut a = 4; println!("a is {}", a); // Arithmetic addition and assignment, 4 + 5 = 7 a += 5; println!("1: a += 5 is {}", a); // Arithmetic subtraction and assignment, 9 - 2 = 7 a -= 2; println!("2: a -= 2 is {}", a); // Arithmetic multiplication and assignment, 7 * 5 = 35 a *= 5; println!("3: a *= 5 is {}", a); // Arithmetic division and assignment, 35 / 2 = 17 not 17.5 a /= 2; println!("4: a /= 2 is {}", a); // Arithmetic remainder and assignment, 17 % 5 = 2 a %= 5; println!("5: a %= 5 is {}", a); // Bitwise AND and assignment, 10 && 10 -> 10 -> 2 a &= 2; println!("6: a &= 2 is {}", a); // Bitwise OR and assignment, 010 || 101 -> 111 -> 7 a |= 5; println!("7: a |= 5 is {}", a); // Bitwise exclusive OR and assignment, 111 ^= 010 -> 101 -> 5 a ^= 2; println!("8: a ^= 2 is {}", a); // Left-shift and assignment, '101'+'0' -> 1010 -> 10 a <<= 1; println!("9: a <<= 1 is {}", a); // Right-shift and assignment, 101̶0̶ -> 10 -> a >>= 2; 2 println!("10: a >>= 2 is {}", a); }
Producción:
a is 4 1: a += 5 is 9 2: a -= 2 is 7 3: a *= 5 is 35 4: a /= 2 is 17 5: a %= 5 is 2 6: a &= 2 is 2 7: a |= 5 is 7 8: a ^= 2 is 5 9: a <<= 1 is 10 10: a >>= 2 is 2
Publicación traducida automáticamente
Artículo escrito por sushmanag73 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA