Ir directamente al contenido de esta página

codexexempla.org

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:

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:

Operadores aritméticos, sus significados y su sintaxis
Operador Operación Sintaxis
+ Adición
var total = sumando1 + sumando2;
    // asigna a total la suma 
    // de las otras dos variables
- Sustracción
var total = minuendo - sustraendo;
    // asigna a total la resta
    // de las otras dos variables
* Multiplicación
var total = factor1 * factor2;
    // asigna a total el producto 
    // de las otras dos variables
/ División
var total = dividendo / divisor;
    // asigna a total el cociente 
    // de las otras dos variables
% Módulo de división
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:

Operadores comparativos, sus significados y su sintaxis
Operador Significado Sintaxis
> Mayor que
variable1 > variable2
    // es verdadero si variable1 
    // es mayor que variable2
< Menor que
variable1 < variable2
    // es verdadero si variable1 
    // es menor que variable2
== Igual a
variable1 == variable2
    // es verdadero si variable1 
    // y variable2 son iguales
!= Distinto de
variable1 != variable2
    // es verdadero si variable1 
    // y variable2 son distintas
>= Mayor o igual a
variable1 >= variable2
    // es verdadero si variable1 
    // es mayor o igual que variable2
<= Menor o igual que
variable1 <= variable2
    // es verdadero si variable1 
    // es menor o igual que variable2
=== Idéntico a
variable1 === variable2
    // es verdadero si variable1 y variable2 
    // son idénticas, es decir, 
    // sus valores coinciden 
    // y son del mismo tipo de variable
!== No idéntico a
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?:

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.

Contacto

En virtud de la Ley Orgánica 15/1999 de Protección de Datos de Carácter Personal le informo de que los datos que proporcione no serán empleados para otro fin que el de responder a su mensaje. En especial, me comprometo a no cederlos a terceros ni a emplearlos para enviar información no solicitada.

Del blog de Digital Icon

(cc) CodexExempla.org, 2007–2017 Mapa del sitio | XHTML | CSS | AA