Tipos Primitivos en JavaScript: String, Number y Boolean
Conoce los tres tipos de datos más fundamentales de JavaScript: cadenas de texto, números y valores booleanos. Aprende sus características, conversiones y casos especiales.
TL;DR - Resumen rápido
- String: Texto entre comillas simples, dobles o backticks. Template literals permiten interpolación con ${variable}
- Number: Un solo tipo para enteros y decimales. Incluye valores especiales NaN e Infinity
- Boolean: Solo true o false. Fundamentales para control de flujo y condiciones
- typeof retorna el tipo de un valor como string. Ten cuidado: typeof null es 'object'
- Conversión explícita es mejor que implícita: usa String(), Number(), Boolean()
- 8 valores falsy: false, 0, -0, 0n, '', null, undefined, NaN. Todo lo demás es truthy
- Usa === (estricta) en lugar de == (suelta) para evitar coerción implícita
¿Qué son los Tipos Primitivos?
Un tipo primitivo es el tipo de dato más básico del lenguaje: un valor simple, inmutable y sin métodos propios. Cuando asignas un número, un texto o un booleano a una variable, estás trabajando con primitivos el nivel más fundamental de los datos en JavaScript.
JavaScript tiene siete tipos primitivos, pero tres son los que usarás constantemente: String (cadenas de texto), Number (números) y Boolean (verdadero/falso). A diferencia de los objetos, los primitivos se copian por valor, no por referencia, lo que los hace predecibles y seguros de usar.
Los 7 Tipos Primitivos
Los siete tipos primitivos de JavaScript son: String, Number, Boolean, undefined, null, Symbol (ES6) y BigInt (ES2020). En este artículo nos enfocamos en los tres más comunes que usarás en prácticamente todo tu código.
String (Cadenas de Texto)
Los strings representan texto en JavaScript. Puedes crearlos usando comillas simples ('...'), comillas dobles ("...") o template literals (`...`). No hay diferencia funcional entre comillas simples y dobles, pero los template literals ofrecen capacidades adicionales como interpolación de variables y strings multilínea.
Comillas Simples, Dobles y Template Literals
Puedes usar cualquiera de los tres tipos de comillas para crear strings. La elección entre comillas simples y dobles es estilística — elige una y manténla consistente en tu proyecto. Los template literals (backticks `) son la adición más moderna y potente.
Las comillas simples y dobles funcionan igual (la convención más común es comillas simples). Los template literals son especiales: permiten saltos de línea sin caracteres de escape y, más importante, permiten insertar expresiones JavaScript dentro del string usando la sintaxis ${expresión}. Esto se conoce como interpolación y es la forma moderna de construir strings dinámicos, reemplazando la concatenación tradicional con +.
Concatenación e Interpolación
Hay dos formas principales de combinar texto con variables: concatenación con el operador + (forma antigua) e interpolación con template literals (forma moderna). La interpolación es más legible y menos propensa a errores, por eso es la práctica recomendada actualmente.
La concatenación con + funciona pero se vuelve difícil de leer cuando tienes múltiples variables y espacios. Los template literals resuelven esto: el código es más limpio, ves claramente dónde van las variables, y puedes incluir expresiones complejas o llamadas a funciones directamente dentro de ${...}. Este es el método preferido en código moderno.
Number (Números)
JavaScript tiene un único tipo numérico llamado Number, a diferencia de otros lenguajes que distinguen entre enteros (int, long) y decimales (float, double). JavaScript usa el mismo tipo para todos los números, representándolos internamente usando el estándar IEEE 754 de punto flotante de 64 bits.
Números Enteros y Decimales
Puedes trabajar con números enteros, decimales, negativos y notación científica sin necesidad de declarar tipos diferentes. JavaScript maneja todo bajo el mismo tipo Number, lo que simplifica el código pero requiere cuidado con la precisión en operaciones decimales.
Todos estos números son del tipo Number independientemente de si tienen decimales o no. La notación científica (1e6) es útil para números muy grandes o muy pequeños. JavaScript no distingue entre entero y decimal, lo que hace el lenguaje más simple pero puede causar problemas de precisión en cálculos con decimales.
Precisión de Punto Flotante
Los números de punto flotante tienen problemas inherentes de precisión. Por ejemplo, 0.1 + 0.2 no es exactamente 0.3 sino 0.30000000000000004. Para cálculos financieros o donde la precisión es crítica, trabaja con enteros (centavos en lugar de dólares) o usa bibliotecas especializadas como decimal.js.
Operaciones Matemáticas Básicas
JavaScript soporta todas las operaciones matemáticas estándar: suma, resta, multiplicación, división, módulo y potencia. El objeto global Math proporciona funciones adicionales para cálculos más complejos como redondeo, raíces cuadradas y funciones trigonométricas.
El operador módulo (%) retorna el resto de una división y se usa comúnmente para determinar si un número es par o impar, o para operaciones cíclicas. El objeto Math incluye métodos como Math.round(), Math.sqrt(), Math.max() que cubren la mayoría de necesidades matemáticas sin necesidad de librerías externas.
Valores Especiales: NaN e Infinity
El tipo Number incluye dos valores especiales: NaN (Not a Number) e Infinity. NaN representa un resultado numérico inválido, mientras que Infinity representa un valor infinitamente grande (o pequeño si es negativo).
NaN aparece cuando intentas una operación matemática inválida como 0 / 0 o convertir texto no numérico a número. Curiosamente, NaN no es igual a sí mismo (NaN !== NaN es true), por eso debes usar Number.isNaN() para verificarlo. Infinity aparece en divisiones entre cero o cuando un número excede los límites representables. Para enteros muy grandes, JavaScript tiene el tipo BigInt (ES2020) que puede manejar enteros de tamaño arbitrario.
Boolean (Verdadero/Falso)
El tipo Boolean es el más simple de JavaScript: solo tiene dos valores posibles, true (verdadero) y false (falso). Son palabras reservadas del lenguaje y se usan constantemente en estructuras de control de flujo como if, while, for y en operadores lógicos.
Los booleanos son el resultado de todas las comparaciones (===, !==, <, >, etc.) y son fundamentales para la lógica de tu programa. Los operadores lógicos (&& para AND, || para OR, ! para NOT) trabajan con valores booleanos, aunque JavaScript convierte automáticamente otros valores a booleanos cuando es necesario. Por convención, nombra tus variables booleanas con prefijos como is, has, can o should: isActive, hasPermission, canDelete.
Operador typeof: Verificar Tipos
El operador typeof retorna un string indicando el tipo de un valor. Es útil para verificar tipos antes de operar con ellos, especialmente cuando trabajas con datos de origen desconocido como inputs de usuario, respuestas de APIs o parámetros de funciones.
El operador typeof siempre retorna un string con el nombre del tipo en minúsculas: "string", "number", "boolean", "undefined", "object", "function" o "symbol". Ten en cuenta dos peculiaridades históricas: los arrays retornan "object" (son objetos especiales) y null también retorna "object" — un bug que no se puede corregir por compatibilidad.
Conversión de Tipos: Explícita vs Implícita
JavaScript puede convertir valores entre tipos de dos formas: coerción implícita (automática) o conversión explícita (manual). La conversión explícita es más clara, predecible y previene bugs, por eso es la forma recomendada en código de producción.
Usa las funciones String(), Number() y Boolean() para conversiones explícitas y claras. Son más legibles que trucos como el doble NOT (!!) o el operador más unario (+). La coerción implícita es cuando JavaScript convierte tipos automáticamente, pero sus reglas pueden ser confusas y causar bugs difíciles de detectar.
Cuidado con la Coerción Implícita
La coerción implícita tiene reglas inconsistentes: "5" + 2 da "52" (concatena strings), pero "5" - 2 da 3 (resta numérica). JavaScript decide qué hacer según el operador, lo cual es confuso. Por eso usa conversiones explícitas y comparación estricta (===) en lugar de suelta (==) para evitar sorpresas.
Valores Truthy y Falsy: Booleanos Implícitos
En contextos booleanos (como la condición de un if), JavaScript convierte cualquier valor a true o false. Los valores que se convierten a false se llaman falsy, y todos los demás son truthy. Solo hay 8 valores falsy en JavaScript:
- <code>false</code> — el valor booleano falso literal
- <code>0</code> y <code>-0</code> — cero numérico positivo y negativo
- <code>0n</code> — BigInt cero
- <code>""</code> — string vacío (comillas simples, dobles o backtick)
- <code>null</code> — ausencia intencional de valor
- <code>undefined</code> — variable no inicializada o sin retorno
- <code>NaN</code> — Not a Number (resultado de operación inválida)
Todo lo demás es truthy, incluyendo arrays vacíos ([]), objetos vacíos ({}), y strings no vacíos como "0" o "false". Esta diferencia es crucial y causa muchos bugs cuando no la entiendes.
Truthy/Falsy en la Práctica
Esta característica permite código conciso: if (user.name) en lugar de if (user.name !== undefined && user.name !== null && user.name !== ''). Pero úsala con cuidado: el cero (0) es falsy, así que if (score) falla cuando score vale 0. Para verificar existencia real, usa score !== undefined.
Errores Comunes con Tipos Primitivos
Aunque los tipos primitivos parecen simples, hay errores comunes que incluso desarrolladores experimentados cometen. La mayoría vienen de no entender bien la coerción de tipos y las particularidades de JavaScript.
El error más común es confiar en la coerción implícita sin entender sus reglas. Usa siempre comparación estricta (===) en lugar de igualdad suelta (==). Ten cuidado con operaciones que mezclan strings y números: el operador + concatena si hay un string, pero -, *, / siempre intentan conversión numérica. Y recuerda que typeof null retorna "object", no "null".
Validación de Tipos en Datos Externos
Cuando trabajes con datos externos (APIs, inputs de usuario, localStorage), siempre valida y convierte tipos explícitamente antes de usarlos en tu lógica. Usa typeof para verificar, y funciones de conversión explícitas como Number() o String(). Esto previene bugs sutiles y hace tu código más robusto y predecible.
Resumen: Tipos Primitivos Fundamentales
Características principales:
- •String: Texto con comillas simples, dobles o backticks. Template literals para interpolación
- •Number: Un solo tipo para enteros y decimales. Incluye NaN e Infinity
- •Boolean: Solo true o false. Base de toda lógica condicional
- •typeof retorna el tipo como string. Cuidado: typeof null es 'object'
- •8 valores falsy: false, 0, -0, 0n, '', null, undefined, NaN
Mejores prácticas:
- •Usa template literals en lugar de concatenación con +
- •Conversión explícita (String(), Number(), Boolean()) mejor que implícita
- •Comparación estricta (===) en lugar de suelta (==)
- •Valida tipos de datos externos antes de usarlos
- •Memoriza los 8 valores falsy para evitar bugs en condiciones