Operadores

Tabla de contenidos

1. Introducción
2. Operadores aritméticos
3. Operadores comparativos

Introducción

Los operadores son símbolos con los que, como su nombre indica, se pueden realizar operaciones con variables, valores constantes o variables y valores constantes. Hay muchos tipos de operadores, pero para esta introducción voy a centrarme en los más comunes:

• Operadores aritméticos: Son los que se emplean para realizar operaciones aritméticas con valores y/o variables.
• Operadores comparativos: Se emplean para establecer comparaciones entre valores y/o variables.
• Operadores lógicos: Se emplean para establecer condiciones, por lo que los explicaré en la sección del curso dedicada a los condicionales.

Por si alguien quiere buscar información, los tipos de operadores que faltarían en esta lista serían los unarios (unary operators), los de orden de bits (bitwise operators) y los de asignación (assignment operators).

Operadores aritméticos

Los operadores aritméticos son los que recojo en la tabla siguiente:

var total = sumando1 + sumando2;
    // asigna a total la suma 
    // de las otras dos variables

var total = minuendo - sustraendo;
    // asigna a total la resta
    // de las otras dos variables

var total = factor1 * factor2;
    // asigna a total el producto 
    // de las otras dos variables

var total = dividendo / divisor;
    // asigna a total el cociente 
    // de las otras dos variables

var total = dividendo % divisor;
    // asigna a total el resto 
    // de la división de las dos variables

Como se ve, son autoexplicativos, pero hay que tener en cuenta que las operaciones aritméticas sólo pueden realizarse entre variables que sean números. Y, como hemos visto en el ejemplo sobre tipos de escalares, no siempre un grupo de cifras es un número.

Cuando realizamos una operación como ésta:

    var a = 8;
    var b = 9;
    total = a + b;
            

total adquiere el valor de 17. Sin embargo, cuando se no se trata de numerales, JavaScript concatena las cadenas:

    var a = "cuenta";
    var b = "gotas";
    total = a + b;
            

Aquí total adquire el valor de «cuentagotas». Lo mismo ocurre cuando se intenta sumar un número a una cadena; JavaScript primero convierte el numeral en una cadena, y después concatena:

    var a = 8;
    var b = "gotas";
    total = a + b;
            

El resultado sería «8gotas». Hay que tener esto en cuenta cuando se obtenga un resultado extraño de una opración. Un error común cuando se empieza a trabajar con variales es éste:

    var a = "8";
    var b = "9";
    total = a + b;
            

total no tendrían un valor de 17, sino de «89».

Para el resto de operadores aritméticos, si se emplean tipos de variable que no sean números, el resultado es el valor NaN, Not a Number.

Por último, para operaciones mataméticas más complejas, necesitaríamos emplear el objeto Math, que veremos más adelante.

Operadores comparativos

Como su nombre indica, estos operadores se emplean para realizar comparaciones entre los valores de las variables:

variable1 > variable2
    // es verdadero si variable1 
    // es mayor que variable2

variable1 < variable2
    // es verdadero si variable1 
    // es menor que variable2

variable1 == variable2
    // es verdadero si variable1 
    // y variable2 son iguales

variable1 != variable2
    // es verdadero si variable1 
    // y variable2 son distintas

variable1 >= variable2
    // es verdadero si variable1 
    // es mayor o igual que variable2

variable1 <= variable2
    // es verdadero si variable1 
    // es menor o igual que variable2

variable1 === variable2
    // es verdadero si variable1 y variable2 
    // son idénticas, es decir, 
    // sus valores coinciden 
    // y son del mismo tipo de variable

variable1 !== variable2
    // es verdadero si variable1 y variable2 
    // no son idénticas, es decir, 
    // sus valores son distintos 
    // o no son del mismo tipo de variable

De nuevo, hay que tener en cuenta los tipos de variables. ¿Qué ocurre cuando se establecen comparaciones entre cadenas literales?:

• == y !=: Comparan las series de caracteres variables, y su orden.
• >, <, >=, <=: Comparan el orden alfabético de los caracteres, para ver cuál sería anterior, característica que se iguala a mayor.

Así:

    var a = "ying";
    var b = "yang";
    alert(a==b);     // devuelve false
    alert(a!=b);     // devuelve true
    alert(a>b);      // devuelve true
    alert(a<b);      // devuelve false
    alert(a>=b);     // devuelve true
    alert(a<=b);     // devuelve false
            

Por su parte, con los comparadores de identidad no sólo debe darse coincidencia del valor, sino del tipo de variable. Así:

    var a = 17;
    var b = "17";
    alert(a==b);
            

Resulta true, porque para poder comparar ambos valores JavaScript toma ambos como literales y establece que los caracteres y su orden son los mismos. Sin embargo, si comprobamos su identidad:

    var a = 17;
    var b = "17";
    alert(a===b);
            

el resultado es false, porque no se trata del mismo tipo de variable.

Pasemos ahora a ver las condiciones y el tercer tipo de operadores.