Skip to content
My Docs

Tipos de datos

Tipos de Datos en JavaScript

Definición de Variables y Constantes en JavaScript

Antes de hablar de los tipos de datos, veamos cómo se definen variables y constantes en JavaScript.

1. Variables (var y let)

Para definir variables en JavaScript, se utilizan las palabras clave var o let. Ambas permiten crear una nueva variable, pero hay una diferencia clave entre ellas:

  • var → Tiene ámbito de función (function scoped).
  • let → Tiene ámbito de bloque (block scoped).

En la mayoría de los casos, let es la opción recomendada porque respeta el alcance del bloque en el que se declara, lo que hace que el código sea más predecible.

let nombre = "Carlos"; // Variable con ámbito de bloque
var edad = 25;         // Variable con ámbito de función

2. Constantes (const)

Para definir una constante, usamos la palabra clave const. Una vez que se ha asignado un valor a una constante, este no puede ser reasignado.

const PI = 3.1416; // No se puede cambiar su valor

3. Definir Variables Sin var, let o const (¡Evítalo!)

En algunos lenguajes como Python o PHP, es común definir variables sin palabras clave especiales.

En JavaScript, esto también es posible, pero debes evitarlo, porque crea una variable global automáticamente. Esto puede generar problemas en tu código.

x = 10; // ⚠️ No recomendado: Crea una variable global

✅ Mejor usa let o const para evitar errores:

let x = 10; // Correcto
const y = 20; // Correcto

Variables sin Tipo Fijo

En JavaScript, las variables no tienen un tipo definido. En su lugar, el tipo depende del valor que almacenan en un momento dado.

Ejemplo:

let x = 5;       // x es un número
x = "Hola";      // Ahora x es una cadena (string)

💡 Regla clave: “En JavaScript, las variables no tienen tipos, solo los valores tienen tipos.”

Los 8 Tipos de Datos en JavaScript

JavaScript tiene 8 tipos de datos:

  1. Number
  2. String
  3. Boolean
  4. Object
  5. Function
  6. Undefined
  7. BigInt
  8. Symbol

El Operador typeof

JavaScript proporciona el operador typeof, que permite verificar el tipo de cualquier variable o valor.

Ejemplo:

let x = 42;
let y = "Hola";


console.log(typeof x); // "number"
console.log(typeof y); // "string"

Este operador es muy útil para depurar código y entender el tipo de dato con el que estamos trabajando.

Números en JavaScript

El primer tipo de dato en JavaScript es el número (Number). Dependiendo del lenguaje del que vengas, es posible que la forma en que JavaScript maneja los números te parezca más sencilla.

A diferencia de otros lenguajes que diferencian entre enteros y números de punto flotante, en JavaScript todos los números son del mismo tipo (Number).

Ejemplo:

let x = 5;           // Número entero
let pi = 3.1415;     // Número decimal
let negativo = -10;  // Número negativo

Sin embargo, existe un tipo especial para números extremadamente grandes, llamado BigInt, que veremos más adelante.

Formas de Definir Números en JavaScript

Aunque la notación decimal es la más común, JavaScript permite definir números en distintos formatos:

1. Números en Hexadecimal, Binario y Octal

Desde ES6, se pueden definir números en distintas bases:

let hex = 0x1F;   // 31 en decimal (Hexadecimal, prefijo "0x")
let bin = 0b1010; // 10 en decimal (Binario, prefijo "0b")
let oct = 0o7;    // 7 en decimal (Octal, prefijo "0o")

2. Notación Científica

Para representar números muy grandes o pequeños, se puede usar notación científica:

let grande = 6e7;   // 6 * 10^7 = 60000000
let pequeño = 4e-3; // 4 * 10^-3 = 0.004

Valores Especiales: NaN e Infinity

Existen dos valores especiales en JavaScript relacionados con los números:

1. NaN (Not a Number)

Si intentamos hacer operaciones matemáticas con valores no numéricos, obtenemos NaN:

let resultado = 10 * "Hola"; // NaN
console.log(resultado);      // Output: NaN

💡 NaN es un valor especial que indica un error en una operación matemática. No genera un error en la ejecución, pero significa que algo no salió bien.

2. Infinity y -Infinity

Si realizamos una operación que produce un número demasiado grande o intentamos dividir entre cero, obtenemos Infinity:

console.log(1 / 0);        // Infinity
console.log(-1 / 0);       // -Infinity
console.log(10 ** 999);    // Infinity

⚠️ Tanto NaN como Infinity son considerados números en JavaScript:

console.log(typeof NaN);      // "number"
console.log(typeof Infinity); // "number"

Operaciones Matemáticas en JavaScript

JavaScript permite realizar las operaciones matemáticas básicas:

let suma = 5 + 3;        // 8
let resta = 10 - 4;      // 6
let multiplicacion = 6 * 3; // 18
let division = 10 / 2;   // 5
let modulo = 10 % 3;     // 1 (resto de la división)
let exponente = 2 ** 3;  // 8 (2^3)

Además, JavaScript ofrece el objeto Math, que contiene muchas funciones útiles:

console.log(Math.sqrt(16));  // 4 (raíz cuadrada)
console.log(Math.abs(-10));  // 10 (valor absoluto)
console.log(Math.max(5, 10, 15));  // 15 (mayor valor)
console.log(Math.min(5, 10, 15));  // 5 (menor valor)
console.log(Math.round(4.6)); // 5 (redondeo)
console.log(Math.floor(4.9)); // 4 (redondeo hacia abajo)
console.log(Math.ceil(4.1));  // 5 (redondeo hacia arriba)
console.log(Math.sin(Math.PI / 2)); // 1 (seno de 90°)

Precisión de los Números en JavaScript

1. Todos los Números son de 64 Bits

En JavaScript, todos los números se almacenan como valores de coma flotante de 64 bits según el estándar IEEE 754.

Esto significa que los números grandes pierden precisión después de 15-16 dígitos:

let num = 9999999999999999; // 16 dígitos
console.log(num);  // 10000000000000000 (redondeado)

2. Errores con Decimales

Los números de punto flotante pueden generar errores inesperados:

console.log(0.1 + 0.2); // 0.30000000000000004
console.log(0.3 === 0.1 + 0.2); // false

💡 Solución: Multiplicar por 10 y redondear:

let resultado = Math.round((0.1 + 0.2) * 100) / 100;
console.log(resultado); // 0.3

Resumen numbers

  • JavaScript no distingue entre enteros y flotantes; todos son del tipo Number.
  • Soporta diferentes bases numéricas como decimal, hexadecimal, binario y octal.
  • Existen valores especiales: NaN (resultado inválido) e Infinity (valor fuera de los límites).
  • El objeto Math proporciona funciones matemáticas avanzadas.
  • Los números grandes pierden precisión y los decimales pueden dar errores de cálculo.

Cadenas de Texto (Strings) en JavaScript

Ahora que hemos visto lo fundamental sobre los números en JavaScript, pasemos al siguiente tipo de dato: las cadenas de texto (Strings).

Las cadenas en JavaScript son similares a las de otros lenguajes: simplemente representan una serie de caracteres.

Cómo Definir Cadenas en JavaScript

En JavaScript, una cadena se puede definir utilizando tres tipos de comillas:

1. Comillas Simples y Dobles

let mensaje1 = 'Hola, mundo';  // Comillas simples
let mensaje2 = "Hola, mundo";  // Comillas dobles

Ambas opciones son válidas y no hay diferencia funcional. Lo importante es ser consistente en todo el código.

2. Template Literals (Backticks - ` )

Desde ES6, se pueden usar backticks (`) para definir cadenas.

let nombre = "Ana";
let saludo = `Hola, ${nombre}!`; // Interpolación de variables
console.log(saludo); // Output: Hola, Ana!

💡 Ventaja de los backticks: Permiten interpolación de variables (introducir una variable dentro de un string) y pueden contener saltos de línea sin necesidad de caracteres especiales.

Propiedades y Métodos de Strings

Las cadenas en JavaScript tienen varias propiedades y métodos útiles.

1. Propiedad length (Longitud de la Cadena)

let texto = "JavaScript";
console.log(texto.length); // Output: 10

2. Obtener un Carácter con charAt()

console.log(texto.charAt(3)); // Output: a

3. Convertir a Mayúsculas y Minúsculas

console.log(texto.toUpperCase()); // "JAVASCRIPT"
console.log(texto.toLowerCase()); // "javascript"

4. Otras Funciones Útiles

console.log(texto.includes("Script")); // true (verifica si contiene "Script")
console.log(texto.startsWith("Java")); // true (verifica si empieza con "Java")
console.log(texto.endsWith("Java"));   // false (verifica si termina con "Java")

Uso de Caracteres Especiales en Strings

Algunas veces necesitamos incluir caracteres especiales en una cadena, como comillas o saltos de línea.

1. Uso del Carácter de Escape (\)

Si queremos usar comillas dentro de una cadena definida con las mismas comillas, necesitamos un carácter de escape (\):

let frase = "Ella dijo: \"JavaScript es genial!\"";
console.log(frase);

2. Alternativa: Usar Diferentes Tipos de Comillas

let frase2 = 'Ella dijo: "JavaScript es genial!"';
console.log(frase2);

3. Caracteres Especiales Comunes

SecuenciaSignificado
\nNueva línea
\tTabulación
\\Barra invertida (\)

Ejemplo:

let mensaje = "Línea 1\nLínea 2";
console.log(mensaje);

Output:

Línea 1
Línea 2

Concatenación de Cadenas

1. Usando el Operador +

let saludo = "Hola" + " " + "mundo!";
console.log(saludo); // Output: Hola mundo!

2. Usando el Método .concat()

let parte1 = "Hola";
let parte2 = "mundo!";
console.log(parte1.concat(" ", parte2)); // Output: Hola mundo!

Precauciones al Concatenar Strings con Números

En JavaScript, puedes concatenar cadenas y números sin necesidad de conversión previa:

let edad = 25;
console.log("Tengo " + edad + " años."); // Output: Tengo 25 años.

Sin embargo, el orden de las operaciones importa:

let x = 5;
let y = 8;
console.log("x + y es " + x + y); // Output: "x + y es 58"

💡 ¿Por qué sucede esto? JavaScript evalúa las expresiones de izquierda a derecha.

  • Primero concatena "x + y es " con x → "x + y es 5".
  • Luego concatena con y → "x + y es 58".

✅ Solución: Usar paréntesis para forzar la operación matemática primero:

console.log("x + y es " + (x + y)); // Output: "x + y es 13"

Resumen Strings

  • JavaScript permite definir cadenas con comillas simples, dobles o backticks (`).
  • Se pueden concatenar con + o .concat().
  • Usa \ para caracteres especiales como \", \', \n. -Ten cuidado al concatenar cadenas con números, ya que el orden afecta el resultado.

Valores Booleanos en JavaScript

El tercer tipo de dato en JavaScript es el Booleano (Boolean). Al igual que en la mayoría de los lenguajes de programación, un booleano solo tiene dos valores posibles:

  • true (verdadero)
  • false (falso)

Estos valores pueden ser asignados directamente o generados como resultado de una comparación lógica.

let esMayor = true; // Asignación directa
let resultado = 5 > 3; // Comparación (true)

Uso de Booleanos en la Lógica de Programación

Los valores booleanos son esenciales para controlar el flujo de ejecución en un programa, especialmente con estructuras de control como:

  • if
  • while
  • Operador ternario (condition ? trueValue : falseValue)

Ejemplo con if:

let edad = 18;
if (edad >= 18) {
    console.log("Eres mayor de edad");
} else {
    console.log("Eres menor de edad");
}

Ejemplo con while:

let contador = 0;
while (contador < 3) {
    console.log("Contador:", contador);
    contador++;
}

Ejemplo con operador ternario (condition ? trueValue : falseValue):

let mensaje = edad >= 18 ? "Adulto" : "Menor";
console.log(mensaje); // "Adulto"

Valores “Truthy” y “Falsy” en JavaScript

Aunque solo existen los valores true y false, JavaScript permite convertir otros valores a booleanos.

Existen valores que se consideran “truthy” (se interpretan como true) y otros que son “falsy” (se interpretan como false).

Valores “Falsy” (equivalentes a false)
"" (cadena vacía)
0 (número cero)
NaN (Not a Number)
0n (BigInt con valor cero)
null
undefined
false

Cualquier otro valor en JavaScript es considerado “truthy” y se evalúa como true.

Ejemplo con if y un valor “falsy”:

if ("") {
    console.log("Esto no se ejecuta");
} else {
    console.log("Esto sí se ejecuta"); // Se ejecuta porque "" es falsy
}

Ejemplo con un valor “truthy”:

if ("Hola") {
    console.log("Esto se ejecuta"); // Se ejecuta porque "Hola" es truthy
}

Conversión de Valores a Booleanos

Para verificar cómo un valor se evalúa en términos booleanos, podemos usar la función Boolean() o el operador !!.

console.log(Boolean("Hola"));  // true (truthy)
console.log(Boolean(""));      // false (falsy)
console.log(Boolean(123));     // true (truthy)
console.log(Boolean(0));       // false (falsy)
console.log(Boolean(null));    // false (falsy)
console.log(Boolean(undefined)); // false (falsy)

Otra forma rápida de convertir a booleano es con !! (doble negación lógica):

console.log(!!"Hola");   // true
console.log(!!0);        // false

Resumen Booleans

  • JavaScript solo tiene dos valores booleanos: true y false.
  • Las estructuras de control (if, while, operadores ternarios) dependen de booleanos.
  • Algunos valores se evalúan como “truthy” (equivalentes a true) y otros como “falsy” (false).
  • Puedes convertir cualquier valor a booleano con Boolean(valor) o !!valor.

Objetos en JavaScrip5

Definición de Objetos

Un objeto en JavaScript es una colección de pares clave-valor. Cada clave (o propiedad) está asociada a un valor que puede ser de cualquier tipo de dato en JavaScript, incluyendo números, cadenas, booleanos, funciones e incluso otros objetos.

Ejemplo de Objeto

let persona = {
    nombre: "Carlos",
    edad: 30,
    colorOjos: "marrón"
};

Los objetos en JavaScript son esenciales para organizar y estructurar datos.

Si alguna vez has trabajado con JSON (JavaScript Object Notation), entonces ya has interactuado con objetos de JavaScript.

Acceder a Propiedades de un Objeto

Existen dos formas principales de acceder a las propiedades de un objeto:

1. Notación de punto (.)

console.log(persona.nombre);  // Output: "Carlos"
console.log(persona.edad);    // Output: 30
console.log(persona.colorOjos); // Output: marrón

2. Notación de corchetes ([])

console.log(persona["nombre"]); // Output: "Carlos"
console.log(persona["edad"]);   // Output: 30
console.log(persona["colorOjos"]);  // OUtput: marron

Modificar Propiedades de un Objeto

Podemos cambiar los valores de un objeto después de haberlo definido:

persona.edad = 31;
persona["colorOjos"] = "verde";


console.log(persona.edad); // Output: 31
console.log(persona.colorOjos); // Output: "verde"

También podemos agregar nuevas propiedades dinámicamente:

persona.altura = 1.75;
console.log(persona.altura); // Output: 1.75

O eliminar propiedades usando delete:

delete persona.colorOjos;
console.log(persona.colorOjos); // Output: undefined

Objetos Anidados y Arrays Dentro de Objetos

Los valores de un objeto pueden ser otros objetos o arrays:

let usuario = {
    nombre: "Ana",
    direccion: {
        calle: "Av. Principal",
        ciudad: "Madrid"
    },
    hobbies: ["leer", "correr", "viajar"]
};


console.log(usuario.direccion.calle); // Output: "Av. Principal"
console.log(usuario.hobbies[0]);      // Output: "leer"

Pasar Objetos a Funciones

Cuando pasamos un objeto a una función, se pasa por referencia, por lo que cualquier modificación dentro de la función afectará al objeto original:

function cambiarEdad(persona) {
    persona.edad = 40;
}


let usuario1 = { edad: 25 };
cambiarEdad(usuario1);


console.log(usuario1.edad); // Output: 40

Si queremos evitar esto, podemos pasar una copia del objeto en su lugar:

function cambiarEdadSeguro(persona) {
    let copia = { ...persona };
    copia.edad = 40;
    return copia;
}


let usuario2 = { edad: 25 };
let nuevoUsuario = cambiarEdadSeguro(usuario2);


console.log(usuario2.edad);    // Output: 25
console.log(nuevoUsuario.edad); // Output: 40

Sintaxis Reducida para Crear Objetos

Cuando una propiedad tiene el mismo nombre que una variable, podemos simplificar la sintaxis:

let nombre = "Carlos";
let edad = 30;


// En lugar de:
let persona4 = {
    nombre: nombre,
    edad: edad };


// Podemos escribir directamente:
let persona5 = {
    nombre,
    edad };

Propiedades con Caracteres Especiales

Si una clave tiene caracteres especiales o espacios, debe ir entre comillas:

let empleado2 = { "job-title": "Diseñador UX" };
console.log(empleado2["job-title"]); // Output: "Diseñador UX"

En estos casos, debemos usar la notación de corchetes ([]) para acceder a la propiedad, ya que empleado2.job-title generaría un error.

El Valor null y los Objetos

JavaScript tiene un valor especial llamado null, que se usa para indicar ausencia de datos:

let persona6 = null;
console.log(persona6); // Output: null

Sin embargo, hay una peculiaridad en JavaScript:

console.log(typeof null); // Output: "object" (esto es un error histórico en JS)

Aunque null no es un objeto, JavaScript lo clasifica como tal por razones técnicas.

Resumen Objetos

  • Los objetos en JavaScript son colecciones de pares clave-valor.
  • Se pueden acceder, modificar y eliminar propiedades con . o [].
  • Los objetos se asignan por referencia, lo que significa que modificar uno puede afectar a otros.
  • Se pueden anidar objetos y almacenar arrays dentro de objetos.
  • Podemos usar sintaxis reducida ({ nombre, edad }) cuando las claves y variables tienen el mismo nombre.
  • Propiedades con caracteres especiales requieren comillas y deben accederse con [].
  • null se usa para indicar ausencia de datos, aunque typeof null retorna "object" por un error histórico en JavaScript.

Arrays en JavaScript

¿Qué es un array?

En JavaScript, un array es una colección ordenada de valores, definida normalmente usando corchetes:

let frutas = ["manzana", "banana", "naranja"];

Características:

  • Puede contener cualquier tipo de dato: números, strings, objetos, booleanos, incluso otros arrays.
  • No es necesario que todos los elementos sean del mismo tipo, a diferencia de lenguajes con tipado estático.
let mezcla = [
    42,
    "texto",
    true,
    { nombre: "Ana" },
    [1, 2]
    ];

¿Por qué los arrays no están en la lista de tipos básicos?

Técnicamente, los arrays no son un tipo de dato independiente en JavaScript, sino una forma especializada del tipo object.

Esto se puede verificar con el operador typeof:

let frutas = ["manzana", "banana"];
console.log(typeof frutas); // "object"

💡 Aunque esto suele ser solo un detalle técnico, conviene tenerlo presente para evitar confusiones puntuales.

Acceder y modificar elementos

Los elementos de un array se acceden por su índice, que empieza en 0:

console.log(frutas[0]); // "manzana"

Se pueden modificar fácilmente:

frutas[1] = "pera";
console.log(frutas); // ["manzana", "pera", "naranja"]

Propiedad .length

Todos los arrays tienen una propiedad .length que indica cuántos elementos contiene:

console.log(frutas.length); // 3

Métodos comunes de los arrays

JavaScript incluye muchos métodos incorporados para trabajar con arrays. Algunos de los más usados son:

MétodoDescripción
.push()Añade un elemento al final
.pop()Elimina y retorna el último elemento
.indexOf()Retorna el índice de un elemento (o -1 si no existe)
.map()Crea un nuevo array aplicando una función a cada elemento
.filter()Crea un nuevo array con los elementos que cumplen una condición
.sort()Ordena los elementos del array

¿Usar coma final (trailing comma) en arrays y objetos?

Las comas finales (también llamadas trailing commas) pueden ser útiles al añadir nuevos elementos, parámetros o propiedades en código JavaScript.

let frutas = [
  "manzana",
  "pera",
  "naranja", // ← coma final
];

Si deseas agregar una nueva propiedad, puedes simplemente añadir una nueva línea sin tener que modificar la última línea anterior, siempre que esa línea ya tenga una coma final. Esto hace que las diferencias en el control de versiones (diffs) sean más limpias y que editar el código sea menos problemático.

JavaScript permite comas finales en literales de arrays desde sus inicios. Actualmente, también se permiten en:

  • Literales de objetos,
  • Parámetros de funciones,
  • Importaciones con nombre (named imports),
  • Exportaciones con nombre (named exports), y más. ⚠️ Sin embargo, JSON no permite comas finales bajo ninguna circunstancia.

Resumen arrays

  • Los arrays son colecciones ordenadas de elementos.
  • Pueden contener cualquier tipo de dato y elementos de tipos mezclados.
  • Aunque son técnicamente objetos, su comportamiento es muy específico.
  • Disponen de métodos potentes para manipulación avanzada de datos.
  • Usar comas finales es opcional, pero recomendable para evitar errores de sintaxis.

Funciones en JavaScript

¿Qué es una función?

Una función en JavaScript es un bloque reutilizable de código que puede:

  • Recibir argumentos (parámetros)
  • Devolver un valor (opcional)
function saludar(nombre) {
  return "Hola, " + nombre;
}

Una función puede no recibir parámetros, o no devolver nada, dependiendo del caso de uso.

¿Diferencias con otros lenguajes?

A diferencia de lenguajes como Java, en JavaScript las funciones no necesitan pertenecer a una clase u objeto. Pueden definirse de forma independiente:

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


add(2, 3); // Output: 5

Formas de definir funciones

JavaScript permite múltiples formas de definir funciones:

1. Declaración de función

function sumar(x, y) {
  return x + y;
}

Estas funciones son “hoisting-friendly”

2. Otro modo de declarar una función

let suma = function(x, y) {
  return x + y;
};

Estas no se pueden usar antes de ser declaradas.

3. Arrow functions (Funciones flecha)

Introducidas en ES6, son una forma más corta de escribir funciones:

let suma = (a, b) => a + b;

También pueden tener cuerpo con {} y usar return:

let suma = (a, b) => {
  return a + b;
};

Llamar a una función

Para ejecutar una función, simplemente se escribe su nombre seguido de paréntesis:

sumar(2, 3); // Llama a la función 'sumar' con los argumentos 2 y 3

Si la función no necesita argumentos:

saludar(); // Llama a la función sin argumentos

Resumen de funciones

  • Las funciones son bloques reutilizables de código.
  • Pueden definirse con function, como expresiones (let f = function()) o con arrow functions (=>).
  • Solo las funciones definidas con function son “hoisted”.
  • Se llaman usando nombreFuncion() con o sin argumentos.
  • Las funciones pueden o no devolver un valor (return es opcional).

Tipo de dato undefined en JavaScript

El tipo de dato undefined es algo peculiar y único en JavaScript. Lo encontrarás en varios contextos, pero casi siempre significa que:

  • Una variable no existe, o
  • Ha sido declarada pero aún no se le ha asignado un valor.

Ejemplos comunes

let x;
console.log(x); // undefined (declarada pero no asignada)


console.log(typeof noExiste); // "undefined" (la variable no existe)


let persona = {};
console.log(persona.edad); // undefined (la propiedad no existe)


let frutas = ["manzana"];
console.log(frutas[3]); // undefined (índice fuera de rango)


function saludar() {
  console.log("Hola");
}
console.log(saludar()); // undefined (no tiene return)

¿Cuál es la diferencia entre undefined y null?

Es una pregunta común al aprender JavaScript. Aquí tienes una tabla comparativa clara:

Característicaundefinednull
¿Qué significa?Variable no declarada o no inicializadaValor intencionalmente vacío o desconocido
¿Lo asigna el programador?❌ No siempre (JS lo asigna automáticamente)✅ Sí, se asigna explícitamente
Tipo (typeof)"undefined""object" (❗ detalle técnico confuso en JS)
Usos comunesVariable sin valor asignado, acceso inexistenteAusencia de valor conocida (ej: edad no proporcionada)

Ejemplo para entender null

let edadUsuario = null;
// Sabemos que la edad existe, pero no ha sido proporcionada aún

Ejemplo de uso de undefined automáticamente

let nombre;
console.log(nombre); // undefined

Consideraciones importantes

  • undefined es el valor por defecto de una variable declarada pero no inicializada.
  • null se usa cuando queremos decir explícitamente que un valor está ausente.
  • Aunque ambos representan “falta de valor”, su uso y comportamiento es distinto.
  • En funciones con valores por defecto, pasar undefined usará el valor por defecto, mientras que pasar null no lo hará.
function saludar(nombre = "Invitado") {
  console.log("Hola, " + nombre);
}


saludar(undefined); // Hola, Invitado ✅
saludar(null);      // Hola, null ❌

Resumen undefined

  • undefined = variable vacía sin valor asignado aún.
  • null = valor intencionalmente vacío.
  • Ambos tienen usos distintos y son fundamentales en JavaScript.
  • Conocer sus diferencias mejora tu comprensión del flujo de datos y validación en tu código.

BigInt en JavaScript

Hasta ahora hemos hablado de:

  • Números (Number)
  • Cadenas (String)
  • Booleanos (Boolean)
  • Objetos (incluidos Arrays, null, funciones y undefined)

Ahora es momento de conocer un tipo de dato menos común pero muy útil: BigInt

¿Qué es BigInt?

BigInt es un tipo de dato que permite trabajar con números enteros extremadamente grandes, sin perder precisión.

Fue introducido porque el tipo Number en JavaScript tiene límites de precisión:

  • A partir de 15-16 dígitos, los números pueden dejar de ser precisos.

¿Cómo se declara un BigInt?

Simplemente añadiendo una n al final del número:

const numeroGrande = 9007199254740991n; // Esto es un BigInt

También puedes usar el constructor:

const otroBigInt = BigInt("123456789012345678901234567890");

¿Qué puedes hacer con BigInt?

Puedes realizar operaciones matemáticas básicas:

const a = 1000n;
const b = 2000n;


console.log(a + b); // 3000n
console.log(b - a); // 1000n
console.log(a * b); // 2000000n
console.log(b / a); // 2n (¡sin decimales!)

Cosas a tener en cuenta

1. No puedes mezclar Number y BigInt directamente

const a = 10n;
const b = 2;


console.log(a + b); // ❌ Error: No puedes mezclar bigInt con otros tipos de datos.

Solución:

console.log(a + BigInt(b)); // ✅ 12n

2. No hay decimales

Cualquier operación que debería devolver un decimal, se redondea hacia abajo:

console.log(10n / 3n); // 3n
console.log(5n / 2n);  // 2n

3. Puedes usarlo con otros formatos numéricos

const bigBinary = 0b1010n;     // binario
const bigHex = 0x1ffn;  // hexadecimal
const bigOctal = 0o777n;        // octal

¿Cuándo usar BigInt?

Aunque no es común en aplicaciones del día a día, es muy útil en casos donde la precisión en grandes enteros es esencial, como:

  • Criptografía
  • Cálculos científicos
  • Finanzas de alta precisión
  • Manipulación de IDs grandes (como en bases de datos)

Resumen BigInt

CaracterísticaBigInt
Precisión para números grandes✅ Sí, sin límites prácticos
Mezcla con Number❌ No, debe hacerse conversión manual
Decimales❌ No, los trunca
Declaración123n o BigInt("123")
Uso típicoCriptografía, datos financieros

Symbol en JavaScript

El último tipo de dato que veremos en este curso es Symbol.

Es probablemente uno de los menos intuitivos de todos los tipos primitivos en JavaScript, pero puede ser muy útil en ciertos casos avanzados.

¿Qué es un Symbol?

Un Symbol es un valor único e inmutable. Su propósito principal es crear identificadores únicos que no se pueden duplicar accidentalmente, incluso si usan la misma descripción.

¿Cómo se crea un símbolo?

Usando el constructor Symbol():

const id = Symbol("descripcion opcional");
  • La cadena que pasamos es una descripción (solo para depuración).
  • Podemos omitirla si queremos.

Importante:

  • Incluso si dos símbolos tienen la misma descripción, no son iguales.
const a = Symbol("clave");
const b = Symbol("clave");


console.log(a === b); // ❌ false

La única forma de que dos símbolos sean iguales es que sean exactamente la misma referencia.

Símbolos globales: Symbol.for()

Existe otra forma de crear símbolos: registrarlos globalmente mediante Symbol.for():

const s1 = Symbol.for("usuarioID");
const s2 = Symbol.for("usuarioID");


console.log(s1 === s2); // ✅ true

En este caso, se accede a la misma entrada dentro de un registro global. Esto permite reutilizar símbolos entre distintas partes de la aplicación.

¿Para qué sirven los símbolos?

Uno de sus usos más útiles es evitar conflictos de nombres cuando agregamos propiedades a objetos.

⚠️ Problema clásico:

const camisa = {
  talla: "M"
};


camisa.talla = 11; // ❗ Esto sobrescribe el valor original

✅ Solución con Symbol:

const TALLA_OCULTA = Symbol("tallaInterna");


camisa[TALLA_OCULTA] = 11; // No interfiere con 'camisa.talla'

Así evitamos colisiones de propiedades, ya que Symbol garantiza que la clave sea única.

¿Cuándo usar Symbol?

  • Cuando quieres garantizar unicidad.
  • Para crear propiedades ocultas o privadas en objetos.
  • En librerías o APIs para evitar conflictos de nombres.

Recuerda esto:

  • Los Symbol existen para cuando necesitas claves únicas dentro de tu código.

Resumen Symbol

CaracterísticaSymbol
Tipo de datoPrimitivo
PropósitoClaves únicas
Descripción opcional✅ Solo para depuración
ComparaciónSymbol("a") !== Symbol("a")
Reutilización global✅ con Symbol.for()
Uso comúnPropiedades ocultas/seguras
AvanzadoSí, poco común en código básico