Tipos e Dados

Tipagem Dinâmica

Na linguagem Javascript nós trabalhamos com muitos tipos de dados diferentes, existem tipos que representam valores numéricos, tipos que representam textos, tipos que representam conjuntos e listas e entre vários outros que vamos ver nesse conteúdo.

Como foi falado em conteúdos anteriores, vimos que existem 7 tipos diferentes de dados primitivos em javascript, são eles:

Diferente de outras linguagens de programação, onde você precisa declarar variáveis junto com os tipos de dados que cada uma delas armazena, como por exemplo:

string nome = "Lucas";//Variável do tipo 'string' que só pode armazenar valores do tipo texto.
int idade = 28;//Variável do tipo 'int' que só pode armazenar valores do tipo inteiro.

Ainda no exemplo acima, caso tentássemos atribuir um número inteiro em uma variável que é do tipo 'string', isso ocasionará um erro de compilação, pois uma variável do tipo 'string' só armazena textos, e não números.

E essa mesma lógica é aplicada a todos os outros tipos de dados primitivos daquela linguagem.

No Javascript não precisamos fazer essas declarações, pois ela é considerada uma linguagem de tipagem dinâmica, ou seja, é uma característica de determinadas linguagens de programação, que não exigem declarações de tipos de dados, pois são capazes de escolher que tipo de dados deve-se utilizar dinamicamente para cada variável, podendo alterá-lo durante a compilação ou a execução do programa.

Em conteúdos anteriores nós vimos como funciona o processo de declaração de variáveis:

let nome = "Lucas";
let numero = 12;

nome = 12;
numero = "Micilini";

Observe que em nenhum momento eu precisei declarar o tipo de dado que aquela variável vai armazenar.

De um lado, a tipagem "mais flexível" do Javascript ajuda no desenrolar do desenvolvimento, pois você não precisa se preocupar muito quando estiver atribuindo valores para as variáveis.

Por um outro lado, isso pode adicionar uma certa dificuldade quando você tem uma variável que você acha que está armazenando um tipo de dado, quando na verdade esta armazenando um outro tipo.

Pegando o gancho do código visto acima, temos a variável chamada 'numero' que inicialmente armazena um valor numérico, só que mais tarde, atribuímos um texto para essa mesma variável.

Se o desenvolvedor não prestar atenção na lógica do código, esse tipo de erro pode passar despercebido, e dar um grande problema lá na frente.

No caso da tipagem dinâmica do Javascript, não significa que elas não tem um tipo específico, elas tem sim, a diferença é que por ela ser dinâmica, uma hora ela pode ser uma string e na outra um número ou qualquer outro dado, por exemplo.

Descobrindo o Tipo da Variável

No Javascript nós temos o comando chamado typeof, que é muito utilizado para retornar o tipo de valor que aquela variável armazena:

let nome = "Micilini";
console.log(typeof nome);//'string'

Evite usar Nomes Genéricos e Siglas

Pelo javascript utilizar uma tipagem dinâmica, você como desenvolvedor deve evitar utilizar nomes genéricos nas suas variáveis, veja um exemplo:

let valor = "Micilini Roll";//Errado, o termo 'valor' é muito genérico, e não especifica o tipo de dado que aquela variável armazena. Como ele armazena um texto, porque não usar o termo 'nome' ou afins?

let qualquerCoisa = 3,1415926;//Errado, o termo 'qualquerCoisa' dá ideia de qualquer coisa, ou seja, mais uma vez, muuuuito genérico. Como ele armazena um número, porque não colocar 'valorPI' ou afins?

Let ctr = 3;//Errado, apesar do termo 'CTR' remeter ao termo 'taxa de cliques' em inglês (Click Through Rate), prefira usar 'taxaDeCliques' ou o termo em inglês como 'clickThroughRate'.

Lembre-se, o nome da sua variável deve dizer não só para você como também para as outras pessoas que tipo de informação está sendo armazenada ali.

É um endereço? Então diga que é um endereço!

É um nome? Então diga que é um nome!

É um token? Então diga que é um token!

Prefira códigos claros, a usar comentários de códigos. Sendo assim, prefira fazer isso:

let clickThroughRate = 3;

Do que tentar explicar por meio de comentários:

let ctr = 3;//Click Through Rate

String

O tipo STRING representa uma sequência de caracteres, mas que são armazenados dentro de aspas simples ('') ou aspas duplas ("").

Com as novas versões do Javascript, agora é possível usar a crase (``).

let nome = 'Micilini';
let endereco = "Rua dos Sonhos de Mel";
let descricao = `Ele também é conhecido como "MIC"`;

A partir do momento que você declara um número ou qualquer outro tipo de informação dentro de aspas simples, duplas ou crás, automaticamente o sistema reconhece como string, por exemplo:

let numero = '12';//Isso aqui é uma string não um número

Métodos da String

O javascript contém diversos métodos que nos ajudam a trabalhar com o tipo string, vejamos alguns deles:

charAt()

O método retorna o caractere no índice especificado em uma string.

let nome = "Micilini";

let quartoCaracter = nome.charAt(4);//Ele recupera o quarto caractere existente na variável nome

console.log(quartoCaracter);//retorna 'l'

O índice de uma string sempre começa com 0, nesse caso o caractere M está no índice 0.

Se executarmos charAt(99), o javascript não acusará nenhum erro, isso porque a linguagem é um pouco flexível e relaxa nesse sentido.

Diferente de outras linguagens em que selecionar um caractere fora do limite de caracteres de uma string, ocasionaria um erro de compilação.

charCodeAt()

Na computação, qualquer caractere pode ser representado em um formato Unicode, como UTF-32, UTF-16 e afins.

O método retorna um número inteiro entre 0 e 65535 representando a unidade de código UTF-16 no índice fornecido.

let nome = "Micilini";

let utf16Char = nome.charCodeAt(4);//Ele recupera o quarto caractere existente na variável 'nome' em formato UTF-16

console.log(utf16Char);//retorna 108

codePointAt()

O método retorna um inteiro que denota o valor de ponto Unicode de um caractere na string.

let nome = "Micilini";

let unicodeCode = nome.codePointAt(4);//Ele recupera o quarto caractere existente na variável nome em formato UNICODE

console.log(unicodeCode);//retorna 108

concat()

O método concatena os argumentos fornecidos para a string fornecida.

Isso significa que este método é capaz de juntar outras string em uma só.

let nome = "Micilini";

let fraseLegal = nome.concat(" é muito shooow!");

console.log(fraseLegal);//'Micilini é muito shooow!'

endsWith()

O método retorna true se uma string terminar com a string especificada. Caso contrário, o método retorna false.

Esse método é ótimo quando queremos verificar se a string termina com um certo padrão:

let token = "SHAR76a88s@--";

let resultado = token.endsWith("@--");

console.log(resultado);//retorna true

startsWith()

O método retorna true se uma string começar com a string especificada. Caso contrário, o método retorna false.

Esse método é ótimo quando queremos verificar se a string termina com um certo padrão:

let token = "SHAR76a88s@--";

let resultado = token.startsWith("SHAR");

console.log(resultado);//retorna true

fromCharCode()

O método retorna uma string criada a partir da sequência especificada de unidades de código UTF-16.

Ou seja, lembra do comando charCodeAt()? Que pega um determinado caractere da string e transforma em código UTF-16?

Então… o fromCharCode() faz o contrário, ele monta a string de acordo com os códigos que você colocar.

let texto = String.fromCharCode(109,105,99,105,108,105,110,105);
console.log(texto);//'micilini'

Tenha em mente que este método não precisa de uma variável já declara (como vinhamos fazendo em métodos anteriores), aqui estamos usando diretamente o tipo 'String' (String.fromCharCode).

fromCodePoint()

O método retorna uma string criada usando a sequência fornecida de pontos de código unicode.

let abc = String.fromCodePoint(65, 66, 67);
console.log(abc);//'abc'

Tenha em mente que este método não precisa de uma variável já declara (como vinhamos fazendo em métodos anteriores), aqui estamos usando diretamente o tipo 'String' (String.fromCodePoint).

includes()

O método verifica se uma string pode ser encontrada dentro de outra string.

Método muito útil para verificarmos se existe uma determinada cadeia de caracteres declarada dentro de uma string.

const mensagem = "Javascript é show!";
let resultado = menesagem.includes("Java");
console.log(result);//retorna true

indexOf()

O método retorna o índice da primeira ocorrência da substring em uma string.

const mensagem = "Javascript é demais!";
let resultado = mensagem.indexOf("sc");
console.log(resultado);// retorna '4'

Para entender esse comando, concentre-se na frase "Javascript é demais!", ela é composta por 20 caracteres. Sendo o caractere número 1 a letra 'J', e o caractere número 2 a letra 'A', correto?

Sim, está correto!

Quando usamos o comando indexOf, estamos informando o texto "sc". O texto "sc" aparece na frase "Javascript é demais!"?

Sim aparece! Mas a partir de qual caractere?

Fácil, a partir do quarto caracter!

Nesse caso tudo o que o indexOf faz é retornar o índice da primeira ocorrência daquela string.

lastIndexOf()

O método retorna o último índice de ocorrência de uma determinada substring na string.

Funciona de forma oposta ao indexOf.

const mensagem = "Javascript é demais!";
let resultado = mensagem.lastIndexOf("!");
console.log(resultado);// retorna '19'

length()

O método retorna o número de caracteres em uma string.

let mensagem = "Javascript é demais!";
console.log(mensagem.length());//retorna 19

localeCompare()

O método verifica se uma determinada string vem antes, depois ou é equivalente a outra string na ordem de classificação.

let resultado = 'z'.localeCompare('t');//Retorna um valor positivo se se 't' vir depois de 'z'
console.log(resultado);//t vem ates de z, logo o retorno será positivo '1'

let resultado = 't'.localeCompare('z');//Retorna um valor positivo se se 'z' vir depois de 't'
console.log(resultado);//z vem ates de t, logo o retorno será negativo '-1'

match()

O método retorna o resultado da correspondência de uma string com uma expressão regular.

Para prosseguir é necessário que você entenda um pouco sobre expressões regulares e como elas funcionam.

let texto = "Javascript é demais!";
let resultado = texto.match(/demais/);
console.log(resultado);//Se ele achar, será retornado o pedaço do texto, caso contrário retornará 'null' (nulo)

matchAll()

O método retorna um iterador de resultados após combinar uma string com uma expressão regular.

A diferença é que o matchAll retorna todas as ocorrências daquela expressão regular, logo precisamos extrair usando o iterador for.

Para prosseguir você precisa entender como funciona o for.

const sentenca = "JavaScript1JavaScript2";

const regex = /JavaScript\d/g;//Regex que vai buscar pelo termo 'Javascript' mais um número qualquer.

let results = sentence.matchAll(regex);//Retorna todas as sentenças em que a expressão regular é encontrada.

for (result of results) {
 console.log(result);//Mostra as strings encontradas
}

padEnd()

O método preenche a string atual com outra string até o final.

let texto = "Micilini";

texto = texto.padEnd(10, "*");//Repete 10 vezes o caractere '*' no final da string

console.log(paddedString);//resultado: 'Micilini**********'

padStart()

O método preenche a string atual com outra string no início dela.

let texto = "Micilini";

texto = texto.padStart(10, "*");//Repete 10 vezes o caractere '*' no início da string

console.log(paddedString);//resultado: '**********Micilini'

repeat()

O método cria uma nova string repetindo a mesma string durante um número especificado de vezes.

let texto = "Bom Trabalho!";
let resultado = texto.repeat(5);//Repete o texto contido na variável 'texto' 5 vezes
console.log(resultado);//resultado: "Bom Trabalho!Bom Trabalho!Bom Trabalho!Bom Trabalho!Bom Trabalho!"

replace()

O método retorna uma nova string substituindo um caractere pelo outro, ou uma sequência de caracteres (é necessário usar expressões regulares) por outra.

const texto = "M9cilini";
let resultado = texto.replace('9', 'i');//Esse método só irá substituir o primeiro 9 por 'i'.

console.log(result);//'Micilini'

const texto = "M9c9l9n9";
let resultado = texto.replace(/9/, 'i');//Esse método só irá substituir todos os 9 por 'i'.

console.log(result);//'Micilini'

replaceAll()

O método retorna uma nova string com todas as correspondências de um padrão de caracteres por outro.

const texto = "M9c9l9n9";
let resultado = texto.replaceAll('9', 'i');//Esse método só irá substituir todos os 9 por 'i'.

console.log(resultado);//'Micilini'

Podemos usar expressões regulares se quisermos!

search()

O método procura uma correspondência entre uma determinada string e uma expressão regular.

Esse método retorna o índice (posição) da primeira correspondência. Se o método não encontrar nada, será retornado -1.

let frase = "eu amo Javascript!";

let regex = /[A-Z]/;//Verifica o índice da primeira ocorrência em que a letra está em maiúsculo

let index = frase.search(regex);

console.log(index);//Retorna '7', que é o início do 'J' de 'Javascript'

slice()

O método extrai todos os caracteres que existem entre dois índices.

let texto = "Javascript é bacana!";
let resultado = texto.slice(0, 10);

console.log(resultado);//Resultado 'Javascript'

split()

O método divide uma string em uma lista de substrings de acordo com o caractere especificado, e retorna como uma matriz.

let texto = "Micilini::Javascript::JS";
let resultado = texto.split('::');

console.log(resultado);//Retorna: ['Micilini', 'Javascript', 'JS']

substring()

O método retorna uma parte especificada da string entre os índices inicial e final.

let texto = "Micilini é dez!";
let resultado = texto.substring(0, 10);

console.log(resultado);//Retorna: 'Micilini'

toLowerCase()

O método transforma todos os caracteres de uma string em minúsculo.

let texto = "MICILINI";
console.log(text.toLowerCase());//Retorna 'micilini'

toUpperCase()

O método transforma todos os caracteres de uma string em maiúsculo.

let texto = "micilini";
console.log(text.toUpperCase());//Retorna 'MICILINI'

trim()

O método remove espaços em branco de ambas as extremidades de uma string.

let texto = " micilini ";
console.log(texto.trim());//Retorna 'micilini', sem os espaços em branco

Lembrando que se você deseja remover espaços em branco que existem entre os caracteres, é recomendável usar o método replace() com expressões regulares.

Usando Literais

Você sabia que para usar quaisquer um dos métodos vistos acima, você pode usar literais?

Ou seja, passar a string diretamente junto com o método? Veja como é simples:

console.log('Micilini'.concat(' Roll'));//Observe que usei o concat diretamente numa string

Template Strings

Desde o ECMASCRIPT 6, o javascript incluiu uma incrível funcionalidade para se trabalhar com strings, as famosas template strings.

Com ela, agora somos capazes de interpolar valores dentro de string e também quebrar string em múltiplas linhas.

Com uma string normal declarada com aspas simples ou aspas duplas, não conseguimos quebrar uma linha no meio da string, por exemplo:

let texto = "ola
mundo
do
Mic!";

O código acima vai gerar um erro de compilação.

Para declarar um template string utilizamos a crase (``):

let templateString = `Olá
Mundo`;

Dentro de um template strings ainda podemos chamar variáveis que serão chamadas dentro da string, veja:

let nome = "Micilini";

let templateString = `Olá ${nome} que bom te ver!`;//Resultado 'Olá Micilini que bom te ver!'

Lembrando que podemos usar quantas variáveis quisermos:

let nome = "Micilini";
let idade = 28;

let templateStrings = `Me chamo ${nome}, e tenho ${idade} anos`;//Resultado 'Me chamo Micilini, e tenho 28 anos'

Se desejar você pode fazer o uso das aspas simples ou duplas dentro do templateStrings:

let templateStrings = `Olá " é isso '`;

Ainda dentro do template strings, você pode fazer operações matemáticas e até mesmo chamar funções. Veremos isso mais a diante na jornada Javascript.

Number

O tipo NUMBER como o próprio nome já diz, representa um valor número, ou seja, qualquer sequência de números que vai de 0 a 9.

Também é considerado do tipo number, o formato de ponto flutuante de 64 bits de precisão dupla, nesse caso, valores como 1.24, 1.0, 987.987 ou qualquer outro valor com ponto é considerado um tipo number.

Em outras linguagens de programação, você pode encontrar diferentes tipos númericos, como integers, floats, doubles ou bignums.

Exemplos de valores do tipo number:

let numero = 124;
let um = 1;
let quebrado = 1.17;
let outroNumero = 0.45;

Podemos declarar valores númericos por meio de uma função padrão do Javascript chamada de Number():

let numero = Number('2.0');

A função Number() converte uma string ou outro valor para o tipo Number. Se o valor não puder ser convertido, ele retornará NaN.

Cuidados com o Tipo Number

Existem alguns cuidados que devemos ter quando utilizamos valores numéricos em Javascript, no início pode parecer muito estranho, mas com o tempo você se acostuma com a forma que o javascript processa os dados.

Vejamos alguns exemplos abaixo:

1) Tipo Infinito:

Quando temos uma operação em que temos qualquer número dividido por zero, sabemos que no mundo real o resultado dessa operação é um número beeeeeeeeem grande.

Quando fazemos isso no Javascript, o resultado será do tipo 'Infinity'

console.log(8 / 0);//'Infinity'

2) Conversões automáticas de strings em number durante operações matemáticas:

Por Javascript ser uma linguagem bem flexível, ele consegue realizar uma operação de matemática entre uma string e um number., sabia?

Por de baixo dos panos, o javascript pega o conteúdo interno da string e verifica se ele pode ser convertido em número, e caso positivo ele retorna o resultado da operação, caso negativo ele retorna Nan.

console.log("10" / 2);//'5'

3) Imprecisões (Versões Antigas)

Em versões mais antigas o javascript não consegue suportar uma especificação exata de ponto flutuante, pois assim como a maioria das linguagens ele suporta a especificação IEEE Standard for Binary Floating-Point Arithmetic.

Isso significa dizer que se somarmos os valores 0.1 com 0.8, o resultado retornando seria 0.8999999999, ou seja, um resultado totalmente impreciso.

console.log(0.1 + 0.8);//'0.899999...'

BigInt

O tipo BIGINT, representa um valor númerico assim como o number, a diferença é que o javascript só considera um valor como bigint quando temos um número maior que 2 elevado a 53.

Tenha em mente que valores do tipo bigint, não podem usar os métodos Math (que veremos logo a seguir), e muito menos realizar operações com valores do tipo number.

Em termos de uso prático, o BigInt foi adicionado ao ES2020 para permitir a representação de números inteiros de 64 bits, necessários para compatibilidade com muitas outras linguagens de programação e APIs.

Exemplo de valores do tipo bigint:

let numeroGrande = 9999999999999999n;
console.log(typeof numeroGrande);//'bigint'

Podemos dizer ao Javascript que o tipo de valor é um bigint usando a função BigInt():

let x = BigInt(12);//Apesar de 12 ser considerado por padrão do tipo Number, aqui estamos forçando o Javascript a reconhecer ele como um bigint
console.log(typeof x);//'bigint'

Métodos de Number

O javascript contém diversos métodos que nos ajudam a trabalhar com o tipo number, vejamos alguns deles:

EPSILON

Basicamente a propriedade EPSILON representa a diferença entre 1 e o menor número de ponto flutuante maior que 1.

Ela tem um valor de 252 que equivale a aproximadamente a 2,2204460492503130808472633361816E-16.

EPSILON é um tipo de propriedade que não conseguimos manipular, ou seja, não conseguimos gravar, enumerar e configurar.

Nós a utilizamos para testar a igualdade dos números de ponto flutuante.

Lembra quando falamos sobre o padrão IEEE anteriormente neste conteúdo? Onde vimos que uma operação como 0.1 + 0.2 não é exatamente igual a 0.3?

Então, nós podemos usar esse método de verificação para saber se a diferença é menor que um EPSILON, veja:

let epsilonValue = Number.EPSILON;
let soma = 0.1 + 0.2;

console.log(soma < epsilonValue);//falso

isInteger()

O método determina se o valor passado é um número inteiro, caso positivo retorna true, caso contrário retorna false.

//Forma de comparação direta:
console.log(Number.isInteger(12));//true
console.log(Number.isInteger(-12));//true
console.log(Number.isInteger(12.9))//false
let valorUm = 322;
console.log(Number.isInteger(valorUm));//true (exemplo passando variáveis)

isSafeInteger()

O método determina se o valor fornecido é um número inteiro seguro.

Um inteiro seguro é um inteiro que pode ser representado exatamente como um número de precisão dupla de acordo com o padrão IEEE-754 (todos os inteiros de 2 elevado a 53 menos 1)

let valorUm = 1243;
let valorDois = 798264359876439587623948762394876192384612983746912873649812763498172634897126349871263498712634987163948792347619827346192873461982734691827634819276348917263489716234;

console.log(Number.isSafeInteger(valorUm));//true
console.log(Number.isSafeInteger(valorDois));//false

MAX_SAFE_INTEGER

A propriedade MAX_SAFE_INTEGER é uma constante que representa o valor máximo (seguro) suportado no JS.

A constante MAX_SAFE_INTEGER tem um valor de 2 elevado a 53 menos 1 (9007199254740991).

É uma propriedade não gravável, não enumerável e não configurável.

let maxSafeInteger = Number.MAX_SAFE_INTEGER;
console.log(maxSafeInteger); // 9007199254740991

MIN_SAFE_INTEGER

A propriedade MIN_SAFE_INTEGER é uma constante que representa o valor mínimo (seguro) suportado no JS.

A constante MAX_SAFE_INTEGER tem um valor de -2 elevado a 53 menos 1 (-9007199254740991).

É uma propriedade não gravável, não enumerável e não configurável.

let minSafeInteger = Number.MIN_SAFE_INTEGER;
console.log(minSafeInteger); // -9007199254740991

MAX_VALUE

A propriedade MAX_VALUE é uma constante que representa o valor máximo suportado no JS.

A constante MAX_VALUE tem um valor de aproximadamente 1,79E+308 ou 2 elevado a 1024. Valores maiores que MAX_VALUE são representados como Infinity.

É uma propriedade não gravável, não enumerável e não configurável.

let maxValue = Number.MAX_VALUE;
console.log(maxValue); // 1.7976931348623157e+308

MIN_VALUE

A propriedade MIN_VALUE é uma constante que representa o valor máximo suportado no JS.

A constante MIX_VALUE tem um valor de aproximadamente 5e-324. Valores menores que MIN_VALUE são convertidos em 0.

É uma propriedade não gravável, não enumerável e não configurável.

let minValue = Number.MIN_VALUE;
console.log(minValue); // 5e-324

NaN

A propriedade NAN (Not-a-Number) representa algo não númerico.

Ela é muito utilizada na função isNaN para verificar se o valor fornecido é um número ou não.

console.log(Number.NaN);//NaN

console.log(isNaN(5));//5
console.log(isNaN(5.89));//5.89
console.log(isNaN(Infinity));//Infinity
console.log(isNaN('Micilini'));//NaN

POSITIVE_INFINITY

A propriedade POSITIVE_INFINITY representa um valor positivo de um tipo infinito.

O valor de POSITIVE_INFINITY é o mesmo da propriedade Infinity do objeto global. É o maior valor que qualquer número em JavaScript.

É uma propriedade não gravável, não enumerável e não configurável.

let infinitoPositivo = Number.POSITIVE_INFINITY;
console.log(infinitoPositivo); // Infinity

NEGATIVE_INFINITY

A propriedade NEGATIVE_INFINITY representa um valor negativo de um tipo infinito.

O valor de NEGATIVE_INFINITY é o mesmo da propriedade Infinity do objeto global. É o menor valor que qualquer número em JavaScript.

É uma propriedade não gravável, não enumerável e não configurável.

let infinitoNegativo = Number.NEGATIVE_INFINITY;
console.log(infinitoNegativo); // -Infinity

toExponential()

O método retorna uma string que representa o objeto Number em notação exponencial.

let numero = 695.8457;

let expNumero01 = numero.toExponential();
console.log(expNumero01); // 6.958457e+2

let expNumero02 = numero.toExponential(2);//Podemos passar parâmetros dentro da função para diminuir a notação em duas casas decimais
console.log(expNumero02); // 6.96e+2

toFixed()

O método formata um número usando a notação de ponto fixo.

É muito utilizado para quebrar as casas decimais.

let numero = 57.77583;
console.log(numero.toFixed());//58, pois sem parâmetros ele arredonda
console.log(numero.toFixed(1));//57.8, mostra somente 1 casa decimal (arredondando)
console.log(numero.toFixed(2));//57.78, mostra duas casas decimais (arredondando)

toLocaleString()

O método retorna uma string com uma representação desse número em um idioma selecionado.

let numero = 400000;
console.log(numero.toLocaleString()); // 400,000 se estiver na localização do brasil

É possível também usar a localização desejada, observe:

let numero = 123456.789;

console.log(numero.toLocaleString("en-IN")); // 1,23,456.789, pois estamos usando a localização da India

Para visualizar a lista completa de localizações você pode fazer isso por meio deste link.

toPrecision()

O método retorna uma string representando o objeto Number para a precisão especificada.

Funciona de forma parecida com o toFixed(), a diferença é que o retorno é uma string.

let numero = 57.77583;

console.log(numero.toPrecision()); // 57.77583, sem parâmetros funciona de forma similar ao toString()

console.log(numero.toPrecision(5)); // 57.776, retorna somente 5 digitos

console.log(numero.toPrecision(2)); // 58, retorna somente dois digitos

toString()

O método retorna uma string representando o número.

var numero = 2000;
console.log(numero.toString()); // '2000' em formato de string

Boolean

Um dos tipos mais utilizados no universo do Javascript, que está presente na maioria das lógicas que implementamos em nosso sistema, é o tipo booleano.

Na ciência da computação, um booleano é um tipo de dado lógico que pode ser representado apenas por dois valores, que são:

Ele é primordial na linguagem, pois dizem ao sistema em si, qual caminho ou seção do código deve ser executada.

É frequentemente utilizado em declarações de if/else e em loops.

Por exemplo: "Se 1 + 1 for igual a 2 (true), execute a mensagem [CERTO], se não (false), execute a mensagem [ERRADO]".

Mais tarde nesse conteúdo vamos aprender um pouco mais sobre as condições de if/else e loops.

Por hora, você precisa entender apenas a declaração do boolean:

let verdadeiro = true;
let falso = false;

Assim como em outras linguagens, podemos utilizar o valor númerico 1 para representar o valor true, e 0 para representar o valor false:

let verdadeiro = 1;
let falso = 0;

Principalmente dentro da estrutura de controle if/else, onde o número 1 é reconhecido como true, e 0 como false.

Anteriormente nós vimos alguns métodos que podem ser usados em tipos string e number, e se você perceber verá que alguns desses métodos apresentam um retorno do tipo booleano (true, false).

Undefined

Um dos valores primitivos que frequentemente encontramos quando esquecemos de declarar alguma coisa, ou quando a execução do código não ocorre de forma planejada, temos o famoso undefined, que em sua tradução é "Indefinido".

Undefined é um valor primitivo atribuído automaticamente a variáveis que acabaram de ser declaradas, ou argumentos formais para os quais não existem argumentos reais.

let indefinido = undefined;//Podemos declarar variáveis com valor indefinido

Lembra que em conteúdos anteriores, quando tentamos instanciar uma variável sem um valor atribuído, o console nos retornou 'undefined'?

let x;
var y;

console.log(x);//undefined
console.log(y);//undefined

Null

Como o próprio nome já diz, null significa 'Nulo', ou seja, quando a referência (variável) aponta para um objeto ou endereço inexistente.

let nulo = null;
console.log(nulo);//'null'

É importante ressaltar que em JavaScript, null é marcado como um dos valores primitivos, no entanto, ao usar o operador typeof, ele é reconhecido como o tipo "objeto".

console.log(typeof null); // "object"

Symbol

Symbol é um dos objetos internos do Javascript na qual este retorna um símbolo primitivo.

Eles geralmente são usados para armazenar conteúdos únicos e exclusivos que não se repetem em mais nenhuma outra parte do código.

Vejamos como é feita a sua declaração:

const simbolo = Symbol('Micilini');

Como os símbolos são únicos, caso tentarmos compará-los com outros símbolos que possuem o mesmo conteúdo, o retorno será falso.

const simbolo01 = Symbol('HI');
const simbolo02 = Symbol('HI');

console.log(simbolo01 == simbolo02);//false
console.log(simbolo01 === simbolo02);//false

Daí você pode se perguntar: "Qual a diferença de um símbolo para uma constante?"

Simples, as constantes são variáveis que não podem ser redeclaradas e reatribuídas, os símbolos são objetos primitivos do próprio javascript onde apontam para diferentes endereços de memória.

Tanto que se tentarmos comparar dois símbolos com o mesmo valor, o retorno será falso, pois eles não são iguais.

Agora se fizermos isso sem a utilização de símbolos, o retorno será verdadeiro:

const um = 'hi';
const dois = 'hi';

console.log(um == dois);//true
console.log(um === dois);//true

Conclusão

Neste conteúdo você aprendeu a utilização básica dos 7 tipos de dados primitivos que existem no universo do Javascript, e alguns métodos que podemos usar nos tipo string e number.

Aprendemos também sobre o significado da tipagem dinâmica do Javascript e suas implicações no dia a dia.