Operadores en TypeScript

Este artículo explica los operadores en TypeScript.

YouTube Video

Operadores en TypeScript

Los operadores en TypeScript se utilizan para realizar cálculos numéricos, comparaciones de valores y operaciones lógicas. Dado que TypeScript utiliza operadores similares a JavaScript, son fáciles de acostumbrarse, pero TypeScript permite operaciones más rigurosas utilizando la seguridad de tipos.

Los principales operadores son los siguientes:.

Operadores Aritméticos

Los operadores aritméticos se utilizan para cálculos numéricos.

 1let a = 10; // Initialize variable 'a' with the value 10
 2let b = 3;  // Initialize variable 'b' with the value 3
 3
 4// Perform and display arithmetic operations between 'a' and 'b'
 5console.log("Addition (a + b):      ", a + b); // 13
 6console.log("Subtraction (a - b):   ", a - b); // 7
 7console.log("Multiplication (a * b):", a * b); // 30
 8console.log("Division (a / b):      ", a / b); // 3.333...
 9console.log("Modulus (a % b):       ", a % b); // 1
10
11// Demonstrate post-increment operation on 'a'
12// Output the current value of 'a' (10), then increment
13console.log("Post-increment (a++):  ", a++);
14// Display the incremented value of 'a' (11)
15console.log("Value of 'a' after increment:", a);
16
17// Demonstrate pre-increment operation on 'a'
18// Increment 'a' first (12) then output
19console.log("Pre-increment (++a):   ", ++a);
20
21// Demonstrate post-decrement operation on 'a'
22// Output the current value of 'a' (12), then decrement
23console.log("Post-decrement (a--):  ", a--);
24// Display the decremented value of 'a' (11)
25console.log("Value of 'a' after decrement:", a);
26
27// Demonstrate pre-decrement operation on 'a'
28// Decrement 'a' first (10) then output
29console.log("Pre-decrement (--a):   ", --a);

Operadores de Asignación

Los operadores de asignación asignan el valor de la derecha a la variable de la izquierda.

1let z = 5;
2z += 3;
3console.log(z);  // Outputs: 8
4
5z *= 2;
6console.log(z);  // Outputs: 16

Operadores de Comparación

Los operadores de comparación comparan valores y devuelven true o false.

1console.log('5 == "5"   :', 5 == "5");   // Outputs: true
2console.log('5 === "5"  :', 5 === "5");  // Outputs: false
3console.log('5 != "5"   :', 5 != "5");   // Outputs: false
4console.log('5 !== "5"  :', 5 !== "5");  // Outputs: true
5console.log('5 > 3      :', 5 > 3);      // Outputs: true
6console.log('5 < 3      :', 5 < 3);      // Outputs: false
7console.log('5 >= 5     :', 5 >= 5);     // Outputs: true
8console.log('5 <= 3     :', 5 <= 3);     // Outputs: false

Operadores Lógicos

Los operadores lógicos se utilizan para combinar expresiones lógicas.

1console.log('true && false :', true && false);  // Outputs: false
2console.log('true || false :', true || false);  // Outputs: true
3console.log('!true         :', !true);          // Outputs: false

Precedencia de los Operadores Lógicos

En TypeScript, los operadores lógicos generalmente se evalúan en el orden de NOT primero, seguido de AND, y finalmente OR.

NOT Tiene la Mayor Precedencia

NOT es un operador unario y se evalúa con la mayor precedencia.

1console.log(!true || false);  // false

AND Tiene Mayor Precedencia que OR

AND tiene una precedencia mayor que OR, por lo que la parte de AND se evalúa primero.

1console.log(true || false && false);  // true

Como resultado, la parte de AND (&&) se calcula primero, y su resultado se pasa a OR (||).

AND y OR Realizan Evaluación de Cortocircuito

En TypeScript, AND y OR realizan evaluación de cortocircuito. Si el resultado está determinado por el valor del lado izquierdo, la expresión del lado derecho no se evalúa.

1let a = false && console.log("This will not be printed");
2console.log(a);  // false
3
4let b = true || console.log("This will not be printed");
5console.log(b);  // true

En ambos casos, console.log() no se ejecuta.

Definiendo la Precedencia de Forma Explícita

Usar paréntesis para agrupar expresiones explícitamente puede prevenir malentendidos sobre la precedencia.

1console.log(true || (false && false));  // true

Diferencias entre el Lenguaje Natural y la Interpretación en Programación

Al usar operadores lógicos, es importante ser consciente de las ambigüedades en el lenguaje natural. Por ejemplo, en la frase 'un perro blanco o un gato', podría significar 'un perro blanco o cualquier gato' o 'un perro blanco o un gato blanco'. En código, podría escribirse de la siguiente manera:.

1if (isWhite && isDog || isCat) {
2    console.log(' "A white dog" or "a cat of any color" ');
3}
4
5if (isWhite && (isDog || isCat)) {
6    console.log(' "A white dog" or "a white cat" ');
7}

Dado que el lenguaje natural puede ser ambiguo, se requiere precaución al programar y diseñar sistemas.

Operadores a Nivel de Bits

Los operadores a nivel de bits manipulan números al nivel de bits.

1console.log('5 & 1  :', 5 & 1);   // Outputs: 1  (AND operation)
2console.log('5 | 1  :', 5 | 1);   // Outputs: 5  (OR operation)
3console.log('5 ^ 1  :', 5 ^ 1);   // Outputs: 4  (XOR operation)
4console.log('~5     :', ~5);      // Outputs: -6 (NOT operation)
5console.log('5 << 1 :', 5 << 1);  // Outputs: 10 (Left shift operation)
6console.log('5 >> 1 :', 5 >> 1);  // Outputs: 2  (Right shift operation)
7console.log('5 >>> 1:', 5 >>> 1); // Outputs: 2  (Unsigned right shift operation)

Operador Ternario

El operador ternario devuelve valores diferentes en función del resultado de una expresión condicional.

1let age = 20;
2let access = (age >= 18) ? "Allowed" : "Denied";
3console.log(access);  // Outputs: Allowed

Operadores de Tipo

Los operadores de tipo de TypeScript incluyen lo siguiente:.

 1console.log(typeof "Hello");  // "string"
 2console.log(typeof 42);       // "number"
 3
 4let arr: number[] = [1, 2, 3];
 5console.log("arr instanceof Array : ", arr instanceof Array); // true
 6
 7// Example of Type Guard
 8function isString(value: any): value is string {
 9  return typeof value === "string";
10}
11
12let value: any = "Hello";
13if (isString(value)) {
14  console.log("Value is a string:", value);  // "Value is a string: Hello"
15}

Los operadores de tipo se utilizan para verificar el tipo de un valor o convertirlo a un tipo específico.

• El operador typeof devuelve el tipo de una variable.
• El operador instanceof verifica si un objeto pertenece a una clase específica.
• El operador is se utiliza para verificar si un valor es de un tipo específico. Es parte de los guardianes de tipo de TypeScript.

Resumen

• Operadores Aritméticos: Realizan cálculos básicos.
• Operadores de Asignación: Asignan valores a variables.
• Operadores de Comparación: Comparan valores.
• Operadores Lógicos: Combinan condiciones lógicas.
• Operadores a Nivel de Bits: Realizan operaciones a nivel de bits.
• Operador Ternario: Devuelve valores en función de condiciones.
• Los operadores de tipo pueden verificar el tipo de un valor.

En TypeScript, estos operadores se pueden utilizar para escribir cálculos complejos y expresiones condicionales de manera eficiente.

Puedes seguir el artículo anterior utilizando Visual Studio Code en nuestro canal de YouTube. Por favor, también revisa nuestro canal de YouTube.

YouTube Video