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?
JavaScript tiene siete tipos primitivos de datos, pero tres de ellos son los más fundamentales y usados constantemente: String (cadenas de texto), Number (números) y Boolean (verdadero/falso). Entender estos tipos es esencial para escribir cualquier código JavaScript efectivo.
A diferencia de lenguajes tipados estáticamente como Java o C++, JavaScript es dinámicamente tipado: no necesitas declarar el tipo de una variable, se determina automáticamente según el valor que le asignes. Esto ofrece flexibilidad y rapidez al escribir código, pero requiere entender bien cómo funcionan las conversiones y coerciones de tipos para evitar bugs sutiles.
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 y fundamentales 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, así que usa la que prefieras (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}.
Template Literals: Más que Strings
Los template literals se llaman así porque actúan como plantillas: puedes insertar cualquier expresión JavaScript dentro usando ${...}. 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 (%) es especialmente útil: 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 round(), sqrt(), 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 dividir 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 que JavaScript puede representar.
Rango Seguro de Números
JavaScript puede representar números entre ±(2^53 - 1) de forma segura, aproximadamente ±9 cuatrillones. Fuera de este rango, pierdes precisión. Para números enteros más grandes, usa el tipo BigInt introducido en 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.
Nombres Descriptivos para Booleanos
Usa nombres de variables booleanas que suenen como preguntas de sí/no. Prefijos como is, has, can, should hacen el código autodocumentado y fácil de leer: isActive, hasPermission, canDelete, shouldUpdate. Esta convención mejora significativamente la legibilidad del código.
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 peculiaridades históricas: 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 coerció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 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), pero "5" - 2 da 3 (resta). 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 - memorízalos porque son fundamentales.
Los 8 valores falsy son: false, 0, -0, 0n (BigInt cero), "" (string vacío), null, undefined, y NaN. Todo lo demás es truthy, incluyendo arrays vacíos ([]), objetos vacíos (), y strings 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 es 0. Para verificar existencia, 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 es "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. 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