Los programas informáticos manejan grandes cantidades de datos. ¿Por qué clasificarlos?

• Para una utilización más eficiente y completa de la memoria.
• Para facilitar el manejo de datos por parte de los programadores.

Los tipos de datos se dividen en dos categorías principales: tipos primitivos y tipos de referencia.

Tipos primitivos:

• number: tipo numérico
• string: tipo cadena de texto
• boolean: tipo booleano
• undefined: tipo no definido
• null: tipo nulo

Tipos de referencia:

• object: tipo objeto
• function: tipo función
• array: tipo arreglo

1.1 number - Tipo numéricco

A diferencia de Java, JavaScript es un lenguaje de tipado débil, por lo que number representa todos los números, incluyendo enteros, decimales, positivos y negativos.

El tipado débil significa que solo después de asignar un valor podemos determinar a qué tipo pertenece una variable.

let edad = 18;
let calificacion = 18.2;
let nombre = 'Carlos' - 1;     // nombre ahora es NaN
console.log(NaN + 1);     // NaN

NaN: Representa un error. Es el resultado de una operación matemática incorrecta o no definida. NaN es pegajoso; cualquier operación con NaN devuelve NaN.

1.2 string - Tipo cadena de texto

Datos encerrados entre comillas simples (''), dobles ("") o comillas invertidas (``) se denominan cadenas. Se recomienda usar comillas simples.

Nota:

• Las comillas deben usarse en pares.
• Las comillas simples o dobles pueden anidarse entre sí, pero no pueden anidarse consigo mismas.
• Se pueden usar caracteres de escape \\ cuando sea necesario para mostrar comillas.

Concatenación de cadenas: Se puede usar + para concatenar cadenas. Sin embargo, hay un método más conveniente: las cadenas de plantilla.

Cadenas de plantilla:

• Se usan comillas invertidas ``.
• Para insertar variables, se encierran con ${}.

// Antes
document.write('Hola, soy ' + nombre + ' y tengo ' + edad + ' años');
// Después
document.write(`Hola, soy ${nombre} y tengo ${edad} años`);

1.3 boolean - Tipo booleano

El tipo booleano se utiliza para representar afirmaciones o negaciones en computación. Tiene dos valores fijos: true y false.

1.4 undefined - Tipo no definido

Es un tipo especial con un solo valor, undefined. ¿Cuándo aparece? Cuando una variable se declara pero no se asigna un valor, su valor por defecto es undefined. Normalmente, no se asigna undefined directamente.

Casos de uso: En el desarrollo, a menudo se declara una variable para recibir datos. Si no se sabe si los datos han llegado, se puede verificar si la varible es undefined para determinar si el usuario ha proporcionado datos.

1.5 null - Tipo nulo

Se usa únicamente para representar "nada", "vacío" o "valor desconocido".

Diferencia entre null y undefined:

• undefined indica que no se ha asignado un valor.
• null indica que se ha asignado un valor, pero está vacío.

Casos de uso: Se usa null como marcador para objetos aún no creados. Si una variable almacenará un objeto que no se ha creado, se puede asignar null temporalmente.

2. Detección de tipos de datos

2.1 Mediante declaraciones de salida en consola

Al imprimir en consola, los números y booleanos aparecen en color azul, mientras que las cadenas y undefined aparecen en gris.

2.2 Mediante la palabra clave typeof

El operador typeof devuelve el tipo de datos del operando. Soporta dos sintaxis:

• Como operador: typeof x (recomendado)
• En forma de función: typeof(x)

3. Conversión de tipos

¿Por qué convertir tipos? JavaScript tiene tipado débil: no conoce el tipo de datos de una varible hasta que se le asigna un valor. Sin embargo, al usar formularios o prompt, los datos obtenidos son cadenas por defecto, lo que impide realizar operaciones aritméticas directamente.

console.log('1000' + '200');    // No imprime 1200, sino 1000200

Por lo tanto, es necesario convertir variables de un tipo de datos a otro requerido.

3.1 Conversión implícita

Cuando se ejecutan ciertos operadores, el sistema convierte automáticamente los tipos de datos internamente. Esto se llama conversión implícita.

Reglas:

• Si al menos uno de los operandos de + es una cadena, el otro se convierte a cadena.
• Los operadores aritméticos distintos de + (como -, \*, /) convierten los datos a tipo numérico.

Casos especiales:

• El operador + como signo positivo puede convertir una cadena a número.
• Cualquier dato concatenado con una cadena resulta en una cadena.

<script>
    console.log(11 + 11);    // 22
    console.log('11' + 11);  // 1111
    console.log(11 - 11);    // 0
    console.log('11' - 11);  // 0
    console.log(1 * 1);      // 1
    console.log('1' * 1);    // 1
    console.log(typeof '123');   // string
    console.log(typeof +'123');  // number
    console.log(+'11' + 11);     // 22
    let valor1 = prompt('Ingrese valor1');     // valor1 es de tipo string
    let valor2 = +prompt('Ingrese valor2');    // valor2 es de tipo number
</script>

3.2 Conversión explícita

Confiar excesivamente en la conversión implícita no es seguro, ya que sus reglas no son claras y se basan en experiencia. Para evitar problemas, se realiza conversión explícita según la lógica.

Conversión a tipo numérico:

• Number(dato): Convierte a tipo numérico. Si la cadena contiene caracteres no numéricos, falla y muestra NaN (Not a Number), que es de tipo number pero representa un valor no numérico.
• parseInt(dato): Conserva solo la parte entera. Lee de izquierda a derecha; si encuentra números primero, los extrae, pero si encuentra no-numéricos primero, devuelve NaN.
• parseFloat(dato): Conserva decimales.

Conversión a tipo cadena:

• Número + ``
• String(dato)
• variable.toString(): Puede incluir un argumento para la base numérica.

Conversión a tipo booleano:

• Boolean(contenido): Los valores 0, '', undefined, null, false y NaN se convierten a false; todos los demás a true.