Tipos primitivos básicos: tipado dinámico, Number, String, Boolean
En JavaScript, el tipado dinámico permite que las variables cambien de tipo durante la ejecución del programa. No es necesario especificar el tipo al declarar una variable; JavaScript determina el tipo en función del valor asignado.
Números (Number)
El tipo Number representa tanto números enteros como de punto flotante. Se utiliza para realizar operaciones matemáticas y cálculos numéricos:
let edad = 30; // Número entero
let temperatura = -5.5; // Número decimal
let precio = 1200.50; // Precio con decimales
Cadenas de texto (String)
Las Strings son cadenas de texto que se utilizan para representar caracteres y palabras. Se pueden definir usando comillas simples, dobles o backticks:
let nombre = "Juan"; // Con comillas dobles
let apellido = 'Pérez'; // Con comillas simples
let saludo = `Hola, ${nombre}!`; // Template literal con interpolación
Los template literals (con backticks) son especialmente útiles porque permiten insertar variables directamente en el texto, como vimos en nuestro primer programa de "Hola mundo".
Booleanos (Boolean)
El tipo Boolean tiene solo dos valores posibles: true
o false
. Es fundamental para realizar evaluaciones lógicas y controlar el flujo de ejecución:
let esMiembro = true;
let tieneAcceso = false;
// Los booleanos son útiles para tomar decisiones
if (esMiembro) {
console.log("Bienvenido, miembro!");
}
Gracias al tipado dinámico, una variable puede cambiar su tipo en cualquier momento:
let variable = 100; // variable es un Number
variable = "Cien"; // ahora es una String
variable = false; // ahora es un Boolean
¿Te está gustando esta lección?
Inicia sesión para no perder tu progreso y accede a miles de tutoriales, ejercicios prácticos y nuestro asistente de IA.
Más de 25.000 desarrolladores ya confían en CertiDevs
Tipos especiales: ausencia de valor
JavaScript tiene dos valores especiales para representar "ausencia de valor", cada uno con un propósito diferente:
undefined
El valor undefined
se asigna automáticamente a variables que han sido declaradas pero no inicializadas:
let usuario;
console.log(usuario); // undefined
console.log(typeof usuario); // "undefined"
// También aparece cuando accedemos a propiedades inexistentes
let persona = {nombre: "Ana"};
console.log(persona.edad); // undefined
null
Por otro lado, null
es un valor que asignamos intencionalmente para indicar la ausencia de un objeto o valor:
let datosUsuario = null; // Todavía no tenemos datos
console.log(datosUsuario); // null
// Útil para resetear o vaciar una variable
let seleccion = "Opción 1";
seleccion = null; // El usuario canceló la selección
Aunque ambos representan "ausencia", tienen diferencias importantes:
undefined
generalmente indica algo que no ha sido inicializadonull
indica una ausencia intencional de valor
Nuestro primer tipo complejo: Objetos
Además de los tipos primitivos, JavaScript tiene objetos que nos permiten agrupar múltiples valores relacionados:
// Un objeto simple que describe a una persona
let persona = {
nombre: "Ana",
edad: 25,
esEstudiante: true
};
// Accediendo a las propiedades
console.log(persona.nombre); // "Ana"
console.log(persona.edad); // 25
Nota: Los objetos son un tema extenso que exploraremos con más detalle en módulos posteriores. Por ahora, solo necesitas comprender que son colecciones de pares clave-valor.
Verificación de tipos con typeof
JavaScript nos proporciona el operador typeof
para verificar el tipo de un valor:
console.log(typeof 42); // "number"
console.log(typeof "Hola"); // "string"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof {}); // "object"
console.log(typeof null); // "object" (esto es una peculiaridad histórica de JavaScript)
Verificar tipos es útil cuando necesitas asegurarte de que una variable contiene el tipo de dato esperado antes de realizar operaciones con ella.
let entrada = "42";
if (typeof entrada === "string") {
// Convertir a número si es una cadena
entrada = Number(entrada);
}
Tipos avanzados
Los siguientes tipos son más avanzados y menos frecuentes, pero es importante conocerlos para tener una visión completa del sistema de tipos en JavaScript.
Symbol
El tipo Symbol, introducido en ES6, se utiliza para crear identificadores únicos e inmutables:
const id = Symbol('id');
let usuario = {
nombre: 'Alice',
[id]: 12345 // Propiedad con Symbol como clave
};
console.log(usuario.nombre); // "Alice"
console.log(usuario[id]); // 12345
Los Symbols son útiles en código más avanzado para crear propiedades que no colisionarán con otras, incluso si tienen el mismo nombre.
BigInt
El tipo BigInt permite representar números enteros extremadamente grandes, más allá del límite del tipo Number:
// Los BigInt se crean añadiendo 'n' al final o usando la función BigInt()
const numeroGrande = 9007199254740991n;
const otroNumeroGrande = BigInt('9007199254740991');
console.log(numeroGrande + 1n); // 9007199254740992n
BigInt es útil cuando trabajas con números muy grandes como identificadores, timestamps precisos o cálculos científicos.
Tipos por referencia vs tipos por valor
El siguiente concepto es fundamental y será crucial para entender el comportamiento de objetos y arrays más adelante en el curso.
En JavaScript, los tipos de datos se dividen en dos categorías según cómo se almacenan en memoria:
Tipos primitivos (por valor)
Los tipos primitivos (Number, String, Boolean, null, undefined, Symbol, BigInt) se pasan "por valor". Esto significa que cuando asignas o copias estos valores, obtienes una copia independiente:
let x = 10;
let y = x; // 'y' obtiene una copia del valor de 'x'
y = 20; // Cambiar 'y' no afecta a 'x'
console.log(x); // 10
console.log(y); // 20
Tipos de referencia (por referencia)
Los objetos (incluyendo arrays y funciones) se pasan "por referencia". Cuando asignas o copias estos valores, ambas variables apuntan al mismo objeto en memoria:
let obj1 = { mensaje: "Hola" };
let obj2 = obj1; // 'obj2' apunta al mismo objeto que 'obj1'
obj2.mensaje = "Adiós"; // Cambiar a través de 'obj2'...
console.log(obj1.mensaje); // "Adiós" - ¡También afecta a 'obj1'!
Profundizaremos en este concepto cuando estudiemos arrays y objetos con más detalle, y será especialmente importante cuando veamos cómo trabajar con funciones que modifican datos.
Conversiones básicas entre tipos
A menudo necesitarás convertir valores de un tipo a otro. JavaScript proporciona varias formas de hacerlo:
Convertir a String
let num = 42;
let str1 = String(num); // Usando la función String()
let str2 = num.toString(); // Usando el método toString()
let str3 = num + ""; // Concatenando con una cadena vacía
Convertir a Number
let str = "42";
let num1 = Number(str); // Usando la función Number()
let num2 = parseInt(str); // parseInt() para enteros
let num3 = parseFloat("42.5"); // parseFloat() para decimales
let num4 = +"42"; // Usando el operador unario +
Convertir a Boolean
JavaScript considera algunos valores como "falsy" (equivalentes a false) y el resto como "truthy" (equivalentes a true):
// Valores falsy:
Boolean(0); // false
Boolean(""); // false (cadena vacía)
Boolean(null); // false
Boolean(undefined); // false
Boolean(NaN); // false
// Cualquier otro valor es truthy:
Boolean(1); // true
Boolean("Hola"); // true
Boolean([]); // true (array vacío)
Boolean({}); // true (objeto vacío)
Este concepto de valores "truthy" y "falsy" será muy importante cuando aprendamos sobre estructuras de control como if
y bucles.
Aprendizajes de esta lección
- Comprender los tipos de datos primitivos y de objeto en JavaScript.
- Aprender a declarar y utilizar variables para almacenar diferentes tipos de datos.
- Familiarizarse con la creación y manipulación de objetos y arrays.
- Conocer cómo utilizar funciones y métodos para operar con diferentes tipos de datos.
- Entender el propósito y uso de los tipos de datos especiales
undefined
,null
ySymbol
.
Completa JavaScript y certifícate
Únete a nuestra plataforma y accede a miles de tutoriales, ejercicios prácticos, proyectos reales y nuestro asistente de IA personalizado para acelerar tu aprendizaje.
Asistente IA
Resuelve dudas al instante
Ejercicios
Practica con proyectos reales
Certificados
Valida tus conocimientos
Más de 25.000 desarrolladores ya se han certificado con CertiDevs