Tipos de datos

docs.scrimba.com

Guarda el nombre de alguien, su edad y si está conectado, y ya habrás utilizado tres tipos de valor diferentes. El nombre es texto, la edad es un número y la bandera de conexión es un sí o no. JavaScript trata cada uno de estos como un tipo distinto y maneja cada uno de manera diferente. Este capítulo trata sobre los pocos tipos que encuentras primero y cómo saber cuál estás sosteniendo.

Los tipos básicos

Tres tipos cubren la mayoría de lo que almacenas. Una cadena es texto, entre comillas. Un número es cualquier número, para contar o medir. Un booleano es un valor sí o no, y tiene solo dos opciones: true o false.

const name = "María"; // una cadena: texto
const age = 27; // un número
const isLoggedIn = true; // un booleano: true o false

Usas una cadena para cualquier cosa que se lea como palabras: un nombre, un mensaje, un color. Usas un número para cualquier cosa que puedas contar o calcular. Usas un booleano siempre que la respuesta sea una de dos opciones, como si una casilla está marcada. Verás mucho más de esto en cadenas y números.

Los valores cotidianos de JavaScript se dividen en algunos tipos, y tres de ellos llevan la mayoría de tus datos. Una cadena es texto entre comillas, simples o dobles, no importa cuál. Un número es cualquier valor numérico. Un booleano es uno de exactamente dos valores, true o false.

const productName = "Ratón inalámbrico"; // cadena
const price = 24.99; // número
const inStock = true; // booleano

Cada tipo tiene un trabajo. Las cadenas contienen texto que muestras o lees, cubierto en cadenas. Los números contienen cualquier cosa que calcules, cubierto en números. Los booleanos contienen una respuesta de dos vías y aparecen en todas partes donde se toma una decisión, porque una comparación como price < 30 produce uno.

JavaScript ordena los valores en un pequeño conjunto de tipos, y tres de ellos representan la mayoría de los datos que manejas. Una cadena es una secuencia de caracteres escrita entre comillas, simples, dobles o acentos graves para plantillas literales. Un número es un valor numérico. Un booleano es uno de dos valores, true o false.

const currency = "EUR"; // cadena
const balance = 1499.5; // número
const isOverdrawn = balance < 0; // booleano, aquí el resultado de una comparación

La distinción entre cadenas y números importa más de lo que parece a primera vista, porque "5" y 5 se comportan de manera diferente: uno es texto que contiene un dígito, el otro es un valor con el que puedes hacer aritmética. Los booleanos merecen notarse temprano porque rara vez los escribes a mano. Salen de comparaciones y comprobaciones lógicas, así que la capacidad de leer balance < 0 como "un booleano" es lo que hace que condiciones posteriores y operadores encajen en su lugar.

JunoLos tipos básicos Los tres que usas constantemente: string para texto entre comillas, number para cualquier cosa numérica, y boolean para una respuesta true o false. Elige el tipo que coincida con el tipo de cosa que estás almacenando. Un nombre es una cadena, una edad es un número, una casilla es un booleano.

JunoLos tipos básicos Tres tipos hacen la mayoría del trabajo: string para texto, number para valores numéricos, boolean para uno de true o false. Las comillas hacen una cadena, así que "5" es texto, no un número. Los booleanos usualmente llegan como el resultado de una comparación en lugar de algo que escribas.

JunoLos tipos básicos Las cadenas, números y booleanos llevan la mayoría de tus datos, y la línea cadena-versus-número es la que muerde: "5" es texto, 5 es aritmética. Casi nunca escribes un literal booleano, porque comparaciones como balance < 0 te dan uno. Leer una comparación como "esto es un booleano" es lo que hace que las condiciones posteriores encajen.

Nada: null y undefined

A veces un valor falta, y JavaScript tiene dos formas de decirlo. undefined significa que aún no se ha dado ningún valor. Si haces una variable sin establecerla, su valor es undefined.

let score;
console.log(score); // undefined

null significa vacío a propósito. Lo usas tú mismo, para decir "esto no tiene valor ahora, y lo hice a propósito".

let winner = null;
console.log(winner); // null

La versión corta: undefined es JavaScript diciendo "nada aquí todavía", y null eres tú diciendo "nada aquí, deliberadamente".

Dos valores ambos significan "sin valor", y la diferencia es quién los estableció. undefined es lo que JavaScript te da por defecto: una variable declarada sin un valor, por ejemplo, comienza como undefined.

let selectedColor;
console.log(selectedColor); // undefined

null es un valor que asignas tú mismo para marcar algo como deliberadamente vacío, un espacio que has vaciado o aún no has llenado.

let couponCode = null;
console.log(couponCode); // null

undefined es la ausencia predeterminada; null es la deliberada. Esa división es la forma útil de leerlos: si ves undefined, algo nunca se estableció; si ves null, alguien eligió vaciarlo.

Tanto null como undefined representan ausencia, y la convención que los separa trata sobre la intención. undefined es la ausencia que produce JavaScript por sí sola: una variable declarada pero no asignada, una propiedad faltante, una función que no devuelve nada.

let discount;
console.log(discount); // undefined

null es la ausencia que asignas deliberadamente, para señalar "intencionalmente vacío" en lugar de "aún no tocado".

let appliedCoupon = null;
console.log(appliedCoupon); // null

Mantener los dos separados es una señal real en una base de código: undefined tiende a significar que nadie ha establecido esto, lo que puede señalar un error o una ruta inconclusa, mientras que null se lee como una opción considerada. Tampoco se comportan de manera idéntica bajo comprobaciones posteriores, razón por la cual mezclarlos causa confusión una vez que comparaciones y operadores entran en la imagen. Trata undefined como el predeterminado de la máquina y null como tu "vacío" explícito, y su comportamiento deja de parecer aleatorio.

JunoNada: null y undefined Dos formas de decir "sin valor". undefined es el predeterminado de JavaScript cuando nada se ha establecido todavía. null es el que escribes tú mismo para significar "vacío a propósito". Si nunca le diste a una variable un valor, espera undefined.

JunoNada: null y undefined Ambos significan ausencia, la diferencia es quién lo estableció. undefined aparece por sí solo, como una variable declarada sin un valor. null es el que asignas para marcar algo como deliberadamente vacío. Leerlos de esa manera te dice si una ausencia fue un accidente o una opción.

JunoNada: null y undefined La convención hace el trabajo pesado aquí: undefined es la ausencia que JavaScript te entrega, null es la ausencia que asignas a propósito. Entonces undefined a menudo señala "nadie estableció esto", lo que puede ser un error, mientras que null se lee como intención. Mantenlos distintos y las comparaciones posteriores dejan de sorprenderte.

Verificar un tipo con typeof

Cuando no estás seguro de qué tipo es un valor, typeof te lo dice. Ponlo delante de un valor y te devuelve una cadena que nombra el tipo.

console.log(typeof "María"); // "string"
console.log(typeof 27); // "number"
console.log(typeof true); // "boolean"

Nota que la respuesta siempre es texto, una cadena como "number", no el tipo en sí. Eso es útil cuando quieres verificar con qué estás tratando antes de usarlo.

typeof reporta el tipo de un valor como una cadena. Colócalo antes de cualquier valor y obtendrás "string", "number", "boolean", y así sucesivamente.

const label = "checkout";
console.log(typeof label); // "string"
console.log(typeof 24.99); // "number"
console.log(typeof false); // "boolean"
console.log(typeof undefined); // "undefined"

Hay una peculiaridad que vale la pena conocer ahora, porque sorprende a todos la primera vez: typeof null es "object", no "null".

console.log(typeof null); // "object"

Este es un error de larga data en el lenguaje que nunca se corrigió, porque corregirlo rompería código antiguo. No es algo que hayas hecho mal. Recuerda que typeof null miente, y verifica null directamente cuando lo necesites.

typeof toma un valor y devuelve una cadena que nombra su tipo. Es la forma más rápida de preguntar "qué estoy sosteniendo" en tiempo de ejecución.

console.log(typeof "checkout"); // "string"
console.log(typeof 1499.5); // "number"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"

El único resultado que debes memorizar es el atípico: typeof null devuelve "object", no "null".

console.log(typeof null); // "object"

Esta es una peculiaridad histórica, un error incorporado en la primera versión de JavaScript que nunca fue corregido porque demasiado código existente ahora depende de la respuesta incorrecta. La consecuencia práctica es que typeof solo no puede decirte que un valor es null; verificas eso con una comparación directa en su lugar. Es el ejemplo clásico de la compensación de compatibilidad hacia atrás de JavaScript, donde un error conocido permanece porque romperlo rompería la web.

JunoVerificar un tipo con typeof Coloca typeof delante de un valor y te dice el tipo, como una cadena como "number". Es la forma más rápida de verificar qué estás sosteniendo cuando no estás seguro. La respuesta siempre es texto, así que typeof 27 te da "number", comillas y todo.

JunoVerificar un tipo con typeoftypeof te devuelve el tipo como una cadena, lo que te permite verificar un valor antes de usarlo. Cuidado con la única trampa: typeof null es "object", no "null". Es un error que el lenguaje mantuvo por compatibilidad, así que prueba null directamente en lugar de confiar en typeof allí.

JunoVerificar un tipo con typeoftypeof responde "qué tipo es este" como una cadena en tiempo de ejecución. El único resultado a memorizar es el incorrecto: typeof null es "object", un error de primera versión congelado en su lugar porque corregirlo rompería la web. Así que nunca puede confirmarte null; verifica eso con una comparación directa en su lugar.

La visión más amplia de los tipos

Has conocido los tipos cotidianos: cadena, número, booleano, más null y undefined. Eso es suficiente para almacenar la mayoría de lo que un programa pequeño necesita. Capítulos posteriores agregan formas de agrupar valores juntos, pero cada uno de esos grupos sigue siendo construido a partir de los tipos simples que ya has visto.

Por ahora, la ganancia es saber que cada valor tiene un tipo, y que el tipo decide qué puedes hacer con el valor. Un número puedes sumarlo; una cadena puedes unirla; un booleano puedes verificarlo. Ten operadores en mente como el próximo paso, porque es donde comienzas a combinar estos valores.

Los tipos hasta ahora, cadena, número, booleano, null y undefined, son los tipos primitivos: valores simples y únicos. JavaScript también tiene tipos no primitivos, los que contienen colecciones de valores, como matrices y objetos. Estos se tratan en sus propios capítulos y se comportan de manera diferente de formas que vale la pena aprender cuando llegues allí.

Una cosa que aclarar ahora: number es un único tipo. JavaScript no divide números enteros y decimales en tipos separados como lo hacen algunos lenguajes, así que 10 y 10.5 son ambos del mismo tipo number. Eso mantiene números más simple de razonar, con un tipo cubriendo cada valor numérico.

Los tipos cubiertos aquí, cadena, número, booleano, null y undefined, son tipos primitivos: valores únicos y autocontenidos. Todo lo demás, matrices y objetos, es un tipo de referencia, que contiene una colección y se comporta de manera diferente cuando la copias o comparas. Esa diferencia es la fuente de muchas sorpresas, y obtiene su propio tratamiento cuando esos tipos llegan.

Algunas cosas que vale la pena señalar mientras los tipos están en la mesa. number es un tipo para cada valor numérico, entero o decimal, así que no hay un tipo de entero separado en el que pensar, cubierto en números. Existen dos primitivos adicionales que rara vez encuentras temprano, bigint para enteros demasiado grandes para un número normal, y symbol para claves únicas. Y los tipos no están fijos en su lugar: JavaScript convertirá uno en otro en ciertas situaciones, un comportamiento llamado coerción (por ejemplo, convertir un número en una cadena cuando los unes). Eso tiene consecuencias reales, y operadores es donde comienza a importar.

JunoLa visión más amplia de los tipos Cada valor tiene un tipo, y el tipo decide qué puedes hacer con él: sumar números, unir cadenas, verificar booleanos. Los tipos cotidianos, cadena, número, booleano, más null y undefined, cubren la mayoría de lo que un programa pequeño almacena. Capítulos posteriores agrupan valores juntos, pero todos están construidos a partir de estos.

JunoLa visión más amplia de los tipos Los cinco que conoces, cadena, número, booleano, null y undefined, son los tipos primitivos: valores únicos y simples. Las matrices y objetos son los no primitivos, llegando después, y se comportan de manera diferente. Hecho útil: number es un tipo para ambos 10 y 10.5, así que no hay un número entero y decimal separado para rastrear.

JunoLa visión más amplia de los tipos Los primitivos son valores únicos; las matrices y objetos son tipos de referencia que se copian y comparan de manera diferente, que es donde viven las sorpresas. number cubre cada valor numérico, y bigint y symbol existen para los casos raros. Los tipos también se convierten entre sí, llamado coerción, y operadores es donde eso comienza a importar, así que mantenlo en la parte trasera de tu mente.

Hacia dónde van los tipos desde aquí

Cada valor que escribes, cada uno que lees de vuelta, lleva un tipo, y adquirir fluidez al nombrarlo es la base para todo lo que sigue. Los próximos capítulos toman los dos que manejarás más y profundizan: cadenas para trabajar con texto, y números para cálculo. Después de eso, operadores es donde estos tipos comienzan a encontrarse, compararse, combinarse y ocasionalmente convertirse, y saber qué tipo estás sosteniendo es lo que evita que te sorprenda.