Un valor en JavaScript siempre es de un tipo determinado. Por ejemplo, una cadena o un número.
Hay ocho tipos de datos básicos en JavaScript. Aquí los cubriremos en general y en los próximos capítulos hablaremos de cada uno de ellos en detalle.
Podemos poner cualquier tipo en una variable. Por ejemplo, una variable puede en un momento ser una cadena y luego almacenar un número:
//sin errores dejar mensaje = "hola"; mensaje = 123456;
Los lenguajes de programación que permiten este tipo de cosas, como JavaScript, se denominan "tipados dinámicamente", lo que significa que existen tipos de datos, pero las variables no están vinculadas a ninguno de ellos.
sea n = 123; norte = 12,345;
El tipo de número representa números enteros y de coma flotante.
Hay muchas operaciones con números, por ejemplo, multiplicación * , división / , suma + , resta - , etc.
Además de los números normales, también pertenecen a este tipo de datos los llamados “valores numéricos especiales”: Infinity , -Infinity y NaN .
Infinity 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:
alerta (1/0); // Infinidad
O simplemente haga referencia a él directamente:
alerta (Infinito); // Infinidad
NaN representa un error computacional. Es el resultado de una operación matemática incorrecta o indefinida, por ejemplo:
alerta( "no es un número" / 2 ); // NaN, dicha división es errónea
NaN es pegajoso. Cualquier operación matemática adicional en NaN devuelve NaN :
alerta (NaN + 1); //NaN alerta (3 * NaN); //NaN alerta( "no es un número" / 2 - 1 ); //NaN
Entonces, si hay un NaN en algún lugar de una expresión matemática, se propaga al resultado completo (solo hay una excepción: NaN ** 0 es 1 ).
Las operaciones matemáticas son seguras
Hacer matemáticas es "seguro" en JavaScript. Podemos hacer cualquier cosa: dividir por cero, tratar cadenas no numéricas como números, etc.
El guión nunca se detendrá ante un error fatal (“morir”). 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.
En JavaScript, el tipo "número" no puede representar de forma segura valores enteros mayores que (2 53 -1) (es decir, 9007199254740991 ), o menores que -(2 53 -1) para negativos.
Para ser realmente precisos, el tipo “número” puede almacenar números enteros más grandes (hasta 1.7976931348623157 * 10 308 ), pero fuera del rango de enteros seguro ±(2 53 -1) habrá un error de precisión, porque no todos los dígitos encajan. en el almacenamiento fijo de 64 bits. Por tanto, se puede almacenar un valor "aproximado".
Por ejemplo, estos dos números (justo encima del rango seguro) son iguales:
console.log(9007199254740991 + 1); // 9007199254740992 console.log(9007199254740991 + 2); // 9007199254740992
Por así decirlo, todos los números enteros impares mayores que (2 53 -1) no se pueden almacenar en absoluto en el tipo "número".
Para la mayoría de los propósitos, el rango ±(2 53 -1) es suficiente, pero a veces necesitamos todo el rango de números enteros realmente grandes, por ejemplo, para criptografía o marcas de tiempo con precisión de microsegundos.
El tipo BigInt se agregó recientemente al lenguaje para representar números enteros de longitud arbitraria.
Un valor BigInt se crea añadiendo n al final de un número entero:
// la "n" al final significa que es BigInt const bigInt = 1234567890123456789012345678901234567890n;
Como los números BigInt rara vez se necesitan, no los cubrimos aquí, pero les dedicamos un capítulo separado de BigInt. Léelo cuando necesites números tan grandes.
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 otro ${str}`;En JavaScript, existen 3 tipos de comillas.
Comillas dobles: "Hello" .
Comillas simples: 'Hello' .
Comillas invertidas: `Hello` .
Las comillas dobles y simples son comillas "simples". Prácticamente no hay diferencia entre ellos en JavaScript.
Las comillas invertidas son comillas de “funcionalidad extendida”. Nos permiten incrustar variables y expresiones en una cadena envolviéndolas en ${…} , por ejemplo:
let nombre = "Juan";
// incrustar una variable
alerta(`¡Hola, ${nombre}!`); // ¡Hola, Juan!
// incrustar una expresión
alerta(`el resultado es ${1 + 2}`); // el resultado es 3 La expresión dentro de ${…} se evalúa y el resultado pasa a formar parte de la cadena. Podemos poner cualquier cosa ahí: una variable como name o una expresión aritmética como 1 + 2 o algo más complejo.
Tenga en cuenta que esto sólo se puede hacer entre comillas invertidas. ¡Otras citas no tienen esta funcionalidad de incrustación!
alerta( "el resultado es ${1 + 2}" ); // el resultado es ${1 + 2} (las comillas dobles no hacen nada)Cubriremos las cadenas más a fondo en el capítulo Cadenas.
No hay ningún tipo de personaje .
En algunos idiomas, existe un tipo de “carácter” especial para un solo carácter. Por ejemplo, en el lenguaje C y en Java se llama “char”.
En JavaScript, no existe tal tipo. Sólo hay un tipo: string . Una cadena puede constar de cero caracteres (estar vacía), un carácter o muchos de ellos.
El tipo booleano tiene sólo dos valores: true y false .
Este tipo se usa comúnmente para almacenar valores de sí/no: true significa "sí, correcto" y false significa "no, incorrecto".
Por ejemplo:
let nameFieldChecked = true; // sí, el campo de nombre está marcado let ageFieldChecked = false; // no, el campo edad no está marcado
Los valores booleanos también surgen como resultado de comparaciones:
seaMayor = 4 > 1; alerta (es mayor); // verdadero (el resultado de la comparación es "sí")
Cubriremos los valores booleanos con más profundidad en el capítulo Operadores lógicos.
El valor null especial no pertenece a ninguno de los tipos descritos anteriormente.
Forma un tipo independiente propio que contiene sólo el valor null :
let edad = nula;
En JavaScript, null no es una "referencia a un objeto inexistente" o un "puntero nulo" como en otros lenguajes.
Es sólo un valor especial que representa "nada", "vacío" o "valor desconocido".
El código anterior indica que se desconoce age .
Destaca también el valor especial undefined . Crea un tipo propio, al igual que null .
El significado de undefined es "valor no asignado".
Si una variable está declarada, pero no asignada, entonces su valor undefined está definido:
dejar envejecer; alerta (edad); // muestra "indefinido"
Técnicamente, es posible asignar explícitamente undefined a una variable:
sea edad = 100; // cambia el valor a indefinido edad = indefinida; alerta (edad); // "indefinido"
…Pero no recomendamos hacer eso. Normalmente, se usa null para asignar un valor “vacío” o “desconocido” a una variable, mientras que undefined se reserva como valor inicial predeterminado para cosas no asignadas.
El tipo object es especial.
Todos los demás tipos se denominan "primitivos" porque sus valores sólo pueden contener una sola cosa (ya sea una cadena, un número o lo que sea). Por el contrario, los objetos se utilizan para almacenar colecciones de datos y entidades más complejas.
Siendo tan importantes los objetos merecen un trato especial. Nos ocuparemos de ellos más adelante en el capítulo Objetos, después de que aprendamos más sobre las primitivas.
El tipo symbol se utiliza para crear identificadores únicos para objetos. Tenemos que mencionarlo aquí en aras de la exhaustividad, pero también posponer los detalles hasta que conozcamos los objetos.
El operador typeof devuelve el tipo de operando. Es útil cuando queremos procesar valores de diferentes tipos de manera diferente o simplemente queremos hacer una verificación rápida.
Una llamada a typeof x devuelve una cadena con el nombre del tipo:
tipo de indefinido // "indefinido"
tipo de 0 // "número"
tipo de 10n // "bigint"
tipo de verdadero // "booleano"
tipo de "foo" // "cadena"
tipo de Símbolo("id") // "símbolo"
tipo de Matemáticas // "objeto" (1)
tipo de nulo // "objeto" (2)
tipo de alerta // "función" (3)Las últimas tres líneas pueden necesitar una explicación adicional:
Math es un objeto integrado que proporciona operaciones matemáticas. Lo aprenderemos en el capítulo Números. Aquí, sirve sólo como ejemplo de un objeto.
El resultado de typeof null es "object" . Se trata de un error oficialmente reconocido en typeof , que proviene de los primeros días de JavaScript y se mantiene por motivos de compatibilidad. Definitivamente, null no es un objeto. Es un valor especial con un tipo propio e independiente. El comportamiento de typeof es incorrecto aquí.
El resultado de typeof alert es "function" , porque alert es una función. Estudiaremos funciones en los próximos capítulos donde también veremos que no existe un tipo de "función" especial en JavaScript. Las funciones pertenecen al tipo de objeto. Pero typeof los trata de manera diferente y devuelve "function" . Esto también proviene de los primeros días de JavaScript. Técnicamente, este comportamiento no es correcto, pero puede resultar conveniente en la práctica.
La sintaxis typeof(x)
También puedes encontrarte con otra sintaxis: typeof(x) . Es lo mismo que typeof x .
Para dejarlo claro: typeof es un operador, no una función. Los paréntesis aquí no forman parte de typeof . Es el tipo de paréntesis que se utiliza para la agrupación matemática.
Por lo general, estos paréntesis contienen una expresión matemática, como (2 + 2) , pero aquí contienen solo un argumento (x) . Sintácticamente, permiten evitar un espacio entre el operador typeof y su argumento, y a algunas personas les gusta.
Algunas personas prefieren typeof(x) , aunque la sintaxis typeof x es mucho más común.
Hay 8 tipos de datos básicos en JavaScript.
Siete tipos de datos primitivos:
number para números de cualquier tipo: entero o de punto flotante, los números enteros están limitados por ±(2 53 -1) .
bigint para números enteros de longitud arbitraria.
string por cuerdas. Una cadena puede tener cero o más caracteres; no existe un tipo de carácter único independiente.
boolean para true / false .
null para valores desconocidos: un tipo independiente que tiene un único valor null .
undefined para valores no asignados: un tipo independiente que tiene un valor único undefined .
symbol para identificadores únicos.
Y un tipo de datos no primitivo:
object para estructuras de datos más complejas.
El operador typeof nos permite ver qué tipo está almacenado en una variable.
Generalmente se usa como typeof x , pero typeof(x) también es posible.
Devuelve una cadena con el nombre del tipo, como "string" .
Para null devuelve "object" : esto es un error en el idioma, en realidad no es un objeto.
En los próximos capítulos, nos concentraremos en los valores primitivos y una vez que estemos familiarizados con ellos, pasaremos a los objetos.
importancia: 5
¿Cuál es el resultado del guión?
let nombre = "Ilya";
alerta(`hola ${1}`); // ?
alerta(`hola ${"nombre"}`); // ?
alerta(`hola ${nombre}`); // ?
Las comillas invertidas incrustan la expresión dentro de ${...} en la cadena.
let nombre = "Ilya";
// la expresión es un número 1
alerta(`hola ${1}`); // hola 1
// la expresión es una cadena "nombre"
alerta(`hola ${"nombre"}`); // hola nombre
// la expresión es una variable, incrustarla
alerta(`hola ${nombre}`); // hola ilya