Tipos de Dados em JavaScript

Este artigo explica os tipos de dados em JavaScript.

YouTube Video

Tipos de Dados em JavaScript

O JavaScript possui tipos de dados para classificar valores, que podem ser amplamente divididos em tipos primitivos e tipos de objeto. Os tipos de dados determinam que tipo de dado é armazenado em uma variável e influenciam como ele pode ser manipulado.

Tipos Primitivos

Os tipos primitivos são tipos de dados simples que representam um único valor. O JavaScript possui os seguintes 7 tipos primitivos.

number

1let num = 42;
2let pi = 3.14;
3
4console.log("Value of num:", num);
5console.log("Value of pi:", pi);

• number é um tipo usado para lidar com valores numéricos, incluindo inteiros e números de ponto flutuante (decimais). Manipular valores que excedem certos limites resulta em Infinity ou NaN (Não é um Número).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

• No JavaScript, os números são representados como números de ponto flutuante. Como resultado, certos decimais (especialmente aqueles que não podem ser representados precisamente em binário) podem não ser expressos com precisão.
• Quando cálculos precisos são necessários, como no caso de valores monetários, é necessário evitar esses erros de arredondamento. Por exemplo, você pode usar BigInt ou ajustar o número de casas decimais com toFixed().

string

1let greeting = "Hello, world!";
2let char = 'A';
3const message = `"${greeting}" in JavaScript`;
4
5console.log("Value of greeting:", greeting);
6console.log("Value of char:", char);
7console.log("Value of message:", message);

• string é um tipo de dado usado para manipular texto, representando uma sequência de caracteres. É representado ao envolver o texto em aspas simples (') ou aspas duplas ("). A partir do ES6, literais de template permitem incorporar variáveis de forma fácil usando acentos graves (). Para incorporar uma variável, use a sintaxe ${}.

boolean

1let isAvailable = true;
2let hasError = false;
3
4console.log("Value of isAvailable:", isAvailable);
5console.log("Value of hasError:", hasError);

• boolean representa um valor lógico e só pode ter dois valores: true ou false. É usado como resultado de expressões condicionais ou como um indicador.

null

1let result = null;
2
3console.log("Value of result:", result);

• null é um tipo de dado que indica explicitamente 'nenhum valor.'. null é definido pelos desenvolvedores para indicar uma ausência intencional.

undefined

1let score;
2let subject = undefined;
3
4console.log("Value of score:", score);     // undefined
5console.log("Value of subject:", subject);

• undefined é um tipo de dado que significa 'não definido.'. undefined é automaticamente atribuído quando uma variável é declarada, mas não recebe um valor.

bigint

1let bigIntValue = 9007199254740991n;
2let anotherBigInt = 123456789012345678901234567890n;
3
4console.log("Value of bigIntValue:", bigIntValue);
5console.log("Value of anotherBigInt:", anotherBigInt);

• bigint é um tipo de dado para manipulação de inteiros grandes. bigint permite uma representação precisa de inteiros grandes que não podem ser representados pelo tipo number. Os literais de bigint são representados adicionando-se n ao final de um número.
• bigint é um tipo para manipular inteiros de tamanho arbitrário, sem limitações de faixa. No entanto, bigint e number não podem ser operados diretamente em conjunto, então é necessário ter cuidado.

Symbol

1let sym1 = Symbol('id');
2let sym2 = Symbol('id');
3
4console.log("sym1 === sym2:", sym1 === sym2); // false

• Symbol é um tipo de dado usado para criar identificadores únicos. É criado usando Symbol() e pode ser usado como uma propriedade de um objeto. Ao contrário de outros tipos primitivos, Symbol tem valores únicos, então mesmo com o mesmo conteúdo, é tratado como um Symbol diferente.

Tipos de Objeto

Os tipos de objeto são estruturas de dados que podem armazenar múltiplos valores. Um objeto é uma coleção de pares chave-valor e pode ter propriedades e métodos.

Object

1let person = {
2    name: "John",
3    age: 30,
4    isEmployee: true
5};
6console.log(person.name); // John

• Object é uma coleção de propriedades (pares chave-valor) que pode armazenar vários tipos de dados. Os objetos são representados por chaves {}, e cada propriedade é conectada por : entre a chave e o valor.

Array

1let numbers = [10, 20, 30];
2console.log(numbers[0]); // 10
3console.log(numbers[1]); // 20
4console.log(numbers[2]); // 30
5console.log(numbers[3]); // undefined

• Array é uma lista que contém múltiplos valores de forma ordenada. Arrays são representados por colchetes [], e os valores são separados por vírgulas ,. Cada elemento é acessado usando um índice que começa em 0.

Function

1function greet(name) {
2    return "Hello, " + name;
3}
4console.log(greet("Alice")); // Hello, Alice

• Funções são um tipo de objeto e blocos de código reutilizáveis. Funções podem ser definidas usando a palavra-chave function.

Outros Tipos de Objeto

• JavaScript também possui tipos de objeto embutidos, como Date, RegExp, Map e Set. Esses lidam com dados de acordo com casos de uso específicos.

Conversão de Tipos

Conversões de tipo implícitas e explícitas são realizadas frequentemente em JavaScript.

Conversão de Tipo Implícita

• O JavaScript pode converter tipos automaticamente ao realizar operações entre diferentes tipos.

1let result = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

• Neste exemplo, o número 5 é implicitamente convertido em uma string, resultando na string "55".

Conversão de Tipo Explícita

• Os desenvolvedores também podem realizar conversões de tipo de forma explícita.

1let num = "123";
2let convertedNum = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

• Neste exemplo, a função Number() é usada para converter explicitamente a string "123" no número 123.

Verificação de Tipos

Em JavaScript, você pode usar o operador typeof para verificar o tipo de dado de uma variável.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

Conclusão

• Tipos primitivos incluem number, string, boolean, null, undefined e symbol.
• Tipos de objeto incluem Object, Array, Function, entre outros.
• Como ocorrem tanto conversões de tipo automáticas quanto explícitas, é importante entender o uso adequado dos tipos de dados.

Você pode acompanhar o artigo acima usando o Visual Studio Code em nosso canal do YouTube. Por favor, confira também o canal do YouTube.

YouTube Video