2. ¿Cuáles son algunos tipos de datos JS? - KatherineAGM/Checkpoint-7 GitHub Wiki

En JavaScript, los tipos de datos son clasificaciones que definen la naturaleza de un valor o una pieza de información que se almacena en una variable. En términos más simples, le dicen a JavaScript qué tipo de "cosa" es un dato, lo que a su vez determina como JavaScript puede interactuar y operar con él.

Piensa en los tipos de datos como categorías para la información:

  • ¿Es un número? (Para hacer cálculos)
  • ¿Es texto? (Para mostrar mensajes)
  • ¿Es verdadero o falso? (Para tomar decisiones)
  • ¿Es una colección de cosas? (Para agrupar información)

Características clave de los tipos de datos en JavaScript:

  1. Tipado Dinámico (Dynamic Typing):

  • Esta es una de las características más importantes de JavaScript en relación con sus tipos de datos. Significa que no necesitas declarar explícitamente el tipo de dato de una variable cuando la creas. JavaScript lo deduce automáticamente en tiempo de ejecución basándose en el valor que le asignes.

  • Además, el tipo de una variable puede cambiar durante la ejecución del programa. Si una variable almacena un número y luego le asignas una cadena de texto, JavaScript lo acepta sin problemas.

  • Esto contrasta con lenguajes de tipado estático (como Java o C++), donde debes especificar el tipo de una variable (int numero; String texto;) y ese tipo no puede cambiar después de la declaración.

  1. Tipado Débil (Weak Typing / Loose Typing):

  • Significa que JavaScript es bastante flexible en cómo maneja los tipos de datos en operaciones. A menudo, JavaScript realizará coerciones de tipo (conversiones automáticas de tipos) para intentar que las operaciones funcionen.

  • Esta flexibilidad puede ser conveniente, pero también puede llevar a comportamientos inesperados si no se comprenden las reglas de coerción.

Categorías de Tipos de Datos en JavaScript:

Como mencioné anteriormente, los tipos de datos se agrupan en dos categorías principales:

  1. Tipos Primitivos:

  • Representan valores únicos y simples.

  • Son inmutables, lo que significa que una vez creados, sus valores no pueden ser modificados directamente. Si "cambias" un valor primitivo, en realidad estás creando un nuevo valor.

  • Incluyen: String, Number, BigInt, Boolean, Undefined, Null, Symbol.

  1. Tipos No Primitivos (Objetos):

  • Representan colecciones de valores o entidades más complejas.

  • Son mutables, lo que significa que sus propiedades internas pueden ser modificadas después de su creación.

  • El tipo principal es Object. Arrays, funciones, fechas, etc., son variaciones especializadas de Object.

¿Por qué son importantes los tipos de datos?

  • Operaciones: El tipo de dato determina qué operaciones se pueden realizar con él (ej: no puedes multiplicar texto).

  • Comportamiento: Influye en cómo se comporta el código (ej: el + opera diferente con números que con cadenas).

  • Uso de memoria: Aunque JavaScript lo gestiona internamente, diferentes tipos de datos requieren diferentes cantidades de memoria.

  • Depuración: Comprender los tipos de datos es crucial para entender por qué tu código no funciona como esperas (especialmente con el tipado débil y las coerciones).

Tipos de Datos Primitivos (7 tipos)

Los tipos de datos primitivos son inmutables (no se pueden cambiar directamente una vez creados) y representan un único valor.

  1. String (Cadena de texto):

  • Representa secuencias de caracteres (texto).

  • Se encierran entre comillas simples (' '), dobles (" ") o backticks (`). Los backticks () permiten "template literals", que son cadenas con expresiones incrustadas y soporte para múltiples líneas.

Ejemplos:

let nombre = "Juan";
let saludo = 'Hola';
let mensaje = `Mi nombre es ${nombre}`; // Template literal
  1. Number (Número):

  • Representa tanto números enteros como números de punto flotante (decimales).

  • JavaScript no distingue entre enteros y flotantes como otros lenguajes.

  • Incluye valores especiales como Infinity (infinito positivo), -Infinity (infinito negativo) y NaN (Not-a-Number, un valor que representa un resultado numérico inválido).

Ejemplos:

let edad = 30;
let precio = 19.99;
let resultado = 0 / 0; // NaN
let infinito = 1 / 0; // Infinity
  1. BigInt (Entero Grande):

  • Introducido más recientemente en ES2020.

  • Representa números enteros de precisión arbitraria, lo que significa que pueden almacenar números enteros mucho más grandes que los que puede manejar el tipo Number.

  • Se crea añadiendo n al final de un literal numérico.

Ejemplos:

let numeroMuyGrande = 9007199254740991n; // Número mayor que Number.MAX_SAFE_INTEGER
  1. Boolean (Booleano):

  • Representa un valor lógico: true (verdadero) o false (falso).

  • Se utiliza comúnmente para la lógica condicional.

Ejemplos:

let estaActivo = true;
let esMayorDeEdad = false;
  1. Undefined (Indefinido):

  • Indica que una variable ha sido declarada pero aún no se le ha asignado un valor.

  • También es el valor que devuelve una función que no tiene una declaración de return explícita o que se llama sin argumentos opcionales.

Ejemplos:

let miVariable; // miVariable es undefined
console.log(miVariable); // undefined
  1. Null (Nulo):

  • Representa la ausencia intencionada de cualquier valor de objeto.

  • Es un valor que el desarrollador asigna explícitamente para indicar "sin valor".

  • Aunque typeof null devuelve "object", null es un tipo primitivo. Esto es considerado un "error histórico" en JavaScript.

Ejemplos:

let carritoDeCompras = null; // El carrito está vacío
  1. Symbol (Símbolo):

  • Introducido en ES6 (ECMAScript 2015).

  • Representa un valor único e inmutable, que puede ser utilizado como clave para propiedades de objetos.

  • Cada Symbol creado es único, incluso si tienen la misma descripción. Esto es útil para evitar colisiones de nombres de propiedades.

Ejemplos:

const id = Symbol('id');
const otroId = Symbol('id');
console.log(id === otroId); // false (son únicos)

Tipo de Dato No Primitivo (1 tipo principal)

Los tipos no primitivos son mutables y se refieren a colecciones de valores o entidades más complejas.

  1. Object (Objeto):

  • Es el tipo de dato fundamental para todas las estructuras de datos complejas en JavaScript.

  • Representa una colección de propiedades, donde cada propiedad tiene un nombre (clave) y un valor. Los valores pueden ser de cualquier tipo de dato, incluyendo otros objetos.

  • Las funciones, arrays, fechas y expresiones regulares son, técnicamente, subtipos de Object en JavaScript.

Ejemplos:

// Objeto literal
let persona = {
    nombre: "Ana",
    edad: 25,
    profesion: "Ingeniera"
};

// Array (que es un tipo especial de Objeto)
let numeros = [1, 2, 3, 4, 5];

// Función (que también es un tipo especial de Objeto)
function saludar() {
    console.log("Hola");
}

// Fecha (Objeto Date)
let hoy = new Date();

La importancia de typeof

Puedes usar el operador typeof para verificar el tipo de dato de una variable o valor.

console.log(typeof "Hola");       // "string"
console.log(typeof 123);          // "number"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof null);         // "object" (¡la famosa excepción!)
console.log(typeof Symbol('foo'));// "symbol"
console.log(typeof 10n);          // "bigint"
console.log(typeof {});           // "object"
console.log(typeof []);           // "object"
console.log(typeof function(){}); // "function" (aunque es un tipo especial de objeto)