Tipos de datos en JavaScript explicados

Curso de Fundamentos de JavaScript

Contenido del curso

No sé dónde empezar

Fundamentos Javascript

Funciones, Scope y Estructuras de Datos

DOM y Experiencia en el Navegador

Modulos y Asincronía

Tomar examen

Tipos de datos en JavaScript explicados

Resumen

Cuando declaras una variable en JavaScript, le estás asignando un tipo de dato específico que define qué puede contener y cómo se comporta. Conocer los tipos de datos primitivos y complejos es la base para escribir código sólido, evitar errores silenciosos y entender por qué el lenguaje se comporta como lo hace en ciertos casos famosos, como el del null.

Esta guía es para ti si estás empezando con JavaScript y quieres dominar la diferencia entre un string, un number, un boolean y estructuras más robustas como objetos, arrays y funciones.

¿Cuáles son los 7 tipos de datos primitivos en JavaScript?

Los primitivos son representaciones de datos simples, valores únicos que puedes asignar directamente a una variable. JavaScript reconoce siete [01:00]:

String: cadenas de texto, como "Hola".
Number: valores numéricos, como 42.
Boolean: dos estados posibles, true o false.
Null: ausencia intencional de valor.
Undefined: variable declarada sin valor asignado.
Symbol: identificadores únicos.
BigInt: números demasiado grandes para el tipo number.

¿Cómo se declaran los primitivos en código?

La mejor práctica es empezar con const, salvo que necesites reasignar el valor más adelante; en ese caso usa let. Así se ve cada uno [02:30]:

javascript // Tipo de datos primitivos const texto = "Hola"; const numero = 42; const booleano = true; const nulo = null; const indefinido = undefined; const simbolo = Symbol("id"); const granNumero = 123n;

Fíjate en un detalle: si escribes "42" entre comillas, ya no es un número, es un string. Tu editor te ayuda con colores distintos para que reconozcas visualmente cada tipo.

¿Para qué sirve Symbol en JavaScript? Es un tipo de dato que crea identificadores únicos. Lo usarás cuando trabajes con aplicaciones más robustas y necesites asignar IDs irrepetibles a piezas de código.

¿Cómo verifico el tipo de dato de una variable?

Usas la palabra reservada typeof antes de la variable y lo imprimes con console.log [05:00]:

javascript console.log(typeof texto); // string console.log(typeof numero); // number console.log(typeof booleano); // boolean console.log(typeof nulo); // object ← ojo aquí console.log(typeof indefinido); // undefined console.log(typeof simbolo); // symbol console.log(typeof granNumero); // bigint

¿Por qué typeof null devuelve object en JavaScript?

Aquí viene lo interesante. Cuando ejecutas typeof null, JavaScript responde object, y eso confunde a cualquiera que esté empezando.

Es un error histórico del lenguaje. En las primeras implementaciones de JavaScript, null se representaba como un puntero nulo y quedó clasificado junto con los objetos. La comunidad lo reconoce como un bug, pero no se ha corregido por compatibilidad: arreglarlo rompería incontables aplicaciones construidas desde el nacimiento del lenguaje.

Conceptualmente, null no es un objeto. Es la ausencia intencional de un valor, distinta de undefined, que indica que una variable nunca recibió valor.

¿Cuál es la diferencia entre null y undefined? null lo asignas tú a propósito para indicar vacío. undefined lo asigna JavaScript automáticamente cuando declaras una variable sin valor.

¿Qué son los tipos de datos complejos en JavaScript?

Los complejos agrupan múltiples valores o comportamientos en una sola estructura. Son tres [07:30]:

Object: colecciones de pares clave-valor.
Array: listas ordenadas de elementos.
Function: bloques de código reutilizables.

Así los declaras:

javascript // Tipos complejos const persona = { nombre: "Juan", edad: 30 }; const numeros = [1, 2, 3, "texto"]; const miFuncion = function() { // lógica aquí };

Un objeto puede mezclar strings y numbers dentro de sus propiedades. Un array también puede contener distintos tipos de datos en la misma lista. Y una función encapsula instrucciones que ejecutas cuando la llamas.

¿Qué cuidados debo tener con los nombres de variables?

Dos reglas que te van a ahorrar dolores de cabeza:

No uses palabras reservadas como nombre de variable. Si intentas llamar function a una constante, JavaScript te lanzará un error.
JavaScript distingue mayúsculas y minúsculas. miVariable y MiVariable son dos cosas distintas.

Los comentarios también son tu aliado. Con // dejas notas que JavaScript ignora, pero que ayudan a cualquier compañero (o a ti mismo en seis meses) a entender qué hace el código.

¿Ya practicaste declarando tus propias variables con cada tipo? Cuéntame en los comentarios cuál fue el tipo de dato que más te costó identificar y cómo resolviste el reto.

Steven Andres Moreno Melendez

Estudiante

// ============================================
// Reto: Tipos de datos en JavaScript
// ============================================
// Completa cada función según las instrucciones.
// Ejecuta los tests con: npx vitest src/02-tipos-de-datos
// ============================================

// --- Reto 1: Identificar tipos primitivos ---
// Declara las siguientes constantes con los valores indicados:
//   texto = "hola"
//   numero = 42
//   booleano = true
//   nulo = null
//   indefinido = undefined
//   simbolo = Symbol("id")
//   grande = 123n
// Retorna un objeto con el typeof de cada una:
//   { texto, numero, booleano, nulo, indefinido, simbolo, grande }
// donde cada valor es el resultado de typeof sobre la variable.
function identificarPrimitivos() {
    const texto = "hola";
    const numero = 42;
    const booleano = true;
    const nulo = null;
    const indefinido = undefined;
    const simbolo = Symbol("id");
    const grande = 123n;
    return { texto: typeof texto, numero: typeof numero, booleano: typeof booleano, nulo: typeof nulo, indefinido: typeof undefined, simbolo: typeof simbolo, grande: typeof grande };
}
// --- Reto 2: Diferenciar string y number ---
// Recibe un parámetro "valor".
// Retorna un objeto con:
//   { tipo: typeof valor, esString: true/false, esNumber: true/false }
function diferenciarStringNumber(valor) {
    return { tipo: typeof valor, esString: typeof valor === "string", esNumber: typeof valor === "number" };
    // Tu código aquí
}

// --- Reto 3: El caso especial de null ---
// Declara una constante "nulo" con valor null.
// Retorna un objeto con:
//   { valor: nulo, tipo: typeof nulo, esNull: true/false }
// Pista: typeof null devuelve "object", pero debes verificar
// si realmente es null usando una comparación estricta (===).
function explorarNull() {
    const nulo = null;
    return { valor: nulo, tipo: typeof nulo, esNull: nulo === null };
    // Tu código aquí
}


// --- Reto 4: Undefined vs Null ---
// Declara una variable con let llamada "sinAsignar" (sin asignarle valor).
// Declara una constante "vacio" con valor null.
// Retorna un objeto con:
//   { sinAsignar, vacio, tipoSinAsignar: typeof sinAsignar, tipoVacio: typeof vacio, sonIguales: sinAsignar == vacio, sonEstrictamenteIguales: sinAsignar === vacio }
function compararNullUndefined() {
    let sinAsignar = undefined;
    const vacio = null;
    return { sinAsignar, vacio, tipoSinAsignar: typeof sinAsignar, tipoVacio: typeof vacio, sonIguales: sinAsignar == vacio, sonEstrictamenteIguales: sinAsignar === vacio };
    // Tu código aquí
}

// --- Reto 5: Symbol y BigInt ---
// Crea un Symbol con la descripción "miID".
// Crea un BigInt con el valor 9007199254740991n.
// Retorna un objeto con:
//   { tipoSymbol: typeof del symbol, tipoBigInt: typeof del bigint, descripcionSymbol: symbol.description, valorBigInt: el bigint creado }
function crearSymbolYBigInt() {
    const misimbolo = Symbol("miID");
    const miNumeroGrande = 9007199254740991n;
    return { tipoSymbol: typeof misimbolo, tipoBigInt: typeof miNumeroGrande, descripcionSymbol: misimbolo.description, valorBigInt: miNumeroGrande }
    // Tu código aquí
}

// --- Reto 6: Crear un objeto ---
// Crea un objeto "persona" con las propiedades:
//   nombre (string): "Juan"
//   edad (number): 42
//   activo (boolean): true
// Retorna un objeto con:
//   { persona, tipoPersona: typeof persona, propiedades: Object.keys(persona) }
function crearObjeto() {
    const persona = { nombre: "Juan", edad: 42, activo: true };
    return {persona, tipoPersona: typeof persona, propiedades: Object.keys(persona)};
    // Tu código aquí
}

// --- Reto 7: Trabajar con arrays ---
// Crea un arreglo "mezcla" con los valores: 1, "dos", true, null
// Retorna un objeto con:
//   { arreglo: mezcla, esArreglo: Array.isArray(mezcla), largo: mezcla.length, tipos: [typeof de cada elemento] }
function trabajarConArreglos() {
    const mezcla = [1,"dos", true, null];
    return{arreglo:mezcla, esArreglo: Array.isArray(mezcla), largo: mezcla.length, tipos: [typeof mezcla[0], typeof mezcla[1], typeof mezcla[2], typeof mezcla[3]]};

    // Tu código aquí
}

// --- Reto 8: Funciones como valor ---
// Crea una constante "saludar" que sea una función que reciba un nombre
// y retorne "Hola, {nombre}!".
// Retorna un objeto con:
//   { tipoFuncion: typeof saludar, resultado: saludar("JavaScript") }
function funcionComoValor() {
   const saludar = function(nombre) {
    return "Hola, " + nombre + "!"
   }; // Tu código aquí
   return {tipoFuncion: typeof saludar, resultado: saludar("JavaScript")}
}

// --- Reto 9: Clasificar tipo de dato ---
// Recibe un parámetro "valor".
// Determina si es primitivo o complejo y retorna un objeto con:
//   { valor, tipo: typeof valor, clasificacion: "primitivo" | "complejo" }
// Reglas:
//   - Si es null, clasificación es "primitivo" (a pesar de typeof).
//   - Si typeof es "object" o "function", clasificación es "complejo".
//   - En cualquier otro caso, clasificación es "primitivo".
// Pista: primero verifica si es null, luego revisa typeof.
function clasificarTipo(valor) {
    let clasificacion ="";
    if (valor === null) {
        clasificacion = "primitivo";
    }
    else if (typeof valor === "object"|| typeof valor === "function"){
        clasificacion= "complejo";
    }
    else {
        clasificacion = "primitivo";
    }
    return {valor: valor, tipo: typeof valor, clasificacion: clasificacion};
    }
    // Tu código aquí

module.exports = {
    identificarPrimitivos,
    diferenciarStringNumber,
    explorarNull,
    compararNullUndefined,
    crearSymbolYBigInt,
    crearObjeto,
    trabajarConArreglos,
    funcionComoValor,
    clasificarTipo,
};

// ============================================

// Reto: Tipos de datos en JavaScript

// ============================================

// Completa cada función según las instrucciones.

// Ejecuta los tests con: npx vitest src/02-tipos-de-datos

// ============================================

// --- Reto 1: Identificar tipos primitivos ---

// Declara las siguientes constantes con los valores indicados:

// texto = "hola"

// numero = 42

// booleano = true

// nulo = null

// indefinido = undefined

// simbolo = Symbol("id")

// grande = 123n

// Retorna un objeto con el typeof de cada una:

// { texto, numero, booleano, nulo, indefinido, simbolo, grande }

// donde cada valor es el resultado de typeof sobre la variable.

function identificarPrimitivos() {

const texto = "hola";

const numero = 42;

const booleano = true;

const nulo = null;

const indefinido = undefined;

const simbolo = Symbol("id");

const grande = 123n;

return { texto: typeof texto, numero: typeof numero, booleano: typeof booleano, nulo: typeof nulo, indefinido: typeof undefined, simbolo: typeof simbolo, grande: typeof grande };

}

// --- Reto 2: Diferenciar string y number ---

// Recibe un parámetro "valor".

// Retorna un objeto con:

// { tipo: typeof valor, esString: true/false, esNumber: true/false }

function diferenciarStringNumber(valor) {

return { tipo: typeof valor, esString: typeof valor === "string", esNumber: typeof valor === "number" };

// Tu código aquí

}

// --- Reto 3: El caso especial de null ---

// Declara una constante "nulo" con valor null.

// Retorna un objeto con:

// { valor: nulo, tipo: typeof nulo, esNull: true/false }

// Pista: typeof null devuelve "object", pero debes verificar

// si realmente es null usando una comparación estricta (===).

function explorarNull() {

const nulo = null;

return { valor: nulo, tipo: typeof nulo, esNull: nulo === null };

// Tu código aquí

}

// --- Reto 4: Undefined vs Null ---

// Declara una variable con let llamada "sinAsignar" (sin asignarle valor).

// Declara una constante "vacio" con valor null.

// Retorna un objeto con:

// { sinAsignar, vacio, tipoSinAsignar: typeof sinAsignar, tipoVacio: typeof vacio, sonIguales: sinAsignar == vacio, sonEstrictamenteIguales: sinAsignar === vacio }

function compararNullUndefined() {

let sinAsignar = undefined;

const vacio = null;

return { sinAsignar, vacio, tipoSinAsignar: typeof sinAsignar, tipoVacio: typeof vacio, sonIguales: sinAsignar == vacio, sonEstrictamenteIguales: sinAsignar === vacio };

// Tu código aquí

}

// --- Reto 5: Symbol y BigInt ---

// Crea un Symbol con la descripción "miID".

// Crea un BigInt con el valor 9007199254740991n.

// Retorna un objeto con:

// { tipoSymbol: typeof del symbol, tipoBigInt: typeof del bigint, descripcionSymbol: symbol.description, valorBigInt: el bigint creado }

function crearSymbolYBigInt() {

const misimbolo = Symbol("miID");

const miNumeroGrande = 9007199254740991n;

return { tipoSymbol: typeof misimbolo, tipoBigInt: typeof miNumeroGrande, descripcionSymbol: misimbolo.description, valorBigInt: miNumeroGrande }

// Tu código aquí

}

// --- Reto 6: Crear un objeto ---

// Crea un objeto "persona" con las propiedades:

// nombre (string): "Juan"

// edad (number): 42

// activo (boolean): true

// Retorna un objeto con:

// { persona, tipoPersona: typeof persona, propiedades: Object.keys(persona) }

function crearObjeto() {

const persona = { nombre: "Juan", edad: 42, activo: true };

return {persona, tipoPersona: typeof persona, propiedades: Object.keys(persona)};

// Tu código aquí

}

// --- Reto 7: Trabajar con arrays ---

// Crea un arreglo "mezcla" con los valores: 1, "dos", true, null

// Retorna un objeto con:

// { arreglo: mezcla, esArreglo: Array.isArray(mezcla), largo: mezcla.length, tipos: [typeof de cada elemento] }

function trabajarConArreglos() {

const mezcla = [1,"dos", true, null];

return{arreglo:mezcla, esArreglo: Array.isArray(mezcla), largo: mezcla.length, tipos: [typeof mezcla[0], typeof mezcla[1], typeof mezcla[2], typeof mezcla[3]]};

// Tu código aquí

}

// --- Reto 8: Funciones como valor ---

// Crea una constante "saludar" que sea una función que reciba un nombre

// y retorne "Hola, {nombre}!".

// Retorna un objeto con:

// { tipoFuncion: typeof saludar, resultado: saludar("JavaScript") }

function funcionComoValor() {

const saludar = function(nombre) {

return "Hola, " + nombre + "!"

}; // Tu código aquí

return {tipoFuncion: typeof saludar, resultado: saludar("JavaScript")}

}

// --- Reto 9: Clasificar tipo de dato ---

// Recibe un parámetro "valor".

// Determina si es primitivo o complejo y retorna un objeto con:

// { valor, tipo: typeof valor, clasificacion: "primitivo" | "complejo" }

// Reglas:

// - Si es null, clasificación es "primitivo" (a pesar de typeof).

// - Si typeof es "object" o "function", clasificación es "complejo".

// - En cualquier otro caso, clasificación es "primitivo".

// Pista: primero verifica si es null, luego revisa typeof.

function clasificarTipo(valor) {

let clasificacion ="";

if (valor === null) {

clasificacion = "primitivo";

}

else if (typeof valor === "object"|| typeof valor === "function"){

clasificacion= "complejo";

}

else {

clasificacion = "primitivo";

}

return {valor: valor, tipo: typeof valor, clasificacion: clasificacion};

}

// Tu código aquí

module.exports = {

identificarPrimitivos,

diferenciarStringNumber,

explorarNull,

compararNullUndefined,

crearSymbolYBigInt,

crearObjeto,

trabajarConArreglos,

funcionComoValor,

clasificarTipo,

};

Tipos de datos en JavaScript explicados

Fundamentos Javascript

Tus primeras líneas de JavaScript en el navegador

Editor de notas Markdown con JavaScript

Configuración del entorno para JavaScript

var vs let vs const en JavaScript