Tipos de datos en JavaScript: primitivos vs complejos

Domina los tipos de datos en JavaScript con ejemplos claros y buenas prácticas. Aquí verás cómo declarar variables con const y let, por qué diferenciar un número de un texto evita errores, y cómo usar typeof y console.log para identificar cada valor, incluido el caso especial de null.

¿Qué son los tipos de datos en JavaScript y cómo se clasifican?

En JavaScript existen siete tipos de datos primitivos: string, number, boolean, null, undefined, symbol y bigint. Son valores simples que puedes usar directamente. Además, hay tipos complejos: objetos, funciones y arrays, que permiten agrupar y estructurar datos.

• Un texto entre comillas es un string. Ejemplo: "hola".
• Un 42 sin comillas es un number. "42" es un string, no un number.
• Un boolean solo puede ser true o false.
• null expresa ausencia intencional de valor.
• undefined indica que algo no fue definido.
• symbol ayuda a crear identificadores únicos como un ID.
• bigint representa números enteros muy grandes terminados en n.

¿Cómo declarar variables y comentarios en JavaScript de forma segura?

La mejor práctica: usar const para declarar valores que no cambiarán. Si un valor debe cambiar, usa let. Para documentar, agrega comentarios con //: JavaScript los ignora y ayudan a otras personas a entender el código.

// Tipos de datos primitivos
const texto = "hola";                 // string
const numero = 42;                      // number
const booleano = true;                  // boolean (también puede ser false)
const nulo = null;                      // null
const indefinido = undefined;           // undefined
const simbolo = Symbol('id');           // symbol
const grande = 123n;                    // bigint

• Evita confundir "42" con 42: el primero es string, el segundo es number.
• El editor suele ofrecer ayudas visuales para distinguir variables, funciones y tipos.
• JavaScript es sensible a mayúsculas y minúsculas: cuidado con los nombres.
• No uses palabras reservadas como nombres de variables: pueden causar errores.

¿Cómo identificar tipos con typeof y trabajar con datos complejos?

Puedes imprimir valores e identificar su tipo con console.log y la palabra reservada typeof. Además, verás cómo modelar datos complejos con objetos, arrays y funciones.

¿Cómo verificar tipos con typeof y console.log?

console.log(typeof texto, texto);         // 'string' "hola"
console.log(typeof numero, numero);       // 'number' 42
console.log(typeof booleano, booleano);   // 'boolean' true
console.log(typeof nulo, nulo);           // 'object' null  ← caso especial
console.log(typeof indefinido, indefinido); // 'undefined' undefined
console.log(typeof simbolo, simbolo);     // 'symbol' Symbol('id')
console.log(typeof grande, grande);       // 'bigint' 123n

• Atención: typeof null devuelve 'object' por un error histórico. Conceptualmente, null expresa ausencia de valor, no es un objeto.
• Usa typeof para confirmar el tipo antes de operar con un valor.

¿Qué incluyen los tipos de datos complejos: objetos, arrays y funciones?

// Tipos de datos complejos
const objeto = { nombre: "Juan", edad: 42 }; // propiedades internas con distintos tipos
const arreglo = [1, 2, "tres"];              // puede mezclar numbers y strings
const unaFuncion = function () {               // función como valor
  // acciones según sea el caso
};

• Un objeto agrupa pares clave-valor.
• Un array contiene listas de valores, incluso mezclados.
• Una función es un valor que puedes asignar y ejecutar.
• Evita nombrar variables con palabras reservadas: por ejemplo, no uses "function" como nombre.

¿Qué habilidades y keywords prácticas refuerzas?

• Declarar con const y cambiar con let cuando sea necesario.
• Comentar con // para documentar el código.
• Distinguir string vs number al leer y escribir valores.
• Identificar tipos con typeof y validar antes de usar.
• Crear symbol para IDs únicos y usar bigint para números grandes.
• Modelar datos con objetos, arrays y funciones.
• Cuidar mayúsculas y minúsculas en nombres y evitar palabras reservadas.

¿Probaste tus propias variables y el resultado de typeof? Cuéntame en los comentarios tu solución y qué casos te sorprendieron.