Referencias JS


Operadores

 

1. Asignación

Estos operadores, nos permiten cambiar de manera simple y controlada el valor de una variable. Es la manera de inicializar una variable.

El signo igual (=): asigna el valor (que está a su izquierda) al nombre de la variable (que está a su derecha derecha)

var x = 1;
var a = 7, b = 13;
var c = "naranja", d = true;

Muchas veces deseamos mantener el valor que está en la variable y cambiarlo mínimamente. Realizar operaciones matemáticas con el valor de una variable y luego guardar el resultado en la misma variable es muy frecuente y en JavaScript (y en otros muchos lengujes) hay abreviaturas para hacer esto, en esta tabla puedes verlas:

operadores incre

 

2. Comparación o relación

En JavaScript tenemos los siguientes comparadores: mayor que (>), mayor o igual que (>=), menor que (<), menor o igual que (<=), igual que (==) y estrictamente igual que (===). Es decir, en JavaScript tenemos un comparador adiccional, que nos permite comparar entre dos elementos, no solo por su valor, también por su tipo. Con el tripe igual no solo comparamos valores sino además su tipo.

Estos son algunos ejemplos...


var mayorQue = 8 > 3;
var menorQue = 10 < 50;
var mayorIgual = 100 >= 90;
var menorIgual = 10 <= 40;
var igual = (13 == 13);
var identico1 = (13 === 13);  // Ojo! compara valor y tipo de dato
var identico2 = (13 === '13'); // R. falso
var distinto = 100 != 10;

 

3. Aritméticos

Las matemáticas básicas en JavaScript son muy similares a cualquier lenguaje (sumar +, restar -, multiplicar * y dividir /). El único operador matemático que puede resultarnos extraño es el módulo o resto de la división entera, que se indica con el signo de porcentaje (%). También podemos utilizar los signos de agrupación para designar y/o cambiar el orden de las operaciones, utilizando siempre paréntesis, con distinto grado de profundidad. Es útil mencionar aquí que si utilizamos el signo (+) con variables de cadena, lo que conseguimos es concatenar dichos string. Ejemplos:


var suma = 5 + 9;                   // R.  14
var resta = 10 - 3;                 // R.   7
var multiplicacion = 4 * 3;         // R.  12
var division = 18 / 2;              // R.   9 
var modulo = 53 % 10;               // R.   3
var agrupado1 = 3 + (4 * 5) - 6;    // R.  17
var agrupado2 = (3 + 4) * (5 - 6);  // R.  -7
var cadenas = '4' + '3';            // R.  43   ojo! son string

 

4. Lógicos

Podemos concatenar validaciones y así evaluar expresiones más complejas. En JavaScript disponemos de && (todo debe resolverse como verdadero, es el Y (AND) lógico), || (Al menos uno de los elementos debe ser verdadero, es el O (OR) lógico) y la negación que es el operador NO y se representa con (!).

Conviene mencionar también aquí el operador distinto (no es igual) que se representa así (!=) y el estrictamente distinto (no es idéntico) que se representa así (!==)


//  AND(&&)
console.log(true && true);   // true
console.log(true && false);  // false
console.log(false && false); // false
console.log(false && true);  // false
//  OR(||)
console.log(true || true);   // true
console.log(true || false);  // true
console.log(false || false); // false
console.log(false || true);  // true

var exp1 = true && true;             // R.  true
var exp2 = (3 == 3) && (5 >= 8);     // R.  false
var exp3 = (9 > 11) || (17 <= 40);   // R.  true
var exp4 = false || false;           // R.  false

En JavaScript todo puede ser comparado en términos booleanos, especialmente si hacemos uso de la función Boolean(). En general podemos saber cómo responderá JavaScript, si tenemos en cuenta el “valor real”
de la expresión que deseamos validar. Por ejemplo, una cadena de texto vacía (“”) no aportará valor real, por lo que será false. Es importante indicar que el 0 y -0 son false.

Orden de prioridad de los operadores (de mayor prioridad a menor prioridad)

  1. Los paréntesis
  2. Exponenciación
  3. Multiplicación y división
  4. Sumas y restas
  5. Módulo
  6. Comparación
  7. Lógicos

 

5. typeof

El operador typeof se emplea para determinar el tipo de dato que almacena una variable. Su uso es muy sencillo, ya que sólo es necesario indicar el nombre de la variable cuyo tipo se quiere averiguar, ejemplo:


var Saludar = function() {
  console.log('Hola a todos');
};
var Usuario = {
    nombre : 'Juan'
};
var Vocales = [ 'a', 'e', 'i','o' ,'u'];
var frase = 'En un lugar de la Mancha...';
var numero = 8;
 
typeof Saludar;     // devuelve 'function'
typeof Usuario;     // devuelve 'object'
typeof Vocales;     // devuelve 'object' ¡ojo!
typeof frase;       // devuelve 'string'
typeof numero;      // devuelve 'number'
typeof null;        // devuelve 'object' ¡ojo!

Los posibles valores de retorno del operador son: undefined, boolean, number, string para cada uno de los tipos primitivos y object para los valores de referencia y también para los valores de tipo null.

El operador typeof no distingue entre las variables declaradas pero no inicializadas y las variables que ni siquiera han sido declaradas

 

Visitas...

Hoy ........ 0

Ayer ....... 1

Mes ........ 37

Total ........ 5556

En línea...

Hay 38 invitados y ningún miembro en línea

< 3con14 - LAB / >

1998 - 2017, www.3con14.biz
(cc) Jesús Plaza M.
RECONOCIMIENTOS