En este breve tutorial vamos a ver cuáles son las diferencias entre los tipos primitivos y los objetos en JavaScript. Para empezar, vamos a ver lo que son los tipos primitivos. Seguidamente veremos qué son los objetos y en qué se diferencian.
Introducción
Los tipos primitivos en JavaScript son los siguientes:
- Booleano:
'boolean' - Cadena:
'string' - Número:
'number','bigint' - Símbolo:
'symbol' - Undefined:
'undefined'
Por regla general, todo lo que no sea un tipo primitivo en JavaScript es un objeto de tipo 'object'.
Seguramente te estarás preguntado por qué el tipo null no está en la lista. Esto es debido a que null es de tipo object.
Para obtener el tipo de una variable en JavaScript puedes usar el operador typeof. De hecho, si ejecutas la expresión typeof null verás que el resultado que obtienes es 'object'. Esta es una de las grandes diferencias entre null y undefined, tal y como hemos visto en el tutorial en el que explicábamos las diferencias entre null y undefined.
En cuanto a las funciones, lo cierto es que son de tipo function, aunque sin embargo tampoco hemos incluido este tipo en la lista de tipos primitivos. Esto es debido a que el constructor del tipo function deriva del tipo object.
Diferencias entres tipos primitivos y objetos
A continuación vamos a ver las diferencias más notables entre los tipos primitivos y los objetos:
- Los tipos primitivos siempre se pasan por valor, mientras que los objetos se pasan por referencia.
- Los tipos primitivos se copian por valor mientras que los objetos se copian por referencia.
- Los tipos primitivos se comparan por valor mientras que los objetos se comparan por referencia.
- Los tipos primitivos son inmutables, mientras el único elemento inmutable de un objeto es su referencia, pudiendo modificar su valor.
A continuación vamos a ver algunos ejemplos que validan estas afirmaciones.
Para empezar, vamos a copiar un objeto de tipo primitivo para ver lo que ocurre:
let animal = 'perro';
let mascota = animal;Ahora vamos a cambiar el valor de la variable animal y a ver lo que ocurre con la variable mascota:
animal = 'dinosaurio';
console.log(mascota);El valor que se mostrará por pantalla será 'perro', ya que al trabajar con tipos primitivos, la asignación de valor que hemos hecho al principio se ha hecho por valor y no por referencia. Es decir, que aunque podamos asignar el valor de una variable a otra, estas son totalmente independientes.
Vamos a ver ahora lo que ocurre cuando copiamos un objeto:
let animal = {
especie: 'perro'
}
let mascota = animal;En este ejemplo, la variable mascota apunta al mismo objeto que la variable animal, ya que la asignación se ha hecho por referencia y no por valor. Para demostrarlo, vamos a modificar la propiedad especie:
animal.especie= 'dinosaurio';
console.log(mascota.especie);El valor que se mostrará por pantalla será 'dinosaurio', ya que mascota apuntaba al mismo objeto que animal. Es decir, que en realidad tenemos un solo objeto con dos referencias al mismo. De hecho, si comparamos el objeto animal con el objeto mascota veremos que las variables son idénticas:
if (animal === mascota) {
console.log('Somos el mismo objeto');
}Sin embargo, si definimos dos objetos diferentes, el resultado de la comparación será falso aunque los objetos sean idénticos, ya que tendrán una referencia distinta:
let animal = {
especie: 'perro'
}
let mascota = {
especie: 'dinosaurio'
}
if (animal !== mascota) {
console.log('No somos el mismo objeto');
}Y esto ha sido todo.
Edu Lázaro: Ingeniero técnico en informática, actualmente trabajo como desarrollador web y programador de videojuegos.
