JavaScript VII Tipos de valores y operadores IV

Seguimos estudiando los valores y operadores, nuestra idea es repasarlos de una manera rápida, sin ocupar más que el tiempo mínimo para familiarizarnos con los distintos tipos y tener una de idea básica antes de usarlos y comenzar a teclear pequeños programas, así que sin más dilación vayamos a terminar el repaso de los valores y los operadores.

Hasta este momento hemos repasado distintos tipos de operadores siendo todos símbolos, ahora vamos a repasar unos cuantos que directamente son palabras y veremos algunos comportamientos quizás no esperados de JavaScript con el tratamiento de algunos valores.
 
Operadores Unarios
 
typeof
Este es uno de esos operadores unarios y que además es una palabra, no un símbolo, el operador typeof al usarlo nos devolverá un valor de cadena, que nos indicará con qué tipo de valor se está operando o dicho de otra forma le asignaremos un valor y el operador typeof nos dirá de que tipo es el valor, ya sea numérico de cadena, booleano....  Recordemos que un operador Unario es aquel que solo necesita un valor para operar, por ejemplo:
 
 El operador + necesita dos valores para operar y hacer la suma el 2 y el 3
 
2 + 3 nos devolverá un 5
 
Este es un operador binario, dado que necesita dos valores para operar.
Un operador Unario solo necesitará un valor para operar, por ejemplo:
 
typeof 2; // nos devolverá el valor “number”
o
typeof (2); // nos devolverá el valor “number”
 
Los dos ejemplos de arriba son iguales, como dijimos se opera solo con un valor el 2, ambos ejemplos darán un mismo resultado, como habréis podido observar, la única diferencia entre estas dos declaraciones, es que en la segunda el número 2 está entre dos paréntesis, como en algunos operadores estos son obligatorios, algunos programadores recomiendan que se use aún cuando no es necesario, pero no es obligatorio en este operador como podréis comprobar.
 
typeof “cadena”; //devolverá el valor “string”
 
typeof null; //devolverá el valor “object”
 
typeof false; //devolverá el valor “boolean”
 
delete
La función del operador delete es la de eliminar un objeto, una propiedad de un objeto o un elemento en el índice de un array, esto de momento supera nuestros conocimientos y no vamos a entrar hasta que estemos un poco más avanzados, si bien la sintaxis del operador es la siguiente:
 
delete nombredelobjeto;
delete nombredelobjeto.propiedad;
delete nombredelobjeto[indice];
delete propiedad; // solo se admite cuando se usa una declaración "with"
 
void
El operador void especifica una expresión que se evalúa, pero no devolverá ningún valor, así a priori cuesta encontrar usos, pero más adelante veremos cómo puede resultar útil al crear formularios y… por ahora con saber que existe nos sobra, ya veremos usos más adelante, cuando tengamos otros conocimientos más arraigados.
 
void (expresion)
void expresión
 
Valores Vacíos

En algunos casos necesitaremos valores que indique un valor vacío o una ausencia de un valor significativo, para esto se necesitará un valor que no lleva información, para esto JavaScript, nos tiene reservados dos valores especiales null y undefined.
 
Algunas operaciones en JavaScript, cuando no producen un valor significativo nos devolverán el valor undefined. La razón principal para dar este resultado es que nos tienen que devolver un valor si o si, entonces nos devolverá undefined.
 
Ahora qué diferencia hay entonces entre null y undefined, a priori la mayor parte del tiempo no importa, y pueden usarse indistintamente en la mayoría de casos. 
 
La diferencia es que null se trata como un variable u objeto la cual tiene un valor null (nulo), mientras que undefined se usaría cuando no hay un valor definido ni objeto ni variable, designa algo, un resultado que no es posible definir.
 
Conversión automática de tipo
 
JavaScript, esta ideado de forma que, aunque nos equivoquemos intentará aceptar los programas que le tecleemos, aun cuando el programa no funcione de una forma lógica, pero veamos a que nos referimos con unos ejemplos.

"12" - 3

Pulsa para ver el resultado

En este ejemplo el valor de cadena “12” lo convertirá a un valor numérico para poder ejecutar la resta quedando 12 – 3 igual a 9
 
“12” – 3 //operación inicial imposible de realizar
12 – 3 igual a 9 //así es como lo interpretará

"12" + 3

Pulsa para ver el resultado

En este ejemplo siguiendo la lógica del ejemplo anterior el valor de cadena “12” + 3, en el caso anterior cambio el valor de cadena a un valor numérico y realizo la resta, en este caso parecería lógico pensar que realizará la suma, pues no, trasformará el segundo valor numérico a uno de tipo cadena, y hará una concatenación de cadenas como vimos que se hacían en el capítulo VI, quedando de la siguiente forma.
 
“12” + 3 //operación inicial imposible de realizar
“12” + “3” igual a 123 //así es como lo interpretará

"ocho" * 3

Pulsa para ver el resultado

En este ejemplo al usar el valor de cadena “ocho” * 3, el valor “ocho” digamos que no es un valor tan fácil de identificar como un fallo o como en los anteriores fácil de “adaptar”, por lo que JavaScript lo transformará en un valor NaN (Not a Number/ no es un número), por lo que quedaría
 
“ocho” * 3 //operación inicial imposible de realizar
NaN * 3 es igual a NaN //así es como lo interpretará

false == 0

Pulsa para ver el resultado

En este ejemplo vemos como false == 0 es igual a true, esto es así porque según las reglas para convertir números y cadenas a valores booleanos consideran que NaN el 0 y la cadena vacía “ “ tiene el valor false y el resto de valores tendrán un valor true. Por lo que volviendo al ejemplo.
 
false == 0 es igual a true, es la respuesta “lógica” después de la explicación claro.

12 * null

Pulsa para ver el resultado

En este último ejemplo 12 * null, el valor null lo convierte en un valor numérico 0, por lo que el valor numérico 12 lo multiplica por el valor numérico 0 y nos devuelve 0.
 
12 * null //operación inicial imposible de realizar
12 * 0 es igual a 0 //así es como lo interpretará
 
Como podemos observar en los ejemplos al operar con valores incorrectos, JavaScript cogerá ciertos valores y los modificará sin previo aviso, a un valor con el cual pueda operar. Esto no lo hace de forma aleatoria, sino que usa una serie de reglas que no necesariamente serán las que esperaríamos.
 
Esta modificación automática de un valor dado, con la intención de poder operar se llama type coercion, coerción de tipo o coerción de dato, la podéis encontrar de las tres maneras.
 
Cortocircuito de operadores lógicos
 
En el anterior capítulo hablamos del uso de los operadores lógicos && (and) y || (or), aplicados a valores booleanos pero ¿qué sucede si los valores son de otro tipo?
 
Pues como en los casos anteriores hizo JavaScript, sino puede operar con un tipo de valor, lo cambiará. Convertirá el valor del lado izquierdo a un valor de tipo booleano y a partir de ese instante dependiendo del operador que se este utilizando, actuará en consecuencia a este y del valor modificado, devolviendo dependiendo del caso el valor que estaba en el principio en el lado de la izquierda o el de la derecha.
 
En el caso del operador || (or), nos devolverá el valor de su izquierda siempre que ese valor se pueda convertir en verdadero de lo contrario nos devolverá el valor de la derecha.
 
NaN || “cadena” // devolverá “cadena”
 
Como dijimos unas líneas más arriba NaN es uno de esos valores que al cambiarlos a valores booleanos JavaScript interpreta como false. Por lo tanto, al ser falso nos devolverá el valor de la derecha del operador ||.
 
 “hola” || “adios” // devolverá “hola”
 
El resto de valores que no sean NaN, 0 o la cadena vacía “ “ los interpretará como verdaderos por lo que devolverá el valor de la izquierda del operador ||.
 
El operador && funciona al revés que el operador ||, cuando el valor de la izquierda del operador es un valor que se convertirá en falso, devolverá ese valor y si es verdadero devolverá el valor de la derecha.
 
NaN && “cadena” // devolverá NaN
 
NaN al cambiarlo a un valor booleano JavaScript lo interpreta como false. Por lo tanto, nos devolverá el valor de la izquierda del operador &&, al revés que con ||.
 
 “hola” && “adios” // devolverá “adios”
 
Al considerar “hola” como true, nos devolverá el valor de la derecha del operador “adios”.
 
Otra de las propiedades importantes que tienen estos dos operadores && (and) || (or), es que el valor a la derecha del operador se evalúa solo si es necesario.

¿Cuando es necesario evaluar “el segundo valor” y cuando no?
 
Como vimos en el anterior capítulo estos dos operadores siguen reglas sencillas veamos && (and) este valor devolverá verdadero solo cuando sus dos valores lo sean por lo que si tuviéramos algo así:
 
true && true el resultado es true
 
Recordemos que en JavaScript, ejecuta el código de arriba abajo y de izquierda a derecha, por lo que se leería true y aún tendría que comparar con el segundo valor porque solo devolverá true si ambos lo son, por lo tanto si el primer valor es true debe leer el segundo valor, ya sea false o true para comparar con el primero.
 
¿Pero qué pasa si el primer valor es false?

Pues que ya no comprobará el segundo valor, porque el valor del segundo sea, false o true no modificará el valor que devolverá el operador, porque con tan solo un false el resultado con el operador && es falso, así que JavaScript ignorará el segundo valor.
 
false && false //esto devolverá falso
false && true //esto devolverá falso
true && false //esto devolverá falso
true && true //esto devolverá verdadero
 
Con el comando || pasa igual, pero con sus reglas sabemos que, al comparar dos valores, devolverá true, siempre que al menos uno de estos valores sea true.
 
Por esta razón si el primer valor es false no es determinante, si el segundo valor también es false será falso y si es true será verdadero, pero, si el primer valor es true será verdadero siempre, así que solo se comprobará el segundo valor si el primer valor es false.
 
Por eso recordar:

Si el primer valor es true, verdadero, poco importa el valor del segundo sea cual sea el valor de este el resultado será true, por lo que al igual que como en el caso anterior con el operador &&, en este caso el segundo valor se ignora en JavaScript.
 
false || false //esto devolverá falso
false || true //esto devolverá verdadero
true || false //esto devolverá verdadero
true || true //esto devolverá verdadero
 
El orden de prioridad

Llegados este punto a la hora de hacer operaciones, con más de un operador al igual que en matemáticas, tenemos que tener claro el orden de prioridad de los operadores, por ejemplo en matemáticas se hacen antes las multiplicaciones y las divisiones, después las sumas y restas, en JavaScript es igual, solo que tenemos los operadores lógicos que son los de menor prioridad y dentro de ellos el que menor prioridad es || (or), luego && (and) y a estos dos les seguirían los operadores de comparación y demás, así que como con palabras es un poco tedioso de explicar os dejo aquí debajo una tabla con los operadores y su orden de mayor a menor precedencia.

Hasta aquí hemos llegado, con el repaso de los valores y operadores, como dijimos pueden quedar dudas en este momento, pero resolverlas ahora no sería fácil ni productivo lo mejor es disiparlas conforme las vayamos viendo de nuevo, utilizando y ya tengamos fijados mejor ciertos conceptos, que sin un poco de práctica no sería posible, en el siguiente capítulo nos adentraremos más en JavaScript y usando lo aprendido comenzaremos a crear programas básicos, aún así si tenéis alguna duda hasta este punto, respecto a lo explicado no dudes en preguntar ?

Manuel Castelló (kasmangou)

Temas relacionados: Programación,  kasmangou, JavaScript, Taller 

Reconocimientos y más información sobre la obra gráfica
ADVERTENCIA: En este foro, no se admitirán por ninguna razón el lenguaje soez y las descalificaciones de ningún tipo. Se valorará ante todo la buena educación y el rigor sobre el tema a tratar, así que nos enorgullece reconocer que rechazaremos cualquier comentario fuera de lugar.