Javascript: guia sobre tipos de dados

Neste artigo, você aprenderá sobre os tipos de dados disponíveis em JavaScript de maneira fácil de entender.

Tipos de dados em JavaScript

Os tipos de dados basicamente especificam os tipos de dados que podem ser armazenados e manipulados em um programa.

Existem seis tipos básicos de dados em JavaScript, que podem ser agrupados em três grandes categorias: tipos de dados primitivos (ou primários), tipos de dados compostos (ou de referência) e tipos de dados especiais. String, Number e Boolean são tipos de dados primitivos. Objetos, arrays e funções (todos os tipos de objeto) são tipos de dados compostos. E Undefined e Null são tipos de dados especiais.

Os tipos de dados primitivos podem conter apenas um valor por vez, enquanto os tipos de dados compostos podem conter coleções mais complexas de valores e entidades. Vamos discutir cada um deles em detalhes.

Tipo de dados string

O tipo de dados string é usado para representar dados de texto (ou seja, strings de caracteres). Strings são criadas usando aspas simples ou duplas em torno de um ou mais caracteres, como segue:

var a = 'Oi!'; // usando aspas simples
var b = "Oi!"; // usando aspas duplas

Você pode incluir aspas em uma string, desde que não correspondam às aspas incluídas.

var a = "Tem água na caixa d'água?"; // aspas simples dentro de aspas duplas
var b = 'Ele disse "Oi" e saiu.'; // aspas duplas dentro de aspas simples

Tipos de dados numéricos

Tipos de dados numéricos são usados ​​para representar números positivos ou negativos com ou sem casas decimais, ou números escritos usando notação exponencial, como 1,5e-4 (equivalente a 1,5×10 -4).

var a = 25; // inteiro
var b = 80.5; // número de ponto flutuante
var c = 4.25e+6; // notação exponencial, o mesmo que 4.25e6 ou 4250000
var d = 4.25e-6; // notação exponencial, o mesmo que 0.00000425

O tipo de dados Number também inclui valores especiais: Infinity, -Infinity e NaN. Infinito significa infinito matemático ∞, que é maior que qualquer número. O infinito é o resultado da divisão de um número diferente de zero por 0, conforme mostrado na figura a seguir:

alert(16 / 0); // Saída: Infinity
alert(-16 / 0); // Saída: -Infinity
alert(16 / -0); // Saída: -Infinity

NaN representa o valor especial Not-a-Number. Este é o resultado de operações aritméticas inválidas ou indefinidas, como tirar a raiz quadrada de -1 ou dividir 0 por 0.

alert("Algum texto" / 2); // Saída: NaN
alert("Algum texto" / 2 + 10); // Saída: NaN
alert(Math.sqrt(-1)); // Saída: NaN

Tipo de dados booleano

O tipo de dados booleano ou Boolean pode conter apenas dois valores: true ou false. Geralmente é usado para armazenar valores como yes(true) ou no(false), on(true) ou off(false), etc. Do seguinte modo:

var estouLendo = true; // sim, estou lendo
var estouDormindo = false; // não, não estou dormindo

Os valores booleanos também são o resultado de comparações de programas. O exemplo a seguir compara duas variáveis ​​e exibe o resultado em uma caixa de diálogo de alerta:

var a = 2, b = 5, c = 10;
alert(b > a) // Saída: true
alert(b > c) // Saída: false

Tipo de dados indefinido

Um tipo de dados indefinido pode ter apenas um valor – o valor especial é indefinido. Se uma variável for declarada, mas não tiver um valor atribuído, seu valor será indefinido.

var a;
var b = "Olá mundo!";
alert(a); // Saída: undefined
alert(b); // Saída: Olá mundo!

Tipo de dados null ou nulo

Este é outro tipo de dado especial que pode ter apenas um valor – o valor nulo. nullvalue significa nenhum valor. Não é equivalente a uma string vazia (“”) ou 0, não é nada.

O conteúdo atual de uma variável pode ser explicitamente esvaziado atribuindo à variável um valor nulo.

var a = null;
alert(a); // Saída: null
var b = "Olá mundo!";
alert(b); // Saída: Olá mundo!
b = null;
alert(b); // Saída: null

O tipo de dados do objeto

O objeto é um tipo de dados complexo que permite armazenar coleções de dados.

Os objetos contêm propriedades definidas como pares chave-valor. As chaves de propriedade (nomes) são sempre strings, mas os valores podem ser qualquer tipo de dados, como strings, números, booleanos ou tipos de dados complexos, como arrays, funções e outros objetos. Você aprenderá mais sobre objetos em capítulos posteriores.

O exemplo a seguir mostrará a maneira mais simples de criar um objeto em JavaScript.

// Cria um objeto vazio
var emptyObject = {};
// Cria um objeto com algumas propriedades
var person = {"name": "Clark", "surname": "Kent", "age": "36"};
// Cria um objeto com algumas propriedades, usando uma notação mais legível
var car = {
    "modal": "BMW X3", // modelo do carro
    "color": "branco", // cor do carro
    "doors": 5 // número de portas
}

As aspas em nomes de propriedades podem ser omitidas se o nome for um nome JavaScript válido. Isso significa que as aspas são necessárias para “primeiro nome”, mas são opcionais em torno do primeiro nome. Portanto, o objeto car no exemplo acima também pode ser escrito como:

var carro = {
    modelo: "BMW X3",
    cor: "branco",
    portas: 5
}

O tipo de dados array

Um array em JavaScript é uma coleção de valores ordenados. Cada valor é chamado de elemento do array e pode ser de qualquer tipo, incluindo outros arrays.

Você pode criar um array usando colchetes [], separando os elementos por vírgulas. Por exemplo:

let arr = [1, 2, 3, 4, 5]; // array de inteiros
let names = ["John", "Mary", "Jane"]; // array de strings
let mixed = [1, "two", true, null]; // array misto

Você também pode acessar os elementos de um array usando seus índices, que são os números que indicam a posição de cada elemento no array. O primeiro elemento de um array tem índice 0, o segundo tem índice 1, e assim por diante. Por exemplo:

let arr = [1, 2, 3, 4, 5];
console.log(arr[0]); // imprime 1
console.log(arr[2]); // imprime 3
let names = ["John", "Mary", "Jane"];
console.log(names[1]); // imprime "Mary"

Você também pode modificar os elementos de um array usando os índices, assim como adicionar novos elementos ao final do array usando o método push(). Por exemplo:

let arr = [1, 2, 3, 4, 5];
arr[0] = 100; // altera o primeiro elemento para 100
arr.push(6); // adiciona o número 6 ao final do array
console.log(arr); // imprime [100, 2, 3, 4, 5, 6]

Além disso, você também pode usar o método length para descobrir quantos elementos um array tem. Por exemplo:

let arr = [1, 2, 3, 4, 5];
console.log(arr.length); // imprime 5
let names = ["John", "Mary", "Jane"];
console.log(names.length); // imprime 3

Função typeof

A função typeof em JavaScript é utilizada para verificar o tipo de dado de uma variável. Ela é muito útil para garantir que a variável contenha o tipo de dado esperado em um código.

Para utilizar a função typeof, basta colocá-la seguida pelo nome da variável que deseja verificar. A função retornará uma string indicando o tipo de dado da variável. Alguns dos tipos de dados que podem ser verificados com typeof são: “number”, “string”, “boolean”, “undefined” e “object”.

Exemplo:

let x = 10;
console.log(typeof x); // output: "number"
let y = "hello";
console.log(typeof y); // output: "string"
let z = true;
console.log(typeof z); // output: "boolean"
let obj = { name: "John" };
console.log(typeof obj); // output: "object"
let arr = [1, 2, 3];
console.log(typeof arr); // output: "object"

Como você pode ver claramente no exemplo acima, quando testamos o nullvalor usando o typeofoperador ( linha no-22 ), ele retornou “objeto” em vez de “nulo”.

Este é um bug de longa data no JavaScript, mas como muitos códigos na web escritos em torno desse comportamento e, portanto, corrigi-lo criariam muito mais problemas, a ideia de corrigir esse problema foi rejeitada pelo comitê que projeta e mantém o JavaScript .

Leia também: Javascript: gerando saídas (output)