Merge branch 'master' of github.com:danilolmc/pt.javascript.info into update-dynamic-imports

Author: danilolmc

1-js/09-classes/05-extend-natives/article.md

@@ -1,12 +1,12 @@
 
-# Extending built-in classes
+# Estendendo classes nativas
 
-Built-in classes like Array, Map and others are extendable also.
+Classes nativas como Array, Map e outras também podem ser estendidas.
 
-For instance, here `PowerArray` inherits from the native `Array`:
+Por exemplo, aqui `PowerArray` herda do `Array` nativo:
 
 ```js run
-// add one more method to it (can do more)
+// adiciona mais um método (pode fazer mais)
 class PowerArray extends Array {
   isEmpty() {
     return this.length === 0;
@@ -21,20 +21,20 @@ alert(filteredArr); // 10, 50
 alert(filteredArr.isEmpty()); // false
 ```
 
-Please note a very interesting thing. Built-in methods like `filter`, `map` and others -- return new objects of exactly the inherited type `PowerArray`. Their internal implementation uses the object's `constructor` property for that.
+Note uma coisa muito interessante. Métodos nativos, como `filter`, `map` e outros retornam novos objetos exatamente do tipo herdado `PowerArray`. Sua implementação interna usa a propriedade `constructor` do objeto para isso.
 
-In the example above,
+No exemplo acima,
 ```js
 arr.constructor === PowerArray
 ```
 
-When `arr.filter()` is called, it internally creates the new array of results using exactly `arr.constructor`, not basic `Array`. That's actually very cool, because we can keep using `PowerArray` methods further on the result.
+Quando `arr.filter()` é chamado, ele internamente cria o novo array de resultados usando exatamente `arr.constructor`, não o básico `Array`. Isso é realmente interessante, porque podemos continuar utilizando os métodos de `PowerArray` no resultado.
 
-Even more, we can customize that behavior.
+Ainda mais, podemos personalizar este comportamento.
 
-We can add a special static getter `Symbol.species` to the class. If it exists, it should return the constructor that JavaScript will use internally to create new entities in `map`, `filter` and so on.
+Podemos adicionar um getter estático especial chamado `Symbol.species` à classe. Se ele existir, deve retornar o construtor que o JavaScript usará internamente para criar novas entidades em `map`, `filter` e assim por diante.
 
-If we'd like built-in methods like `map` or `filter` to return regular arrays, we can return `Array` in `Symbol.species`, like here:
+Se quisermos que os métodos nativos como `map` ou `filter` retornem arrays regulares, podemos retornar `Array` em `Symbol.species`, como nesse exemplo:
 
 ```js run
 class PowerArray extends Array {
@@ -43,7 +43,7 @@ class PowerArray extends Array {
   }
 
 *!*
-  // built-in methods will use this as the constructor
+  // métodos nativos usarão isso como o construtor
   static get [Symbol.species]() {
     return Array;
   }
@@ -53,37 +53,37 @@ class PowerArray extends Array {
 let arr = new PowerArray(1, 2, 5, 10, 50);
 alert(arr.isEmpty()); // false
 
-// filter creates new array using arr.constructor[Symbol.species] as constructor
-let filteredArr = arr.filter(item => item >= 10);
+// filter cria um novo array usando arr.constructor[Symbol.species] como constructor
+let filteredArr = arr.filter(item => item >= 10); 
 
 *!*
-// filteredArr is not PowerArray, but Array
+// filteredArr não é PowerArray, mas Array
 */!*
 alert(filteredArr.isEmpty()); // Error: filteredArr.isEmpty is not a function
 ```
 
-As you can see, now `.filter` returns `Array`. So the extended functionality is not passed any further.
+Como você pode ver, agora `.filter` retorna `Array`. Assim, a funcionalidade estendida não é repassada adiante.
 
-```smart header="Other collections work similarly"
-Other collections, such as `Map` and `Set`, work alike. They also use `Symbol.species`.
+```smart header="Outras coleções funcionam similarmente"
+Outras coleções, como `Map` e `Set, funcionam da mesma forma. Elas também utilizam `Symbol.species`.
 ```
 
-## No static inheritance in built-ins
+## Sem herança estática em objetos nativos
 
-Built-in objects have their own static methods, for instance `Object.keys`, `Array.isArray` etc.
+Objetos nativos possuem seus próprios métodos estáticos, por exemplo `Object.keys`, `Array.isArray`, etc.
 
-As we already know, native classes extend each other. For instance, `Array` extends `Object`.
+Como já sabemos, classes nativas se estendem. Por exemplo, `Array` estende de `Object`.
 
-Normally, when one class extends another, both static and non-static methods are inherited. That was thoroughly explained in the article [](info:static-properties-methods#statics-and-inheritance).
+Normalmente, quando uma classe estende outra, métodos estáticos e não estáticos são herdados. Isso foi explicado detalhadamente no artigo [](info:static-properties-methods#statics-and-inheritance).
 
-But built-in classes are an exception. They don't inherit statics from each other.
+Mas as classes nativas são uma exceção. Elas não herdam métodos estáticos uma das outras.
 
-For example, both `Array` and `Date` inherit from `Object`, so their instances have methods from `Object.prototype`. But `Array.[[Prototype]]` does not reference `Object`, so there's no, for instance, `Array.keys()` (or `Date.keys()`) static method.
+Por exemplo, tanto `Array` quanto `Date` herdam de `Object`, então suas instâncias têm métodos de `Object.prototype`. No entanto `Array.[[Prototype]]` não referencia `Object`, então não existe, por exemplo, um método estático `Array.keys()` (ou `Date.keys()`).
 
-Here's the picture structure for `Date` and `Object`:
+Aqui está a estrutura visual para `Date` e `Object`:
 
 ![](object-date-inheritance.svg)
 
-As you can see, there's no link between `Date` and `Object`. They are independent, only `Date.prototype` inherits from `Object.prototype`.
+Como você pode ver, não existe ligação entre `Date` e `Object`. Eles são independentes, apenas `Date.prototype` herda de `Object.prototype`.
 
-That's an important difference of inheritance between built-in objects compared to what we get with `extends`.
+Essa é uma diferença importante de herança entre objetos nativos em comparação com o que obtemos com `extends`.

1-js/99-js-misc/05-bigint/article.md

@@ -1,130 +1,129 @@
 # BigInt
 
-[recent caniuse="bigint"]
+[BigInt recentemente adicionado ao caniuse="bigint"]
 
-`BigInt` is a special numeric type that provides support for integers of arbitrary length.
+BigInt é um tipo numérico especial que oferece suporte para inteiros de tamanho arbitrário.
 
-A bigint is created by appending `n` to the end of an integer literal or by calling the function `BigInt` that creates bigints from strings, numbers etc.
+Um bigint é criado anexando `n` ao final de um literal inteiro ou chamando a função `BigInt` que cria BigInts a partir de strings, números, etc.
 
 ```js
 const bigint = 1234567890123456789012345678901234567890n;
 
 const sameBigint = BigInt("1234567890123456789012345678901234567890");
 
-const bigintFromNumber = BigInt(10); // same as 10n
+const bigintFromNumber = BigInt(10); // o mesmo que 10n
 ```
 
-## Math operators
+## Operadores matemáticos
 
-`BigInt` can mostly be used like a regular number, for example:
+`BigInt` pode ser usado principalmente como um número comum, por exemplo:
 
 ```js run
 alert(1n + 2n); // 3
 
 alert(5n / 2n); // 2
 ```
 
-Please note: the division `5/2` returns the result rounded towards zero, without the decimal part. All operations on bigints return bigints.
+Perceba: a divisão `5/2` retorna o resultado arredondado para zero, sem a parte decimal. Todas as operações com BigInts retornam BigInts.
 
-We can't mix bigints and regular numbers:
+Não podemos misturar BigInts e números comuns:
 
 ```js run
-alert(1n + 2); // Error: Cannot mix BigInt and other types
+alert(1n + 2); // Erro: Não é possível misturar BigInt e outros tipos
 ```
 
-We should explicitly convert them if needed: using either `BigInt()` or `Number()`, like this:
+Devemos convertê-los explicitamente, se necessário, usando `BigInt()` ou `Number()`, assim:
 
 ```js run
 let bigint = 1n;
 let number = 2;
 
-// number to bigint
+// number para bigint
 alert(bigint + BigInt(number)); // 3
 
-// bigint to number
+// bigint para number
 alert(Number(bigint) + number); // 3
 ```
 
-The conversion operations are always silent, never give errors, but if the bigint is too huge and won't fit the number type, then extra bits will be cut off, so we should be careful doing such conversion.
+As operações de conversão são sempre silenciosas, nunca dão erros, mas se o bigint for muito grande e não couber no tipo número, então bits extras serão cortados, então devemos ter cuidado ao fazer a conversão.
 
-````smart header="The unary plus is not supported on bigints"
-The unary plus operator `+value` is a well-known way to convert `value` to a number.
+````smart header="O operador mais unário não é suportado em BigInts"
+O operador mais unário `+valor` é uma maneira bem conhecida de converter `valor` para um número.
 
-In order to avoid confusion, it's not supported on bigints:
+Para evitar confusão, não é suportado em BigInts:
 ```js run
 let bigint = 1n;
 
-alert( +bigint ); // error
+alert( +bigint ); // erro
 ```
-So we should use `Number()` to convert a bigint to a number.
+Então, devemos usar `Number()` para converter um BigInt em um número.
 ````
 
-## Comparisons
+## Comparações
 
-Comparisons, such as `<`, `>` work with bigints and numbers just fine:
+Comparações, como `<`, `>` funcionam bem com BigInts e números:
 
 ```js run
 alert( 2n > 1n ); // true
 
 alert( 2n > 1 ); // true
 ```
 
-Please note though, as numbers and bigints belong to different types, they can be equal `==`, but not strictly equal `===`:
+Note que, como números e BigInts pertencem a tipos diferentes, eles podem ser iguais `==`, mas não estritamente iguais `===`:
 
 ```js run
 alert( 1 == 1n ); // true
 
 alert( 1 === 1n ); // false
 ```
 
-## Boolean operations
+## Operações booleanas
 
-When inside `if` or other boolean operations, bigints behave like numbers.
+Quando dentro de `if` ou outras operações booleanas, BigInts se comportam como números.
 
-For instance, in `if`, bigint `0n` is falsy, other values are truthy:
+Por exemplo, em `if`, o bigint `0n` é falso, outros valores são verdadeiros:
 
 ```js run
 if (0n) {
-  // never executes
+  // nunca executa
 }
 ```
-
-Boolean operators, such as `||`, `&&` and others also work with bigints similar to numbers:
+Operadores booleanos, como `||`, `&&` e outros também funcionam com BigInts semelhante aos números:
 
 ```js run
-alert( 1n || 2 ); // 1 (1n is considered truthy)
+alert( 1n || 2 ); // 1 (1n é considerado verdadeiro)
 
-alert( 0n || 2 ); // 2 (0n is considered falsy)
+alert( 0n || 2 ); // 2 (0n é considerado falso)
 ```
 
 ## Polyfills
 
-Polyfilling bigints is tricky. The reason is that many JavaScript operators, such as `+`, `-` and so on behave differently with bigints compared to regular numbers.
+Fazer um polyfill para BigInts é complicado. A razão é que muitos operadores JavaScript, como `+`, `-` e assim por diante se comportam de maneira diferente com BigInts em comparação com números regulares.
 
-For example, division of bigints always returns a bigint (rounded if necessary).
+Por exemplo, a divisão de BigInts sempre retorna um bigint (arredondado se necessário).
 
-To emulate such behavior, a polyfill would need to analyze the code and replace all such operators with its functions. But doing so is cumbersome and would cost a lot of performance.
+Para emular tal comportamento, um polyfill precisaria analisar o código e substituir todos esses operadores com suas funções. Mas fazer isso é trabalhoso e custaria muito em termos de desempenho.
 
-So, there's no well-known good polyfill.
+Então, não há um polyfill bem conhecido e bom.
 
-Although, the other way around is proposed by the developers of [JSBI](https://github.com/GoogleChromeLabs/jsbi) library.
+Apesar disso, o caminho inverso é proposto pelos desenvolvedores da biblioteca [JSBI](https://github.com/GoogleChromeLabs/jsbi).
 
-This library implements big numbers using its own methods. We can use them instead of native bigints:
+Esta biblioteca implementa números grandes usando seus próprios métodos. Podemos usá-los em vez de BigInts nativos:
 
-| Operation | native `BigInt` | JSBI |
+| Operação | `BigInt` nativo | JSBI |
 |-----------|-----------------|------|
-| Creation from Number | `a = BigInt(789)` | `a = JSBI.BigInt(789)` |
-| Addition | `c = a + b` | `c = JSBI.add(a, b)` |
-| Subtraction	| `c = a - b` | `c = JSBI.subtract(a, b)` |
+| Criação a partir de Number | `a = BigInt(789)` | `a = JSBI.BigInt(789)` |
+| Adição | `c = a + b` | `c = JSBI.add(a, b)` |
+| Subtração	| `c = a - b` | `c = JSBI.subtract(a, b)` |
 | ... | ... | ... |
 
-...And then use the polyfill (Babel plugin) to convert JSBI calls to native bigints for those browsers that support them.
+...E então use o polyfill (plugin do Babel) para converter chamadas JSBI para BigInts nativos para aqueles navegadores que os suportam.
 
-In other words, this approach suggests that we write code in JSBI instead of native bigints. But JSBI works with numbers as with bigints internally, emulates them closely following the specification, so the code will be "bigint-ready".
+Em outras palavras, essa abordagem sugere que escrevamos código em JSBI em vez de BigInts nativos. Mas o JSBI trabalha com números como se fossem BigInts internamente, emula-os de perto seguindo a especificação, então o código será "pronto para bigint".
 
-We can use such JSBI code "as is" for engines that don't support bigints and for those that do support - the polyfill will convert the calls to native bigints.
+Podemos usar esse código JSBI "como está" para motores que não suportam BigInts e para aqueles que suportam - o polyfill converterá as chamadas para BigInts nativos.
 
-## References
+## Referências
 
-- [MDN docs on BigInt](mdn:/JavaScript/Reference/Global_Objects/BigInt).
-- [Specification](https://tc39.es/ecma262/#sec-bigint-objects).
+- [Documentação da MDN sobre BigInt](https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/BigInt).
+- [Especificação](https://tc39.es/ecma262/#sec-bigint-objects).