Data types

1-js/02-first-steps/05-types/article.md

@@ -2,7 +2,7 @@
 
 Uma variável em JavaScript é sempre de um certo tipo. Por exemplo, uma string ou um número.
 
-Há oito tipos de dados básicos em JavaScript. Aqui, vamos cobri-los em geral e nos próximos capítulos vamos falar sobre cada um deles em detalhe.
+Há oito tipos de dados básicos em JavaScript. Aqui, vamos cobri-los, em geral, e nos próximos capítulos vamos falar sobre cada um deles em detalhe.
 
 Podemos por qualquer tipo numa variável. Por exemplo, uma variável pode em um momento ser uma string e em outro um número:
 
@@ -25,7 +25,7 @@ O tipo *número* representa números inteiros e números 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: `Infinito`, `-Infinito` e `NaN`.
+Além dos números regulares, existem os chamados "valores numéricos especiais" que também pertencem aos tipos de dados: `Infinito`, `-Infinito` e `NaN`.
 
 - `Infinito` representa a matemática [Infinity](https://en.wikipedia.org/wiki/Infinity) ∞. É um valor especial que é maior que qualquer número.
 
@@ -68,27 +68,37 @@ Veremos mais sobre como trabalhar com números no capítulo <info:number>.
 
 ## BigInt [#bigint-type]
 
-In JavaScript, the "number" type cannot represent integer values larger than <code>(2<sup>53</sup>-1)</code> (that's `9007199254740991`), or less than <code>-(2<sup>53</sup>-1)</code> for negatives. It's a technical limitation caused by their internal representation.
+Em JavaScript, o tipo "number" não pode representar com segurança valores inteiros maiores que <code>(2<sup>53</sup>-1)</code> (que é `9007199254740991`) ou menores que <code>-( 2<sup>53</sup>-1)</code> para negativos.
 
-For most purposes that's quite enough, but sometimes we need really big numbers, e.g. for cryptography or microsecond-precision timestamps.
+Para ser realmente preciso, o tipo "number" pode armazenar números inteiros maiores (até <code>1.7976931348623157 * 10<sup>308</sup></code>), mas fora do intervalo de números inteiros seguros <code>±(2 <sup>53</sup>-1)</code> 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.
 
-`BigInt` type was recently added to the language to represent integers of arbitrary length.
+Por exemplo, estes dois números (logo acima da faixa segura) são iguais:
 
-A `BigInt` value is created by appending `n` to the end of an integer:
+```js
+console.log(9007199254740991 + 1); // 9007199254740992
+console.log(9007199254740991 + 2); // 9007199254740992
+```
+
+Por assim dizer, todos os números inteiros ímpares maiores que <code>(2<sup>53</sup>-1)</code> não podem ser armazenados no tipo "número".
+
+Para a maioria dos propósitos, o intervalo <code>±(2<sup>53</sup>-1)</code> é suficiente, mas às vezes precisamos de todo o intervalo de números inteiros realmente grandes, por exemplo, para criptografia ou carimbo do instante exato da data ou hora com precisão de microssegundos.
+
+O tipo `BigInt` foi adicionado recentemente à linguagem para representar inteiros de comprimento arbitrário. 
+
+Um valor `BigInt` é criado anexando `n` ao final de um inteiro:
 
 ```js
-// the "n" at the end means it's a BigInt
+// o "n" no final significa que é um BigInt
 const bigInt = 1234567890123456789012345678901234567890n;
 ```
 
-As `BigInt` numbers are rarely needed, we don't cover them here, but devoted them a separate chapter <info:bigint>. Read it when you need such big numbers.
-
+Como os números `BigInt` raramente são necessários, nós não os cobrimos aqui, mas dedicamos-lhes um capítulo separado <info:bigint>. Leia-o quando precisar de números tão grandes.
 
-```smart header="Compatibility issues"
-Right now, `BigInt` is supported in Firefox/Chrome/Edge/Safari, but not in IE.
+```smart header="Problemas de compatibilidade"
+No momento, o `BigInt` é suportado no Firefox/Chrome/Edge/Safari, mas não no IE.
 ```
 
-You can check [*MDN* BigInt compatibility table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) to know which versions of a browser are supported.
+Você pode verificar a [tabela de compatibilidade do *MDN* sobre BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#browser_compatibility) para saber quais versões de um navegador são suportadas.
 
 ## String
 
@@ -113,10 +123,10 @@ Backticks são citações de "funcionalidade estendida". Eles nos permitem incor
 ```js run
 let name = "John";
 
-// embed a variable
+// Incorporando uma variável
 alert( `Olá, *!*${name}*/!*!` ); // Olá, John!
 
-// embed an expression
+// Incorporando uma expressão
 alert( `o resultado é *!*${1 + 2}*/!*` ); // o resultado é 3
 ```
 
@@ -178,7 +188,7 @@ O código acima declara que `age` é desconhecido.
 
 O valor especial `undefined` também se diferencia. Faz um tipo próprio, tal como `null`.
 
-O significado de `undefined` é "o valor não é atribuído".
+O significado de `undefined` é "valor não foi atribuído".
 
 Se uma variável é declarada, mas não atribuída, então seu valor é `undefined`:
 
@@ -205,15 +215,15 @@ alert(age); // "undefined"
 
 O tipo `object` é especial.
 
-Todos os outros tipos são chamados de "primitivos" porque seus valores podem conter apenas uma única coisa (seja ela uma string, ou um número ou qualquer outra). Por outro lado, os objetos são usados para armazenar coleções de dados e entidades mais complexas.
+Todos os outros tipos são chamados de "primitivos" porque seus valores podem conter apenas uma única coisa (seja ela uma string, ou um número, ou qualquer outra). Por outro lado, 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. Nós vamos lidar com eles no capítulo <info: object>, depois que aprendermos mais sobre primitivos.
+Por serem tão importantes, os objetos merecem um tratamento especial. Nós vamos lidar com eles no capítulo <info:object>, depois que aprendermos mais sobre primitivos.
 
-O tipo `symbol` é usado para criar identificadores únicos para objetos. Nós o temos que mencionar aqui para completude, mas também adiar os seus detalhes até sabermos sobre objetos.
+O tipo `symbol` é usado para criar identificadores únicos para objetos. Nós o temos que mencionar aqui para completude, mas também adiaremos os seus detalhes até sabermos sobre objetos.
 
 ## The typeof operator [#type-typeof]
 
-O operador `typeof` retorna o tipo do argumento. É útil quando queremos processar valores de diferentes tipos de forma diferente ou apenas queremos fazer uma verificação rápida.
+O operador `typeof` retorna o tipo do argumento. É útil quando queremos processar valores de diferentes tipos ou apenas queremos fazer uma verificação rápida.
 
 A chamada para `typeof x` retorna uma string com o nome do tipo:
 
@@ -247,14 +257,14 @@ As três últimas linhas podem precisar de explicações adicionais:
 
 1. `Math` é um objeto embutido que fornece operações matemáticas. Nós o vamos aprender no capítulo <info:number>. Aqui, ele serve apenas como um exemplo de um objeto.
 2. O resultado de `typeof null` é `"object"`. É um erro oficialmente reconhecido no comportamento de `typeof`, vindo dos primeiros dias do JavaScript e mantido para compatibilidade. Naturalmente, `null` não é um objeto. É um valor especial com um tipo separado próprio. O comportamento de `typeof` é errado aqui.
-3. O resultado de `typeof alert` é `"function"`, porque `alert` é uma função. Vamos estudar as funções nos próximos capítulos onde veremos também que não há nenhum tipo especial "função" em JavaScript. As funções pertencem ao tipo objecto. Mas o `typeof` as trata de forma diferente, retornando `"function"`. Isto, também vem dos primeiros dias do JavaScript. Tecnicamente, é incorreto, mas muito conveniente na prática.
+3. O resultado de `typeof alert` é `"function"`, porque `alert` é uma função. Vamos estudar as funções nos próximos capítulos onde veremos também que não há nenhum tipo especial "função" em JavaScript. As funções pertencem ao tipo objeto. Mas o `typeof` as trata de forma diferente, retornando `"function"`. Isto, também vem dos primeiros dias do JavaScript. Tecnicamente, é incorreto, mas muito conveniente, na prática.
 
 ```smart header="A `sintaxe typeof(x)`"
-Você pode também encontrar outra sintaxe: `typeof(x)`. è o mesmo que `typeof x`.
+Você pode também encontrar outra sintaxe: `typeof(x)`. é o mesmo que `typeof x`.
 
-Para deixar claro: `typeof` é um operador, não uma função. Os parêntesis aqui não fazem parte de `typeof`. São o tipo de parêntesis usados em matemática para agrupamento.
+Para deixar claro: `typeof` é um operador, não uma função. Os parênteses aqui não fazem parte de `typeof`. São os parênteses usados em matemática para agrupamento.
 
-Geralmente, tais parêntesis contêm uma expressão matemática, como em `(2 + 2)`, mas aqui eles contêm apenas um argumento `(x)`. Sintáticamente, eles permitem evitar o espaço entre o operador `typeof` e o seu argumento, e algumas pessoas gostam disso.
+Geralmente, tais parênteses contêm uma expressão matemática, como em `(2 + 2)`, mas aqui eles contêm apenas um argumento `(x)`. Sintaticamente, eles permitem evitar o espaço entre o operador `typeof` e o seu argumento, e algumas pessoas gostam disso.
 
 Algumas pessoas preferem `typeof(x)`, embora a sintaxe `typeof x` seja muito mais comum.
 ```
@@ -274,7 +284,7 @@ Existem 8 tipos básicos em JavaScript.
 
 O operador `typeof` nos permite ver que tipo está armazenado em uma variável.
 
-- Geralmente, usado como `typeof x`, mas `typeof(x)` também é possivel.
+- Geralmente, usado como `typeof x`, mas `typeof(x)` também é possível.
 - Retorna uma string com o nome do tipo, como `"string"`.
 - Para `null` retorna `"object"` -- isso é um erro na linguagem, não é realmente um objeto.