0Pricing
Frontend Academy · Lección

Tipos de datos: string, number, boolean, null y undefined

Explore los tipos primitivos de JavaScript, use typeof para inspeccionarlos y aprenda la diferencia entre null y undefined.

Tipos de datos: string, number, boolean, null y undefined es una lección gratuita de Frontend Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Frontend Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Frontend Academy incluye 4 lecciones en total.

El sistema de tipos de JavaScript

JavaScript tiene tipado dinámico: las variables no tienen tipos, sino los valores. La misma variable puede contener primero una cadena, después un número y luego null. Comprender los siete tipos primitivos evita una gran cantidad de errores.

string

Las cadenas representan texto. Use comillas simples, comillas dobles o comillas invertidas (literales de plantilla). Son inmutables: los métodos de cadena devuelven cadenas nuevas. Las cadenas tienen una propiedad .length y muchos métodos integrados.

const greeting = 'Hello';
const lang = "JavaScript";
const sentence = `I love ${lang}`;  // template literal

console.log(greeting.length);   // 5
console.log('hello'.toUpperCase()); // 'HELLO'
console.log(' trim me '.trim()); // 'trim me'

number

JavaScript tiene un único tipo numérico. Todos los números, tanto enteros como decimales, son valores de coma flotante de 64 bits (IEEE 754). Por eso 0.1 + 0.2 !== 0.3. Valores especiales: Infinity, -Infinity y NaN (Not a Number).

const age = 30;
const price = 19.99;
console.log(0.1 + 0.2);          // 0.30000000000000004
console.log(typeof NaN);          // 'number'
console.log(isNaN('hello'));      // true
console.log(Number.isNaN('hello')); // false (safer check)

boolean

Los booleanos son true o false. Se usan en condicionales y comparaciones. Todos los valores de JavaScript tienen un valor de verdad implícito: los valores falsy son false, 0, '', null, undefined y NaN. Todo lo demás es truthy.

const isActive = true;
const isAdmin = false;

// Falsy values:
if (0) { /* never runs */ }
if ('') { /* never runs */ }
if (null) { /* never runs */ }

null

null es un valor vacío asignado explícitamente. Significa «ningún valor de forma intencionada». Use null cuando quiera vaciar una variable o indicar ausencia. typeof null === 'object' es un famoso error de JavaScript que se mantiene por compatibilidad con versiones anteriores.

let selectedUser = null;  // no user selected yet
selectedUser = { name: 'Alice' };
selectedUser = null;       // cleared

undefined

undefined significa que todavía no se ha asignado un valor. Las variables declaradas pero no inicializadas son undefined. Los argumentos de función que faltan son undefined. Las propiedades de objeto que faltan devuelven undefined.

let x;                       // undefined
function greet(name) {
  console.log(name);           // undefined if called as greet()
}
const obj = {};
console.log(obj.foo);         // undefined

null frente a undefined

null = ausencia intencionada. undefined = todavía no asignado. Como regla general, deje que el motor establezca undefined y use null explícitamente en su propio código cuando quiera decir «vacío».

Operador typeof

Use typeof para inspeccionar el tipo de un valor durante la ejecución. Devuelve una cadena: 'string', 'number', 'boolean', 'undefined', 'object', 'function', 'bigint', 'symbol'. Recuerde que typeof null === 'object' es un error conocido.

typeof 'hello'     // 'string'
typeof 42          // 'number'
typeof true        // 'boolean'
typeof undefined   // 'undefined'
typeof null        // 'object' ← historical bug
typeof {}          // 'object'
typeof []          // 'object'
typeof function(){} // 'function'

Symbol y BigInt

Symbol: identificador único e inmutable, usado para claves de propiedades de objetos que no entren en conflicto. BigInt: números enteros mayores que Number.MAX_SAFE_INTEGER (2^53-1). Se crea con 42n o BigInt(42). No suele ser necesario en la mayoría de los proyectos frontend.

Trampas de la coerción de tipos

JavaScript convierte tipos silenciosamente en comparaciones y operaciones. Use === (igualdad estricta) en lugar de == (igualdad flexible) para evitar sorpresas por coerción.

0 == false        // true (coercion)
0 === false       // false (strict, no coercion)
'' == false       // true
'5' == 5          // true
'5' === 5         // false ✓ use this

Conversión de tipos

Convierta los tipos explícitamente con Number(), String(), Boolean() o parseInt() / parseFloat(). La conversión explícita siempre es más clara que depender de la coerción.

Number('42')      // 42
Number('')        // 0
Number('abc')     // NaN
String(42)        // '42'
Boolean(0)        // false
Boolean('hello')  // true
parseInt('10px')  // 10

Comprobación rápida

¿Qué devuelve typeof null en JavaScript?

Repaso: tipos de datos de JavaScript

Siete tipos primitivos: string, number, boolean, null, undefined, symbol y bigint. Use typeof para inspeccionar los tipos. Use === para las comparaciones y evitar la coerción. Distinga null (vacío intencionado) de undefined (todavía no establecido). Todos los demás valores son objetos.

Preguntas frecuentes

¿La lección «Tipos de datos: string, number, boolean, null y undefined» es gratis?

Sí — el texto completo de «Tipos de datos: string, number, boolean, null y undefined» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Frontend Academy, actualiza a CoddyKit PRO. El curso de Frontend Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Tipos de datos: string, number, boolean, null y undefined»?

Explore los tipos primitivos de JavaScript, use typeof para inspeccionarlos y aprenda la diferencia entre null y undefined. Practicas Frontend Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Frontend Academy?

No se requiere experiencia previa. Frontend Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Tipos de datos: string, number, boolean, null y undefined»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Frontend Academy?

Sí. Cada lección de Frontend Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Variables: let, const, var y scope
  2. Tipos de datos: string, number, boolean, null y undefined
  3. Funciones: declaraciones, expresiones y arrow functions
  4. Flujo de control: if, else, switch, for y while
← Volver a Frontend Academy