En el artículo de ¿Por qué JS es de tipado débil y dinámico? Ya vimos dos características bastante importantes de entender en lo referente a como funcionan los tipos de datos en JavaScript que son: el tipado débil y el tipado dinámico.

Estas dos características (tipado débil y dinámico) nos permiten no tener que definir el tipo de dato que almacenaremos dentro de una variable (no debe ser ninguno en específico sino que utilizamos let o var simplemente para todo) ya que a lo que a lo largo del transcurso de nuestro código esta variable puede ir modificando el tipo de dato que almacena tantas veces como queramos y con diferentes tipos de datos. Muestra de ello era que usábamos typeof para comprobar el tipo de dato.

En esta lección, vamos a hablar más al detalle sobre los tipos de datos. Los tipos de datos en JavaScript parecen sencillos y simples, pero tener una idea de cómo funcionan es esencial para poder trabajar con ellos de una manera correcta.

¿Qué son los tipos?

Con tipos nos referimos a un conjunto de valores de un determinado tipo en concreto. Por ejemplo, el tipo boolean engloba el conjunto de valores {true, false}

¿Cómo se subdividen los tipos?

Los tipos de datos se subdividen en:

  • Tipos primitivos.
  • Tipos no primitivos.

En este artículo, abordaremos únicamente los tipos de datos primitivos.

A lo largo de la evolución de versiones de JS, ya hemos visto que las distintas versiones han ido implementando nuevos cambios. Una muestra de ello, es que los datos primitivos han ido aumentado con las distintas versiones de EcmaScript. Un claro ejemplo de ello es que si miramos los tipos primitivos de la imagen superior y la inferior podemos ver que en las últimas versiones que ha sacado EcmaScript se han añadido también algunos tipos de datos.

Tipos primitivos:

Vamos a ver un ejemplo de cada uno:

→ string: el tipo de dato string almacena cadenas de texto. Un string, realmente es un conjunto de caracteres. Cada uno de estos caracteres de la cadena ocupa una posición dentro índice de la cadena, el primer elemento ocupará siempre el elemento 0 del índice. Los escribimos entre comillas, simples (‘) o dobles (“).

→ number:  engloba los números positivos hasta +9007199254740991 y negativos hasta -9007199254740991. Entre estos números también son incluidos los números decimales separados por un punto. Si por ejemplo, dividimos un número entre una cadena de texto, podemos ver que el typeof arroja NaN. Esto se produce debido a que esta operación no se puede realizar y el tipo que imprimirá será NaN ya que dividir 5 entre una cadena de texto aparte de que no se posible realizar dicha división como es lógico tampoco arrojará un tipo número. Por ello, muestra NaN

NaN → Not a Number

El número máximo y mínimo que podemos alcanzar con tipo number es:

→ bigInt: es el tipo de número más grande de JavaScript. Puede representar valores superiores e inferiores a los del rango de los tipos number anteriores (incluidos valores decimales). También se puede utilizar para almacenar números que están dentro del rango de los tipos number.

→ boolean: El tipo booleano, es un valor lógico que tiene únicamente nos ofrece dos posibles valores: verdadero y falso.

→ symbol (nuevo en ECMAScript 6): el tipo de dato symbol, lo usaremos para crear identificadores únicos para objetos. Con ello, queremos decir, que cada objeto será único (concepto de singleton) y si creamos dos objetos y comparamos sus tipos el resultado que nos arrojará el console.log será true ya que ambos son de tipo symbol. En caso de comparar los dos objetos (pese a que contienen lo mismo) vemos que el resultado es false.

De hecho, hasta si creamos dos objetos sin añadirle valor, podemos ver que el resultado con ambos operadores es false y false:

→ undefined: el tipo de dato undefined, nos sirve saber que tenemos variables sin valores asignados.

→ null: es el tipo de dato más complicados de entender. Ya que, pese a que null es un tipo de datos primitivo, cuando se hace un typeof de un tipo null, la consola nos devolverá “object “.

Podemos asignar el valor null a cualquier variable, lo que básicamente significa que está en blanco. Pero tenemos que declararlo nosotros (lo que se conoce como que el programador tiene una intencionalidad → tener una intención) ya que por defecto si no especificamos valor, el valor por defecto será undefined (tal y como hemos visto en el tipo de dato anterior).

Null apunta a un objeto (nulo, dirección inexistente, inválido). Por lo que cuando hacemos el typeof mostrará object aunque es un objeto de tipo null.

Lo más recomendable es no utilizar este tipo de dato primitivo. Ya que nos podemos encontrar con muchos problemas. Vamos a ver algunos de ellos:

Comparando null VS null

Para comparar si es null un tipo de dato, no podemos hacer un typeof como hasta ahora, ya que este, nos devuelve que es de tipo object. Para analizar si el valor de una variable es null, en este caso, podemos utilizar la comparación de tipo de dato == (compara si el valor es igual) y de === (compara valor y tipo de dato) y enfretarlo contra null o contra un valor que sepamos que es null. En este caso, al ser literalmente iguales tanto en valor como en tipo ambos resultados devuelven true.

Comparando undefined VS null

Hay que tener mucho cuidado con el operador que utilizamos cuando enfrentemos un tipo de dato null vs un tipo de dato undefined. Ya que, si comparamos un tipo de dato null con uno undefined según el tipo de operador que utilicemos en dicha comparación podremos ver el resultado es uno u otro.

Si el operador == (compara si el valor es igual) nos imprimirá true. Ya que null es vacío y undifined equivaldría a no definido y entonces, JavaScript interpreta que ambos son relativamente iguales al representar un valor vacío devolviéndonos un true.

Pero en cambio, si comparamos con el operador === (compara valor y tipo de dato) vemos que da false porque como ya hemos visto, aunque en valor para JavaScript sería el mismo (la ausencia de valor), también estamos comparando por tipo de dato y null vs undefined no son iguales por lo que el resultado arrojado será un false.

JavaScript no se lleva “muy bien” con los null, así que, es mejor no declararlos y trabajar directamente con valores undefined.

Espero que os hayan quedado un poco más claros los distintos tipos de datos primitivos ya que esta información nos puede ser de utilizan para trabajar sobre otros aspectos en JavaScript ¡Un saludo!