Tipos de datos en JavaScript

En JavaScript, todo lo que manejamos, un nombre, una edad, una lista de usuarios, una función tiene un “tipo”. Entender los tipos de datos es como aprender los diferentes tipos de ingredientes que tienes en una cocina. Cada uno se comporta de una manera única, y saber cómo usarlos y combinarlos es esencial para crear cualquier aplicación.

Conocer el Tipo de Dato en JavaScript

JavaScript es un lenguaje de tipado dinámico, lo que significa que una misma variable puede contener diferentes tipos de datos a lo largo del tiempo.

let data = "Hola";    // La variable es un string
data = 50;            // Ahora es un number
data = true;         // Ahora es un boolean

Esta flexibilidad es poderosa, pero también exige que sepamos qué tipo de dato estamos manejando en cada momento. Para ello, usamos el operador typeof:

let score = 10;
console.log(typeof(score));

score = false; 
console.log(typeof(score));

score = "Hi";
console.log(typeof(score));

Los tipos de datos en JavaScript se dividen en dos grandes familias: Tipos Primitivos y Tipos de Referencia (Objetos). Su diferencia es una de las ideas más importantes del lenguaje.

Tipos de Datos Primitivos

Los tipos primitivos son los datos más simples e indivisibles. Piensa en ellos como ladrillos: son unidades sólidas y fundamentales.

Una característica clave de los primitivos es que son inmutables: no puedes cambiar el valor en sí mismo una vez creado. Si “modificas” una variable primitiva, lo que realmente sucede es que JavaScript crea un valor nuevo y lo asigna a la variable.

Existen 7 tipos primitivos:

1. string (Cadena de texto)

El tipo de dato string o cadena se utiliza para representar una secuencia de caracteres y es uno de los tipos de datos más utilizados en JavaScript. Este tipo se define con comillas simples (‘), dobles (“) o acentos graves (`) para template literals.

const saludo = "Hola";
const nombre = 'Mundo';
const mensaje = `Hola, ${nombre}!`;  // Template literal

console.log(mensaje);

2. number (Número)

El tipo de dato number incluye tanto números enteros como números decimales. En JavaScript no hay distinción entre números enteros e índices flotantes.

const entero = 42;
const decimal = 3.14;
const negativo = -10;

Incluye valores especiales como Infinity, -Infinity y NaN (Not a Number), que suele aparecer como resultado de una operación matemática inválida.

console.log(10 / 0);       // Infinity
console.log("hola" * 2);   // NaN

3. boolean (Booleano)

El tipo de dato boolean representa un valor lógico que puede ser true o false (verdadero / falso). Es comúnmente utilizado en condiciones y comparaciones.

const isLoggedIn = true;
const hasPermission = false;

console.log(isLoggedIn);
console.log(hasPermission);

Es importante destacar que en JavaScript algunos valores se consideran “falsy” o equivalentes a false cuando se evalúan en un contexto booleano. Estos incluyen 0, -0, null, false, NaN, undefined y un string vacio "".

Por otro lado, todos los demás valores se consideran “truthy” o equivalentes a true, incluyendo objetos, arreglos y cadenas no vacías.

4. undefined (Tipo Indefinido)

Representa la ausencia de un valor. Una variable que ha sido declarada pero no inicializada tiene el valor undefined por defecto. Es el estado “accidental” de vacío.

let userEmail;
console.log(userEmail);

5. null (Nulo)

También representa la ausencia de un valor, pero de forma intencional. Cuando un desarrollador asigna null a una variable, está diciendo explícitamente: “esta variable existe, pero no apunta a ningún objeto o valor”. Es el estado “intencional” de vacío.

let score = null;

if (score === null) {
  console.log('Aun no tienes un score iniciado');
} else {
  console.log("Tu score es " + score);
}

Dato curioso: typeof null devuelve “object”. Este es un error histórico en JavaScript que se ha mantenido por retrocompatibilidad.

6. Symbol (Símbolo)

Un tipo de dato único e inmutable, usado principalmente para crear identificadores únicos para las propiedades de los objetos, evitando colisiones de nombres.

let id1 = Symbol("id");
let id2 = Symbol("id");

console.log(id1 === id2);

La función Symbol() crea un nuevo valor único cada vez que se llama. Por lo tanto si intentamos comparar sus valores, obtendremos el valor booleano false:

console.log(Symbol() == Symbol());

7. Tipo Bigint

Para representar números enteros extremadamente grandes que el tipo number no puede manejar de forma segura. Se crean añadiendo una n al final.

let pageView = 9007199254740991n;

console.log(typeof(pageView));

Tipos de Datos de Referencia (Objetos)

Si los primitivos son ladrillos, los tipos de referencia son planos de construcción. No contienen el valor directamente, sino una referencia (una dirección en la memoria) a donde se encuentra el valor.

Todos los tipos de referencia son técnicamente de tipo object. Son estructuras complejas y mutables que pueden contener colecciones de datos y funcionalidades.

object (Objeto Literal)

let persona = {
  nombre: "Juan",
  edad: 30,
  saludar: function() {
    console.log("Hola, soy " + this.nombre);
  }
};

persona.saludar();

function (Función)

En JavaScript, las funciones también son un tipo de objeto. Esto les permite ser almacenadas en variables, pasadas como argumentos y devueltas por otras funciones (lo que se conoce como “ciudadanos de primera clase“).

function sumar(a, b) {
    return a + b;
}

console.log(sumar(5, 3));

array (Arreglo)

Un tipo especial de objeto usado para almacenar listas ordenadas de valores.

const tags = ["javascript", "webdev", "coding"];

Date (Fechas)

El objeto Date se utiliza para trabajar con fechas y horas.

const hoy = new Date();

console.log(hoy.toDateString());

Diferencias Entre Tipos Primitivos y Referenciados

Este es el concepto más importante que debes entender.

Asignación de Primitivos (Copia por Valor)

Cuando asignas una variable primitiva a otra, se copia el valor. Son dos variables independientes con dos valores idénticos.

(Analogía: Le sacas una fotocopia a un documento.)

let a = 100;
let b = a; // 'b' obtiene una COPIA del valor de 'a'.

console.log(a, b); // 100, 100

// Si cambiamos 'a', 'b' no se ve afectada.
a = 200;
console.log(a, b); // 200, 100

Asignación de Referencias (Copia por Referencia)

Cuando asignas una variable de referencia a otra, se copia la referencia (la dirección), no el objeto en sí. Ambas variables ahora apuntan al mismo objeto en la memoria.

let user1 = { name: "David" };
let user2 = user1; // 'user2' obtiene una COPIA de la dirección de 'user1'.

console.log(user1.name, user2.name); // "David", "David"

// Si cambiamos el objeto a través de 'user2'...
user2.name = "Eva";

// ...el cambio se refleja en 'user1' porque ambos apuntan al MISMO objeto.
console.log(user1.name, user2.name); // "Eva", "Eva"

Comprender esta diferencia es vital para evitar errores inesperados al trabajar con objetos y arrays, especialmente al pasarlos a funciones.

Conversión entre tipos de datos

Una de las potentes características de JavaScript es su capacidad para convertir entre distintos tipos de datos. Esto puede hacerse utilizando las funciones de conversión incorporadas, como Number(), String() y Boolean().

Estas funciones pueden utilizarse para convertir un valor de un tipo de datos en un valor de un tipo de datos diferente sin cambiar los datos subyacentes. Pero de esto hablamos en profundidad en otros tutoriales.

Conclusión Tipos de Datos

Dominar los tipos de datos en JavaScript y sobre todo, la distinción entre primitivos (por valor) y objetos (por referencia), te dará una base sólida para construir cualquier lógica. Te permitirá manipular la información de forma correcta, evitar bugs comunes y escribir código más robusto y predecible. Ahora que conoces los “ingredientes”, estás listo para empezar a “cocinar” aplicaciones más complejas.

En el siguiente artículo nos sumergiremos en el manejo de números en JavaScript, abordando operaciones matemáticas y trucos para trabajar con precisión.