Um valor em JavaScript é sempre de um determinado tipo. Por exemplo, uma string ou um número.
Existem oito tipos básicos de dados em JavaScript. Aqui iremos abordá-los de forma geral e nos próximos capítulos falaremos detalhadamente sobre cada um deles.
Podemos colocar qualquer tipo em uma variável. Por exemplo, uma variável pode em um momento ser uma string e depois armazenar um número:
//nenhum erro deixe mensagem = "olá"; mensagem = 123456;
Linguagens de programação que permitem tais coisas, como JavaScript, são chamadas de “tipagem dinâmica”, o que significa que existem tipos de dados, mas variáveis não estão vinculadas a nenhum deles.
seja n = 123; n = 12,345;
O tipo number representa números inteiros e de ponto flutuante.
Existem muitas operações para números, por exemplo, multiplicação * , divisão / , adição + , subtração - e assim por diante.
Além dos números regulares, existem os chamados “valores numéricos especiais” que também pertencem a este tipo de dados: Infinity , -Infinity e NaN .
Infinity representa o infinito matemático ∞. É um valor especial maior que qualquer número.
Podemos obtê-lo como resultado da divisão por zero:
alerta(1/0); // Infinito
Ou apenas referencie-o diretamente:
alerta(infinito); // Infinito
NaN representa um erro computacional. É o resultado de uma operação matemática incorreta ou indefinida, por exemplo:
alert("não é um número" / 2 ); // NaN, tal divisão está errada NaN é pegajoso. Qualquer operação matemática adicional em NaN retorna NaN :
alerta(NaN + 1); //NaN
alerta(3 *NaN); //NaN
alert("não é um número" / 2 - 1 ); //NaN Portanto, se houver um NaN em algum lugar de uma expressão matemática, ele se propagará para todo o resultado (há apenas uma exceção: NaN ** 0 é 1 ).
Operações matemáticas são seguras
Fazer matemática é “seguro” em JavaScript. Podemos fazer qualquer coisa: dividir por zero, tratar strings não numéricas como números, etc.
O script nunca irá parar com um erro fatal (“morrer”). Na pior das hipóteses, obteremos NaN como resultado.
Valores numéricos especiais pertencem formalmente ao tipo “número”. É claro que não são números no sentido comum da palavra.
Veremos mais sobre como trabalhar com números no capítulo Números.
Em JavaScript, o tipo “número” não pode representar com segurança valores inteiros maiores que (2 53 -1) (isto é 9007199254740991 ) ou menores que -(2 53 -1) para negativos.
Para ser realmente preciso, o tipo “número” pode armazenar números inteiros maiores (até 1.7976931348623157 * 10 308 ), mas fora do intervalo de números inteiros seguros ±(2 53 -1) haverá um erro de precisão, porque nem todos os dígitos cabem no armazenamento fixo de 64 bits. Portanto, um valor “aproximado” pode ser armazenado.
Por exemplo, estes dois números (logo acima da faixa segura) são iguais:
console.log(9007199254740991+1); //9007199254740992 console.log(9007199254740991 + 2); //9007199254740992
Por assim dizer, todos os números inteiros ímpares maiores que (2 53 -1) não podem ser armazenados no tipo “número”.
Para a maioria dos propósitos, o intervalo ±(2 53 -1) é suficiente, mas às vezes precisamos de todo o intervalo de números inteiros realmente grandes, por exemplo, para criptografia ou carimbos de data/hora com precisão de microssegundos.
O tipo BigInt foi adicionado recentemente à linguagem para representar números inteiros de comprimento arbitrário.
Um valor BigInt é criado anexando n ao final de um número inteiro:
// o "n" no final significa que é um BigInt const bigInt = 1234567890123456789012345678901234567890n;
Como os números BigInt raramente são necessários, não os abordamos aqui, mas dedicamos a eles um capítulo separado do BigInt. Leia quando precisar de números tão grandes.
Uma string em JavaScript deve estar entre aspas.
deixe str = "Olá";
let str2 = 'Aspas simples também estão ok';
deixe frase = `pode incorporar outro ${str}`;Em JavaScript, existem 3 tipos de aspas.
Aspas duplas: "Hello" .
Aspas simples: 'Hello' .
Backticks: `Hello` .
Aspas duplas e simples são aspas “simples”. Praticamente não há diferença entre eles em JavaScript.
Backticks são aspas de “funcionalidade estendida”. Eles nos permitem incorporar variáveis e expressões em uma string envolvendo-as em ${…} , por exemplo:
deixe nome = "João";
//incorpora uma variável
alert( `Olá, ${nome}!` ); // Olá, João!
//incorpora uma expressão
alert( `o resultado é ${1 + 2}` ); //o resultado é 3 A expressão dentro de ${…} é avaliada e o resultado passa a fazer parte da string. Podemos colocar qualquer coisa lá: uma variável como name ou uma expressão aritmética como 1 + 2 ou algo mais complexo.
Observe que isso só pode ser feito em crases. Outras citações não possuem essa funcionalidade de incorporação!
alert("o resultado é ${1 + 2}" ); // o resultado é ${1 + 2} (aspas duplas não fazem nada)Abordaremos strings mais detalhadamente no capítulo Strings.
Não há tipo de personagem .
Em alguns idiomas, existe um tipo especial de “caractere” para um único caractere. Por exemplo, na linguagem C e em Java é denominado “char”.
Em JavaScript, não existe esse tipo. Existe apenas um tipo: string . Uma string pode consistir em zero caracteres (estar vazio), um caractere ou muitos deles.
O tipo booleano possui apenas dois valores: true e false .
Este tipo é comumente usado para armazenar valores sim/não: true significa “sim, correto” e false significa “não, incorreto”.
Por exemplo:
deixe nameFieldChecked = true; // sim, o campo nome está marcado deixe ageFieldChecked = falso; // não, o campo idade não está marcado
Os valores booleanos também vêm como resultado de comparações:
seja maior = 4 > 1; alerta(éMaior); // verdadeiro (o resultado da comparação é "sim")
Abordaremos os booleanos mais profundamente no capítulo Operadores lógicos.
O valor null especial não pertence a nenhum dos tipos descritos acima.
Ele forma um tipo separado que contém apenas o valor null :
deixe idade = nulo;
Em JavaScript, null não é uma “referência a um objeto inexistente” ou um “ponteiro nulo” como em algumas outras linguagens.
É apenas um valor especial que representa “nada”, “vazio” ou “valor desconhecido”.
O código acima afirma que age é desconhecida.
O valor especial undefined também se destaca. Ele cria um tipo próprio, assim como null .
O significado de undefined é “valor não atribuído”.
Se uma variável for declarada, mas não atribuída, então seu valor será undefined :
deixe envelhecer; alerta(idade); // mostra "indefinido"
Tecnicamente, é possível atribuir explicitamente undefined a uma variável:
deixe idade = 100; // altera o valor para indefinido idade = indefinida; alerta(idade); // "indefinido"
…Mas não recomendamos fazer isso. Normalmente, usa-se null para atribuir um valor “vazio” ou “desconhecido” a uma variável, enquanto undefined é reservado como valor inicial padrão para coisas não atribuídas.
O tipo object é especial.
Todos os outros tipos são chamados de “primitivos” porque seus valores podem conter apenas uma única coisa (seja uma string, um número ou qualquer outra coisa). Em contraste, os objetos são usados para armazenar coleções de dados e entidades mais complexas.
Por serem tão importantes, os objetos merecem um tratamento especial. Trataremos deles mais adiante no capítulo Objetos, depois de aprendermos mais sobre primitivos.
O tipo symbol é usado para criar identificadores exclusivos para objetos. Temos que mencioná-lo aqui para sermos completos, mas também adiar os detalhes até conhecermos os objetos.
O operador typeof retorna o tipo do operando. É útil quando queremos processar valores de diferentes tipos de maneira diferente ou apenas queremos fazer uma verificação rápida.
Uma chamada para typeof x retorna uma string com o nome do tipo:
typeof indefinido // "indefinido"
typeof 0 // "número"
typeof 10n // "bigint"
typeof true // "booleano"
typeof "foo" // "string"
typeof Símbolo("id") // "símbolo"
typeof Math // "objeto" (1)
typeof null // "objeto" (2)
tipo de alerta // "função" (3)As últimas três linhas podem precisar de explicação adicional:
Math é um objeto integrado que fornece operações matemáticas. Aprenderemos isso no capítulo Números. Aqui, serve apenas como exemplo de objeto.
O resultado de typeof null é "object" . Esse é um erro oficialmente reconhecido em typeof , vindo desde os primeiros dias do JavaScript e mantido para compatibilidade. Definitivamente, null não é um objeto. É um valor especial com um tipo próprio e separado. O comportamento de typeof está errado aqui.
O resultado de typeof alert é "function" , porque alert é uma função. Estudaremos funções nos próximos capítulos, onde também veremos que não existe um tipo especial de “função” em JavaScript. As funções pertencem ao tipo de objeto. Mas typeof os trata de maneira diferente, retornando "function" . Isso também vem dos primeiros dias do JavaScript. Tecnicamente, tal comportamento não é correto, mas pode ser conveniente na prática.
A sintaxe typeof(x)
Você também pode encontrar outra sintaxe: typeof(x) . É o mesmo que typeof x .
Para deixar claro: typeof é um operador, não uma função. Os parênteses aqui não fazem parte de typeof . É o tipo de parênteses usado para agrupamento matemático.
Normalmente, esses parênteses contêm uma expressão matemática, como (2 + 2) , mas aqui eles contêm apenas um argumento (x) . Sintaticamente, eles permitem evitar um espaço entre o operador typeof e seu argumento, e algumas pessoas gostam disso.
Algumas pessoas preferem typeof(x) , embora a sintaxe typeof x seja muito mais comum.
Existem 8 tipos básicos de dados em JavaScript.
Sete tipos de dados primitivos:
number para números de qualquer tipo: inteiro ou ponto flutuante, inteiros são limitados por ±(2 53 -1) .
bigint para números inteiros de comprimento arbitrário.
string para cordas. Uma string pode ter zero ou mais caracteres, não existe um tipo separado de caractere único.
boolean para true / false .
null para valores desconhecidos – um tipo independente que possui um único valor null .
undefined para valores não atribuídos – um tipo independente que possui um único valor undefined .
symbol para identificadores exclusivos.
E um tipo de dados não primitivo:
object para estruturas de dados mais complexas.
O operador typeof nos permite ver qual tipo está armazenado em uma variável.
Geralmente usado como typeof x , mas typeof(x) também é possível.
Retorna uma string com o nome do tipo, como "string" .
Para retornos null "object" – isso é um erro na linguagem, não é realmente um objeto.
Nos próximos capítulos, nos concentraremos nos valores primitivos e, quando estivermos familiarizados com eles, passaremos para os objetos.
importância: 5
Qual é a saída do script?
deixe nome = "Ilya";
alerta( `olá ${1}` ); // ?
alerta( `olá ${"nome"}` ); // ?
alerta( `olá ${nome}` ); // ?
Os crases incorporam a expressão dentro de ${...} na string.
deixe nome = "Ilya";
// a expressão é um número 1
alerta( `olá ${1}` ); // olá 1
// a expressão é uma string "nome"
alerta( `olá ${"nome"}` ); // olá nome
// a expressão é uma variável, incorpore-a
alerta( `olá ${nome}` ); // olá Ilya