Tipos de dados

docs.scrimba.com

Armazene o nome de alguém, sua idade e se está conectado, e você já terá usado três tipos diferentes de valor. O nome é texto, a idade é um número e o sinalizador de conectado é um sim ou não. JavaScript trata cada um desses como um tipo distinto e o manipula de forma diferente. Este capítulo é sobre os poucos tipos que você encontra primeiro e como saber qual você está segurando.

Os tipos básicos

Três tipos cobrem a maioria do que você armazena. Uma string é texto, envolvido em aspas. Um número é qualquer número, para contar ou medir. Um booleano é um valor sim ou não, e tem apenas duas opções: true ou false.

const name = "Maria"; // uma string: texto
const age = 27; // um número
const isLoggedIn = true; // um booleano: true ou false

Você usa uma string para qualquer coisa que leia como palavras: um nome, uma mensagem, uma cor. Você usa um número para qualquer coisa que possa contar ou calcular. Você usa um booleano quando a resposta é uma de duas opções, como se uma caixa está marcada. Você verá muito mais disso em strings e números.

Os valores cotidianos do JavaScript se enquadram em alguns tipos, e três deles carregam a maioria dos seus dados. Uma string é texto entre aspas, simples ou duplas, não importa qual. Um número é qualquer valor numérico. Um booleano é um de exatamente dois valores, true ou false.

const productName = "Mouse sem fio"; // string
const price = 24.99; // número
const inStock = true; // booleano

Cada tipo tem um trabalho. Strings contêm texto que você mostra ou lê, coberto em strings. Números contêm qualquer coisa que você calcula, coberto em números. Booleanos contêm uma resposta de dois caminhos e aparecem em todos os lugares onde uma decisão é tomada, porque uma comparação como price < 30 produz uma.

JavaScript ordena valores em um pequeno conjunto de tipos, e três deles respondem pela maioria dos dados que você manipula. Uma string é uma sequência de caracteres escrita entre aspas, simples, duplas ou crase para literais de template. Um número é um valor numérico. Um booleano é um de dois valores, true ou false.

const currency = "EUR"; // string
const balance = 1499.5; // número
const isOverdrawn = balance < 0; // booleano, aqui o resultado de uma comparação

A distinção entre strings e números importa mais do que parece à primeira vista, porque "5" e 5 se comportam de forma diferente: um é texto que contém um dígito, o outro é um valor com o qual você pode fazer aritmética. Booleanos valem a pena notar cedo porque você raramente os digita manualmente. Eles saem de comparações e verificações lógicas, então a capacidade de ler balance < 0 como "um booleano" é o que faz os operadores posteriores fazerem sentido.

JunoOs tipos básicos Os três que você alcança constantemente: string para texto entre aspas, number para qualquer coisa numérica, e boolean para uma resposta true ou false. Escolha o tipo que corresponde ao tipo de coisa que você está armazenando. Um nome é uma string, uma idade é um número, uma caixa de seleção é um booleano.

JunoOs tipos básicos Três tipos fazem a maioria do trabalho: string para texto, number para valores numéricos, boolean para um de true ou false. Aspas fazem uma string, então "5" é texto, não um número. Booleanos geralmente chegam como o resultado de uma comparação em vez de algo que você digita.

JunoOs tipos básicos Strings, números e booleanos carregam a maioria dos seus dados, e a linha string-versus-número é aquela que morde: "5" é texto, 5 é aritmética. Você quase nunca escreve um literal booleano, porque comparações como balance < 0 te dão um. Ler uma comparação como "isto é um booleano" é o que faz as condições posteriores fazer sentido.

Nada: null e undefined

Às vezes um valor está faltando, e JavaScript tem duas formas de dizer isso. undefined significa que nenhum valor foi dado ainda. Se você fizer uma variável sem atribuir um valor, seu valor é undefined.

let score;
console.log(score); // undefined

null significa vazio de propósito. Você usa isso você mesmo, para dizer "isto não tem valor agora, e eu quis que fosse assim".

let winner = null;
console.log(winner); // null

Resumidamente: undefined é JavaScript dizendo "nada aqui ainda", e null é você dizendo "nada aqui, deliberadamente".

Dois valores significam "nenhum valor", e a diferença é quem os atribuiu. undefined é o que JavaScript dá a você por padrão: uma variável declarada sem um valor, por exemplo, começa como undefined.

let selectedColor;
console.log(selectedColor); // undefined

null é um valor que você atribui você mesmo para marcar algo como deliberadamente vazio, um slot que você limpou ou não preencheu ainda.

let couponCode = null;
console.log(couponCode); // null

undefined é a ausência padrão; null é a deliberada. Essa divisão é a forma útil de lê-los: se você vê undefined, algo nunca foi atribuído; se você vê null, alguém escolheu esvaziá-lo.

Tanto null quanto undefined representam ausência, e a convenção que os separa é sobre intenção. undefined é a ausência que JavaScript produz por conta própria: uma variável declarada mas não atribuída, uma propriedade ausente, uma função que não retorna nada.

let discount;
console.log(discount); // undefined

null é a ausência que você atribui deliberadamente, para sinalizar "intencionalmente vazio" em vez de "nunca foi tocado".

let appliedCoupon = null;
console.log(appliedCoupon); // null

Manter os dois separados é um sinal real em uma base de código: undefined tende a significar que ninguém atribuiu isso, o que pode apontar um bug ou um caminho inacabado, enquanto null lê como uma escolha considerada. Eles também não se comportam de forma idêntica em verificações posteriores, e é por isso que misturá-los causa confusão quando operadores entram em jogo. Trate undefined como o padrão da máquina e null como seu "vazio" explícito, e seu comportamento para de parecer aleatório.

JunoNada: null e undefined Duas formas de dizer "nenhum valor". undefined é o padrão do JavaScript quando nada foi atribuído ainda. null é aquele que você escreve você mesmo para significar "vazio de propósito". Se você nunca deu a uma variável um valor, espere undefined.

JunoNada: null e undefined Ambos significam ausência, a diferença é quem o atribuiu. undefined aparece por conta própria, como uma variável declarada sem um valor. null é aquele que você atribui para marcar algo como deliberadamente vazio. Lê-los dessa forma informa se uma ausência foi um acidente ou uma escolha.

JunoNada: null e undefined A convenção faz o trabalho pesado aqui: undefined é a ausência que JavaScript lhe entrega, null é a ausência que você atribui de propósito. Então undefined frequentemente sinaliza "ninguém atribuiu isso", o que pode ser um bug, enquanto null lê como intenção. Mantenha-os distintos e comparações posteriores param de surpreendê-lo.

Verificando um tipo com typeof

Quando você não tem certeza de qual tipo um valor é, typeof informa. Coloque-o na frente de um valor e ele retorna uma string nomeando o tipo.

console.log(typeof "Maria"); // "string"
console.log(typeof 27); // "number"
console.log(typeof true); // "boolean"

Observe que a resposta é sempre texto, uma string como "number", não o tipo em si. Isso é útil quando você quer verificar com o que está lidando antes de usá-lo.

typeof relata o tipo de um valor como uma string. Coloque-o antes de qualquer valor e você volta com "string", "number", "boolean", e assim por diante.

const label = "checkout";
console.log(typeof label); // "string"
console.log(typeof 24.99); // "number"
console.log(typeof false); // "boolean"
console.log(typeof undefined); // "undefined"

Há uma peculiaridade que vale a pena conhecer agora, porque surpreende todos na primeira vez: typeof null é "object", não "null".

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

Este é um bug antigo na linguagem que nunca foi corrigido, porque corrigi-lo quebraria código antigo. Não é algo que você fez errado. Lembre-se que typeof null mente, e verifique null diretamente quando precisar.

typeof pega um valor e retorna uma string nomeando seu tipo. É a forma mais rápida de perguntar "o que estou segurando" em tempo de execução.

console.log(typeof "checkout"); // "string"
console.log(typeof 1499.5); // "number"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"

O único resultado que você deve memorizar é o fora do padrão: typeof null retorna "object", não "null".

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

Esta é uma peculiaridade histórica, um bug incorporado à primeira versão do JavaScript que nunca foi corrigido porque muito código existente agora depende da resposta errada. A consequência prática é que typeof sozinho não pode dizer que um valor é null; você verifica isso com uma comparação direta. É o exemplo clássico do trade-off de compatibilidade com versões anteriores do JavaScript, onde um erro conhecido permanece porque quebrá-lo quebraria a web.

JunoVerificando um tipo com typeof Coloque typeof na frente de um valor e ele informa o tipo, como uma string como "number". É a forma mais rápida de verificar o que você está segurando quando não tem certeza. A resposta é sempre texto, então typeof 27 te dá "number", aspas e tudo.

JunoVerificando um tipo com typeoftypeof retorna o tipo como uma string, o que permite que você verifique um valor antes de usá-lo. Cuidado com uma armadilha: typeof null é "object", não "null". É um bug que a linguagem manteve para compatibilidade, então teste null diretamente em vez de confiar em typeof lá.

JunoVerificando um tipo com typeoftypeof responde "qual é o tipo disso" como uma string em tempo de execução. O único resultado a memorizar é o errado: typeof null é "object", um bug da primeira versão congelado no lugar porque corrigi-lo quebraria a web. Então nunca pode confirmar null para você; verifique isso com uma comparação direta.

A visão geral dos tipos

Você conheceu os tipos cotidianos: string, número, booleano, além de null e undefined. Isso é o suficiente para armazenar a maioria do que um pequeno programa precisa. Capítulos posteriores adicionam formas de agrupar valores, mas cada um desses grupos ainda é construído a partir dos tipos simples que você já viu.

Por enquanto, o ganho é saber que cada valor tem um tipo, e que o tipo decide o que você pode fazer com o valor. Um número você pode somar; uma string você pode juntar; um booleano você pode verificar. Tenha operadores em mente como o próximo passo, porque é aí que você começa a combinar esses valores.

Os tipos até agora, string, número, booleano, null e undefined, são os tipos primitivos: simples, valores únicos. JavaScript também tem tipos não primitivos, aqueles que contêm coleções de valores, como arrays e objetos. Esses são cobertos em seus próprios capítulos, e se comportam de forma diferente de maneiras que valem a pena aprender quando você chegar lá.

Uma coisa para esclarecer agora: number é um único tipo. JavaScript não divide números inteiros e decimais em tipos separados como alguns idiomas fazem, então 10 e 10.5 são ambos do mesmo tipo number. Isso mantém números mais simples de raciocinar, com um tipo cobrindo cada valor numérico.

Os tipos cobertos aqui, string, número, booleano, null e undefined, são tipos primitivos: valores únicos e auto-contidos. Tudo mais, arrays e objetos, é um tipo de referência, que contém uma coleção e se comporta diferentemente quando você a copia ou compara. Essa diferença é a fonte de muitas surpresas, e ganha seu próprio tratamento quando esses tipos chegam.

Algumas coisas vale a pena sinalizar enquanto os tipos estão na mesa. number é um tipo para cada valor numérico, inteiro ou decimal, então não há um tipo de inteiro separado para raciocinar, coberto em números. Dois tipos primitivos adicionais existem que você raramente encontra cedo, bigint para inteiros muito grandes para um número normal, e symbol para chaves únicas. E os tipos não são fixos no lugar: JavaScript converterá um em outro em certas situações, um comportamento chamado coerção (por exemplo, transformar um número em uma string quando você os junta). Isso tem consequências reais, e operadores é onde começa a importar.

JunoA visão geral dos tipos Cada valor tem um tipo, e o tipo decide o que você pode fazer com ele: adicionar números, juntar strings, verificar booleanos. Os tipos cotidianos, string, número, booleano, além de null e undefined, cobrem a maioria do que um pequeno programa armazena. Capítulos posteriores agrupam valores, mas todos são construídos a partir desses.

JunoA visão geral dos tipos Os cinco que você conhece, string, número, booleano, null e undefined, são os tipos primitivos: valores simples únicos. Arrays e objetos são os não primitivos, chegando depois, e se comportam diferentemente. Fato útil: number é um tipo para 10 e 10.5, então sem inteiro e decimal separados para rastrear.

JunoA visão geral dos tipos Primitivos são valores únicos; arrays e objetos são tipos de referência que copiam e comparam diferentemente, que é onde as surpresas vivem. number cobre cada valor numérico, e bigint e symbol existem para os casos raros. Os tipos também se convertem um no outro, chamado coerção, e operadores é onde isso começa a importar, então mantenha no fundo da sua mente.

Por onde os tipos continuam daqui

Cada valor que você escreve, cada um que você lê de volta, carrega um tipo, e ficar fluente em nomeá-lo é a base para tudo o que vem depois. Os próximos capítulos pegam os dois que você manipulará mais e vão fundo: strings para trabalhar com texto, e números para cálculo. Depois disso, operadores é onde esses tipos começam a se encontrar, comparando, combinando e ocasionalmente convertendo, e saber qual tipo você tem é o que impede isso de surpreender você.