Tipos de Datos y Conversiones en JavaScript

Una variable en JavaScript puede contener cualquier dato. Una variable puede ser en un momento una cadena y luego recibir un valor numérico:

// No hay error
let mensaje = "hola";
mensaje = 123456;

Tipos de Datos

Los lenguajes de programación que permiten tales cosas se denominan “tipificados dinámicamente”, lo que significa que hay tipos de datos, pero las variables no están vinculadas a ninguno de ellos.

Hay siete tipos de datos básicos en JavaScript. Aquí estudiaremos los conceptos básicos, y en los próximos capítulos hablaremos de cada uno de ellos en detalle.

Un número

let ​​n = 123;
n = 12.345;

El tipo de número sirve tanto para números enteros como de punto flotante.

Hay muchas operaciones para los números, por ej. multiplicación *, división /, suma +, resta – y así sucesivamente.

Además de los números regulares, existen los llamados “valores numéricos especiales” que también pertenecen a ese tipo: Infinito, -Infinito y NaN.

El infinito representa el infinito matemático ∞. Es un valor especial que es mayor que cualquier número.

Podemos obtenerlo como resultado de la división por cero:

alert(1/0); // Infinito

O simplemente mencionarlo directamente en el código:

alert(Infinity); // Infinito

NaN representa un error computacional. Es el resultado de una operación matemática incorrecta o indefinida, por ejemplo:

alert("no un número"/2); // NaN, tal división es errónea

NaN es pegajoso. Cualquier otra operación con NaN daría NaN:

alert("no es un número" / 2 + 5); // NaN

Entonces, si hay NaN en algún lugar de una expresión matemática, se propaga a todo el resultado.

Hacer matemáticas es seguro en JavaScript. Podemos hacer cualquier cosa: dividir por cero, tratar las cadenas no numéricas como números, etc.

El script nunca se detendrá con un error fatal. En el peor de los casos obtendremos NaN como resultado.

Los valores numéricos especiales pertenecen formalmente al tipo “número”. Por supuesto que no son números en el sentido común de esta palabra.

Veremos más sobre cómo trabajar con números en el capítulo Números.

Una cadena

Una cadena en JavaScript debe estar entre comillas.

let str = "hola";
let str2 = 'Las comillas simples también estén bien';
let frase = `puede incrustar ${str}`;

En JavaScript, hay 3 tipos de comillas.

1. Comillas dobles: “Hola”.
2. Comillas simples: ‘Hola’.
3. Backticks: `Hola`.

Las comillas dobles y simples son comillas “simples”. No hay diferencia entre ellas en JavaScript.

Backticks son citas de “funcionalidad extendida”. Nos permiten incrustar variables y expresiones en una cadena envolviéndolas en $ {…}, por ejemplo:

let nombre = "Juan";

// incrustar una variable
alert(`Hola, ${nombre}!`); // ¡Hola Juan!

// incrustar una expresión
alert(`el resultado es ${1 + 2}`); // el resultado es 3

La expresión dentro de ${…} se evalúa y el resultado se convierte en parte de la cadena. Podemos poner cualquier cosa allí: una variable como nombre o una expresión aritmética como 1 + 2 o algo más complejo.

Tenga en cuenta que esto solo se puede hacer en backticks. Otras citas no permiten tal incrustación.

No hay ningún tipo para carácter

En algunos idiomas, hay un tipo especial de “carácter” para un solo carácter. Por ejemplo, en el lenguaje C y en Java es char.

En JavaScript, no hay tal tipo. Sólo hay un tipo: cadena. Una cadena puede constar de un solo carácter o muchos de ellos.

Un booleano (tipo lógico)

El tipo booleano tiene solo dos valores: verdadero y falso.

Este tipo se usa comúnmente para almacenar valores de sí / no: verdadero significa “sí, correcto”, y falso significa “no, incorrecto”.

Por ejemplo:

let nameFieldChecked = true; // sí, el campo de nombre está marcado
let ageFieldChecked = false; // no, el campo de edad no está marcado

Los valores booleanos también vienen como resultado de comparaciones:

let esmayor = 4>1;

alert(esmayor); // verdadero (el resultado de la comparación es "sí")

Cubriremos los booleanos con mayor profundidad más adelante en el capítulo Operadores lógicos.

El valor “null”

El valor nulo especial no pertenece a ningún tipo de los descritos anteriormente.

Forma un tipo separado propio, que contiene solo el valor nulo:

let age = null;

En JavaScript, null no es una “referencia a un objeto no existente” o un “puntero nulo” como en otros idiomas.

Es solo un valor especial que tiene el sentido de “nada”, “vacío” o “valor desconocido”.

El código anterior indica que la edad es desconocida o está vacía por alguna razón.

El valor “undefined”

El valor especial indefinido se destaca. Hace un tipo propio, al igual que nulo.

El significado de indefinido es “valor no asignado”.

Si una variable se declara, pero no se asigna, entonces su valor es exactamente indefinido:

let x;
alert(x); // muestra "indefinido"

Técnicamente, es posible asignar indefinido a cualquier variable:

let ​​x = 123;

x = undefined;

alert(x); // "indefinido"

… Pero no se recomienda hacer eso. Normalmente, usamos null para escribir un valor “vacío” o “desconocido” en la variable, y undefined solo se usa para verificaciones, para ver si la variable está asignada o es similar.

Objetos y Símbolos

El tipo de objeto object es especial.

Todos los demás tipos se llaman “primitivos”, porque sus valores pueden contener una sola cosa (ya sea una cadena o un número o lo que sea). En contraste, los objetos se utilizan para almacenar colecciones de datos y entidades más complejas. Trataremos con ellos más adelante en el capítulo Objetos después de que sepamos lo suficiente acerca de los primitivos.

El tipo de símbolo se utiliza para crear identificadores únicos para los objetos. Tenemos que mencionarlo aquí para completar, pero es mejor estudiarlos después de los objetos.

El operador de typeof

El operador typeof devuelve el tipo del argumento. Es útil cuando queremos procesar valores de diferentes tipos de manera diferente, o simplemente queremos hacer una verificación rápida.

Es compatible con dos formas de sintaxis:

Como operador: typeof x.
Estilo de la función: typeof (x).

En otras palabras, funciona con paréntesis o sin ellos. El resultado es el mismo.

La llamada a typeof x devuelve una cadena con el nombre de tipo:

typeof undefined // "indefinido"

typeof 0 // "número"

typeof true // "booleano"

typeof "foo" // "string"

typeof Symbol ("id") // "symbol"

typeof Math // "objeto" (1)

typeof null // "objeto" (2)

typeof alert// "función" (3)

Las últimas tres líneas pueden necesitar explicaciones adicionales:

Las matemáticas Math son un objeto incorporado que proporciona operaciones matemáticas. Lo aprenderemos en el capítulo Números. Aquí sirve solo como un ejemplo de un objeto.

El resultado de typeof null es “objeto”. Eso está mal. Es un error reconocido oficialmente en typeof, mantenido por compatibilidad. Por supuesto, nulo no es un objeto. Es un valor especial con un tipo propio separado. Entonces, de nuevo, eso es un error en el idioma.

El resultado de typeof alert es “function”, porque alert es una función del lenguaje. Estudiaremos las funciones en los próximos capítulos y veremos que no hay un tipo especial de “función” en el idioma. Las funciones pertenecen al tipo de objeto. Pero typeof los trata de manera diferente.

Tipo de conversiones

La mayoría de las veces, los operadores y las funciones convierten automáticamente un valor al tipo correcto. Eso se llama “conversión de tipo”.

Por ejemplo, alert convierte automáticamente cualquier valor en una cadena para mostrarlo. Las operaciones matemáticas convierten los valores en números.

También hay casos en los que necesitamos convertir explícitamente un valor para corregir las cosas.

Aún no hablamos de objetos.

En este capítulo todavía no cubrimos los objetos. Aquí estudiamos los primitivos primero. Más adelante, después de aprender los objetos, veremos cómo funciona la conversión de objetos.

A String

La conversión de cadena ocurre cuando necesitamos la forma de cadena de un valor.

Por ejemplo, alert (valor) lo hace para mostrar el valor.

También podemos usar una función String(valor) para eso:

let valor = true;
alert (typeof valor); // booleano

value = String (value); // ahora el valor es una cadena "true"
alert (typeof valor); // cadena

La conversión de cadenas es en su mayoría obvia. Un falso se convierte en “falso”, nulo se convierte en “nulo”, etc.

A Número

La conversión numérica ocurre en funciones matemáticas y expresiones automáticamente.

Por ejemplo, cuando la división / se aplica a los no números:

alert ("6" / "2"); // 3, las cadenas se convierten en números

Podemos usar una función de Número (valor) para convertir explícitamente un valor:

let str = "123";
alert (typeof str); // cuerda
let num = Number (str); // se convierte en un número 123
alert (typeof num); // numero

La conversión explícita generalmente se requiere cuando leemos un valor de una fuente basada en cadenas como un formulario de texto, pero esperamos que se ingrese un número.

Si la cadena no es un número válido, el resultado de dicha conversión es NaN, por ejemplo:

let edad = Number ("una cadena arbitraria en lugar de un número");
alert (edad); // NaN, error de conversión

La adición “+” concatena cadenas

Casi todas las operaciones matemáticas convierten valores en números. Con una notable excepción de la adición +. Si uno de los valores agregados es una cadena, entonces otra también se convierte en una cadena.

Luego los concatena (une):

alert (1 + '2'); // '12' (cadena a la derecha)
alert ('1' + 2); // '12' (cadena a la izquierda)

Eso solo sucede cuando uno de los argumentos es una cadena. De lo contrario, los valores se convierten en números.

A Boolean

La conversión booleana es la más sencilla.

Ocurre en operaciones lógicas (más adelante cumpliremos con las pruebas de condición y otros tipos de ellas), pero también se puede realizar manualmente con la llamada de Boolean (valor).

Los valores que están intuitivamente “vacíos”, como 0, una cadena vacía, nula, indefinida y NaN se vuelven falsos.

Por ejemplo:

alert (Boolean (1)); // cierto
alert (Boolean (0)); // falso

alert (Boolean ("hola")); // cierto
alert (Boolean ("")); // falso

Tenga en cuenta: la cadena con cero “0” es verdadera

Written by Tutor