Operadores
3. Los Operadores:
A. Operadores Aritméticos
En los primeros ejemplos de este manual sólo se han usado sentencias muy simples como asignar un valor a una variable, mediante el operador de asignación , =, o realizar operaciones aritméticas, pero evidentemente JavaScript puede realizar mas operaciones. En esta seccion y las siguientes se presentan los operadores de que dispone este lenguaje clasificados en varios grupos, según el contexto en el que se usen. Comenzamos con los más conocidos, los operadores aritméticos.
Suma +
Se trata de un operador usado para sumar dos valores numéricos o para concatenar cadenas entre sí o números y cadenas.
let var1 = 10, var2 = 'Buenos', var3 = ' días', var4 = 31;
logger.warn(var1+var4) /* resultado 41 */
logger.warn(var2+var3) /* resultado: Buenos días */
logger.warn(var1+var3) /* resultando: 10 días */
Resta -
Operador usado para restar valores numéricos. Puede actuar sobre un único operando numérico cambiándole de signo.
let num1 = 10, num2 = 8, res = 0;
res = num1 - num2; /*res contiene 2 */
res = -res /* ahora res contiene -2*/
Producto ( * ) y cociente ( / )
Realizan las operaciones aritméticas de multiplicar y dividir dos valores
let op1 = 50, op2= 4, div, mul;
div = op1/op2 /*div contiene 12.5 */
mul = op1 * op2 /*mul contendrá 200 */
Resto %
También llamado operador módulo calcula el resto de una división.
let op1 = 50, op2 = 4, resto;
resto = op1 % op2; /*resto contiene 2 */
Incremento ( ++) y decremento (--)
Estos operadores se usan para incrementar o decrementar en 1 el valor de una variable. Si el operador se antepone a la variable la operación de incremento o decremento es prioritaria sobre cualquier otra.
let op1 = 5, op2 = 5, res;
res = ++op1; /*res adquiere el valor 6 y luego op1 el 6*/
res = op1++; /*res adquiere el valor 5 y luego op2 el 6*/
Operadores compuestos
Los operadores +, -, *, \/ pueden asociarse con el operador de asignación (=) para cambiar el valor de una variable numérica por incrementándolo, decrementándolo, multiplicándolo o dividiéndolo por un valor. El operador += puede usarse igualmente con variables de cadena.
let num = 20, cad = 'buena';
num += 5; /*num adquiere el valor 25 (20 + 5) */
cad += 's' ; /*cad adquiere el valor 'buenas' */
num *= 10; /*num adquiere el valor 250 (25*10) */
B. Operadores Binarios
Complementación ~
Complementa una cadena binaria convirtiendo los 1 en 0 y los 0 en 1. Por ejemplo el número 38 escrito en sistema binario es 00100110 si le aplicamos este operador se convierte en 11011001, o sea el -39 (JavaScript usa codificación en complemento a 2 para los números negativos).
Desplazamiento izquierda <<
Desplaza los bits a la izquierda los lugares que se le indique rellenando con ceros por la derecha y desechando los bits de mayor peso, esto equivale a multiplicar por potencias de 2. Por ejemplo si al 00011010 (26) lo desplazamos 2 a la izquierda tendremos el 01101000 (104).
let num = 26, res;
res = num << 2; /* num contendrá 104 */
Desplazamiento derecha >>
Desplaza los bits a la derecha los lugares que se le indique rellenando con ceros por la izquierda y desechando los bits de menor peso, esto equivale a una división entera por potencias de 2. Por ejemplo si al 00011010 (26) lo desplazamos 2 a la derecha tendremos el 00000110 (6).
let num = 26, res;
res = num << 2; /* num contendrá 104 */
AND lógico binario &
Realiza un AND lógico bit a bit entre dos valores. El AND lógico da como resultado 1 sólo si ambos bits son 1. Por ejemplo 01101101 (109) AND 00100110 (38) resultado: 00100100 (36)
let op1 = 109, op2 = 38, res;
res = op1 & op2; /*res contiene 36 */
OR lógico binario |
Realiza un OR lógico bit a bit entre dos valores. El OR lógico da como resultado 0 sólo si ambos bits son 0. Por ejemplo 00111010 (58) OR 01010010 (82) resultado: 01111010 (122) En el ejemplo podemos ver la sintaxis del operador
let op1 = 58, op2 = 82, res;
res = op1 | op2; /*res contiene 122 */
XOR lógico binario ^
Realiza un XOR lógico bit a bit entre dos valores. El XOR lógico da como resultado 1 si uno sólo de los bits es 1. Por ejemplo 00111010 (58) OR 01010010 (82) resultado: 00101000 (40) En el ejemplo podemos ver la sintaxis del operador
let op1 = 109, op2 = 38, res;
res = op1 ^ op2; /*res contiene 40*/
C. Operadores Lógicos
Los peradores lógicos se utilizan para realizar comparaciones entre valores, numéricos o no, dando como resultado un valor booleanos ( true , false ). La operación lógica negación invierte el operando, si es true lo hace false y viceversa. Si se comparan números con cadenas, JavaScript intenta convertir internamente los datos. En los operadores relacionales (>, <, >=, <=) intenta convertir los datos en tipo número. Para los operadores de igualdad (== !=) intenta convertir los tipos de datos a cadena, número y booleano. Los operadores de identidad (===, !==) no realizan conversión de tipo.
Mayor que >
Compara dos valores y devuelve true si el primero es mayor que el segundo. Compara tanto números como cadenas.
let hoy = 4, ayer = 10, comp;
comp = hoy > ayer /* comp adquiere el valor false*/
Menor que <
Compara dos valores y devuelve true si el primero es mayor que el segundo. Compara tanto números como cadenas.
let hoy = 4, ayer = 10, comp;
comp = hoy < ayer /* comp adquiere el valor false*/
Mayor o igual >=
Compara dos valores y devuelve true si el primero es mayor o es igual que el segundo. Compara tanto números como cadenas.
let hoy = 4, ayer = 4, comp;
comp = hoy >= ayer /* comp adquiere el valor true*/
Menor o igual <=
Compara dos valores y devuelve true si el primero es menor o es igual que el segundo. Compara tanto números como cadenas.
let hoy = 4, ayer = 4, comp;
comp = hoy <= ayer /* comp adquiere el valor true*/
Iguales ==
Compara dos valores y devuelve true si ambos son iguales. Compara tanto números como cadenas.
let hoy = 4, ayer = 4, comp;
comp = hoy == ayer /* comp adquiere el valor true*/
Idénticos ===
Similar a == pero también compara el tipo de datos de los opeandos. Compara dos valores y devuelve true si el primero es igual al segundo y el tipo de datos de ambos es el mismo. Compara tanto números como cadenas.
let hoy = 4, ayer = '4', comp;
comp = hoy == ayer; /* comp adquiere el valor true*/
comp = hoy === ayer /* comp adquiere el valor false*/
No iguales != No identicos !==
Invierten el sentido de las comparaciones iguales == e idénticos === respectivamente.
AND lógico &&
Este operador se utiliza para concatenar comparaciones, es decir, para comprobar varias condiciones. El resultado sólo será true si todas las comparaciones lo son.
let op1 = 2, op2 = 50, op3 = 25, comp;
comp = (op1 > op2) && (op1 < op3); /*comp adquiere el valor false */
comp es false por que op1 no es mayor que op2 aunque sea mayor que op
OR lógico ||
Como el anterior, sirve apra realizar comparaciones compuestas y sólo devolverá false cuando todas las comparaciones los sean. Es decir basta que una comparación sea true para que devuelva el valor true.
let op1 = 2, op2 = 50, op3 = 25, comp;
comp = (op1 > op2) && (op1 < op3); /*comp adquiere el valor true */
comp es true por que op1 es menor que op3, (op1 < op3 es por tanto true)
D. Operadores Varios
delete
Se usa para borrar propiedades de un objeto o elementos de un array. Devuelve true si la operación se realizaó con éxito.
let lista = new Array(1, 4, 7, 9, 10);
delete(lista,0);
El elemento lista[1] contiene ahora undefined.
new
Se utiliza para crear instancias de un objeto
let hoy = new Date('10/30/2000')
typeof
Devuelve el tipo de dato al que pertenece una variable o expresión. Los tipos devueltos son number, string, boolean, object, function y undefined.
let hoy = 1.2345;
tipo = typeof(hoy);
La variable tipo contendrá number.
E. Funciones Globales
A sí como JavaScript proporciona objetos predefinidos, también posee una serie de funciones predefinidas. Se trata de las funciones: eval, isNan, Number, String, parseInt, parseFloat, escape, unescape.
eval
Se usa para evaluar una cadena con código JavaScript sin referirse a un objeto concreto. La sintáxis de eval es:
eval(expr)
donde expr es la cadena a evaluar.
isNaN(arg)
Determina si el argumento es un valor NaN (not a number)
parseInt(str, [base])
Convierte una cadena de caracteres en un valor numérico. La función lleva como argumento la cadena a convertir y opcionalmente puede llevar un segundo argumento para indicar la base de numeración en que está escrita la cadena.
Si se omite se supone que la cadena representa un número en base 10. La cadena sólo podrá contener caractéres válidos para el sistema de numeración indicado: dígitos (0..9 para la base 10, 0 1 para números binarios, 0..7 para sistema octal, 0..9, A..F para sistema hexadecimal) y signo (+, -).
Si encuentra algún carácter no válido sólo interpreta desde el principio de la cadena hasta el carácter no válido. Si comienza por un carácter ilegal devuelve NaN. Ejemplo:
let minum1 = '14';
logger.warn(parseInt(minum1));
Escribirá 14. En el siguiente ejemplo transforma un número binario a decimal:
let minum1 = '11001';
logger.warn(parseInt(minum1, 2));
Ahora escribirá 25, el equivalente decimal al binario 11001.
parseFloat(str)
Convierten una la cadena que se le pasa como argumento a un valor numérico de tipo flotante. Los caracteres válidos de la cadena son los mismos que en parseInt mas el punto decimal y el exponente (E). No admite un segundo argumento. Por lo demás funciona exactamente igual que parseInt.
let minum1 = '14.5E2';
logger.warn(parseInt(minum1));
Escribirá el número 1450, 14.5 por 10 elevado a 2.
Number(objArg) and String(objArg)
Permiten convertir el objeto pasado como argumento a un número o a una cadena. Por ejemplo:
let hoy = new Date();
hoy.getDate();
logger.warn(string(hoy));
Escribirá en pantalla la cadena "Sun Sep 3 20:40:05 UTC+0200 2000" si la fecha del día es domingo 3 de Septiembre y la hora es las 20:40:05.
escape(cadarg)
Codifica la cadena del argumento substituyendo todos los caracteres no ASCII por su código en el formato %xx. Por ejemplo:
let cadena = 'Buenos días';
logger.warn(escape(cadena));
Produce la frase "Buenos d%EDas", pues la í (i acentuada) es el código hexadecimal ED de ese carácter.
unescape(cadarg)
Es inversa a la anterior, de manera que si la cadena contiene códigos del tipo %xx son convertidos al correspondiente carácter ASCII extendido.
let cadena = 'Buenos d%EDas';
logger.warn(escape(cadena));
Ahora se escribirá 'Buenos días', se ha substituido %ED por su equivalente í (i acentuada).
F. Expresiones Regulares
Las expresiones regulares constituyen un mecanismo bastante potente para realizar manipulaciones de cadenas de texto. El proceso para el que se usan estas expresiones, presente en el mundo el UNIX y el lenguaje Perl, es el de buscar y/o sustituir una subcadena de texto dentro de otra cadena.
En principio esto puede hacerse usando los métodos del objeto string , pero el problema surge cuando no tenemos una subcadena fija y concreta sino que queremos buscar un texto que responda a un cierto esquema, como por ejemplo: buscar aquellas palabras que comienzan con http: y finalizan con una \, o buscar palabras que contengan una serie de números consecutivos, etc.; es en estos casos cuando las expresiones regulares muestran toda su potencia.
La subcadena que buscamos en el texto es lo que se llama un patrón y se construye encerrando entre dos barras inclinadas ( / ) una serie de caracteres normales y símbolos especiales llamados comodines o metacaracteres, (algo parecido a la orden dir *.bat usada en el DOS cuando queríamos listar los ficheros con extensión bat).
Este patrón es una descripción del texto que se está buscando y JavaScript encontrará las subcadenas que concuerdan con ese patrón o definición. Las expresiones regulares se usan con el objeto Regular Expresion y también dentro de los métodos String.match , String.replace , String.search y String.split.
En la tabla que sigue se muestran los caracteres comodín usados para crear los patrones y su significado, junto a un pequeño ejemplo de su utilización.
| Significado | Ejemplo | Resultado | |
|---|---|---|---|
| \ | Marca de carácter especial | /\$ftp/ | Busca la palabra $ftp |
| ^ | Comienzo de una línea | /^-/ | Líneas que comienzan por - |
| $ | Final de una línea | /s$/ | Líneas que terminan por s |
| . | Cualquier carácter (menos salto de línea) | \b.\b/ | Palabras de una sola letra |
| | | Indica opciones | /(L|l|f|)ocal/ | Busca Local, local, focal |
| ( ) | Agrupar caracteres | /(vocal)/ | Busca vocal |
| [ ] | Conjunto de caracteres opcionales | /escrib[aoe]/ | Vale escriba, escribo, escribe |
La tabla que sigue describe los modificadores que se pueden usar con los caracteres que forman el patrón. Cada modificador actúa sobre el carácter o el paréntesis inmediatamente anterior.
| Descripción | Ejemplo | Resultado | |
|---|---|---|---|
| * | Repetir 0 o mas veces | /l*234/ | Valen 234, 1234, 11234... |
| + | Repetir 1 o mas veces | /a*mar/ | Valen amar, aamar, aaamar... |
| ? | 1 o 0 veces | /a?mar/ | Valen amar, mar. |
| {n} | Exactamente n veces | /p{2}sado/ | Vale ppsado |
| {n,} | Al menos n veces | /(m){2}ala/ | Vale mmala, mmmala.... |
| {m,n} | entre m y n veces | /tal{1,3}a/ | Vale tala, talla, tallla |
Los siguientes son caracteres especiales o metacaracteres para indicar caracteres de texto no imprimibles, como puedan ser el fín de línea o un tabulador, o grupos predefinidos de caracteres (alfabéticos, numéricos, etc...)
| Descripción | Ejemplo | Resultado | |
|---|---|---|---|
| \b | Principio o final de palabra | /\bver\b/ | Encuentra ver en "ver de" , pero no en "verde" |
| \B | Frontera entre no-palabras | /\Bver\B/ | Empareja ver con "Valverde" pero no con "verde" |
| \d | Un dígito | /[A-Z]\d/ | No falla en "A4" |
| \D | Alfabético (no dígito) | /[A-Z]\D/ | Fallaría en "A4" |
| \O | Carácter nulo | ||
| \t | Caracter ASCII 9 (tabulador) | ||
| \f | Salto de página | ||
| \n | Salto de línea | ||
| \w | Cualquier alfanumérico, [a-zA-Z0-9_ ] | /\w+/ | Encuentra frase en " frase .", pero no el . (punto). |
| \W | Opuesto a \w ([^a-zA-Z0-9_ ]) | /\W/ | Hallaría sólo el punto (.) |
| \s | Carácter tipo espacio (como tab) | /\sSi\s/ | Encuentra Si en "Digo Si ", pero no en "Digo Sientate" |
| \S | Opuesto a \s^ | ||
| \cX | Carácter de control X | \c9 | El tabulador |
| \oNN | Carácter octal NN | ||
| \xhh | El hexadecimal hh | /\x41/ | Encuentra la A (ASCII Hex41) en "letra A" |