From 38e228ed256fe96f1f252298e5cb93a8f80a207b Mon Sep 17 00:00:00 2001 From: DaniloLima122 Date: Tue, 6 Feb 2024 17:21:30 -0300 Subject: [PATCH 1/3] it updates bigint article --- 1-js/99-js-misc/05-bigint/article.md | 89 ++++++++++++++-------------- 1 file changed, 44 insertions(+), 45 deletions(-) diff --git a/1-js/99-js-misc/05-bigint/article.md b/1-js/99-js-misc/05-bigint/article.md index 2a1cfc843..d5a402998 100644 --- a/1-js/99-js-misc/05-bigint/article.md +++ b/1-js/99-js-misc/05-bigint/article.md @@ -1,22 +1,22 @@ # 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 comprimento 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 regular, por exemplo: ```js run alert(1n + 2n); // 3 @@ -24,44 +24,44 @@ 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 regulares: ```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 unário mais não é suportado em bigints" +O operador unário mais `+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 @@ -69,7 +69,7 @@ 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 @@ -77,54 +77,53 @@ 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 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. +Embora, 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](mdn:/JavaScript/Reference/Global_Objects/BigInt). +- [Especificação](https://tc39.es/ecma262/#sec-bigint-objects). From e6157c8fc8604d7f4e4945586a8950dcb97cb154 Mon Sep 17 00:00:00 2001 From: DaniloLima122 Date: Wed, 7 Feb 2024 11:57:04 -0300 Subject: [PATCH 2/3] it improves grammar --- 1-js/99-js-misc/05-bigint/article.md | 42 ++++++++++++++-------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/1-js/99-js-misc/05-bigint/article.md b/1-js/99-js-misc/05-bigint/article.md index d5a402998..0f552e511 100644 --- a/1-js/99-js-misc/05-bigint/article.md +++ b/1-js/99-js-misc/05-bigint/article.md @@ -2,9 +2,9 @@ [BigInt recentemente adicionado ao caniuse="bigint"] -BigInt é um tipo numérico especial que oferece suporte para inteiros de comprimento arbitrário. +BigInt é um tipo numérico especial que oferece suporte para inteiros de tamanho arbitrário. -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. +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; @@ -16,7 +16,7 @@ const bigintFromNumber = BigInt(10); // o mesmo que 10n ## Operadores matemáticos -`BigInt` pode ser usado principalmente como um número regular, por exemplo: +`BigInt` pode ser usado principalmente como um número comum, por exemplo: ```js run alert(1n + 2n); // 3 @@ -24,15 +24,15 @@ alert(1n + 2n); // 3 alert(5n / 2n); // 2 ``` -Perceba: a divisão `5/2` retorna o resultado arredondado para zero, sem a parte decimal. Todas as operações com bigints retornam 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. -Não podemos misturar bigints e números regulares: +Não podemos misturar BigInts e números comuns: ```js run alert(1n + 2); // Erro: Não é possível misturar BigInt e outros tipos ``` -Devemos convertê-los explicitamente se necessário: usando `BigInt()` ou `Number()`, assim: +Devemos convertê-los explicitamente, se necessário, usando `BigInt()` ou `Number()`, assim: ```js run let bigint = 1n; @@ -47,21 +47,21 @@ alert(Number(bigint) + number); // 3 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="O operador unário mais não é suportado em bigints" -O operador unário mais `+valor` é uma maneira bem conhecida de converter `valor` para um número. +````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. -Para evitar confusão, não é suportado em bigints: +Para evitar confusão, não é suportado em BigInts: ```js run let bigint = 1n; alert( +bigint ); // erro ``` -Então, devemos usar `Number()` para converter um bigint em um número. +Então, devemos usar `Number()` para converter um BigInt em um número. ```` ## Comparações -Comparações, como `<`, `>` funcionam bem com bigints e números: +Comparações, como `<`, `>` funcionam bem com BigInts e números: ```js run alert( 2n > 1n ); // true @@ -69,7 +69,7 @@ alert( 2n > 1n ); // true alert( 2n > 1 ); // true ``` -Note que, como números e bigints pertencem a tipos diferentes, eles podem ser iguais `==`, mas não estritamente iguais `===`: +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 @@ -79,7 +79,7 @@ alert( 1 === 1n ); // false ## Operações booleanas -Quando dentro de `if` ou outras operações booleanas, bigints se comportam como números. +Quando dentro de `if` ou outras operações booleanas, BigInts se comportam como números. Por exemplo, em `if`, o bigint `0n` é falso, outros valores são verdadeiros: @@ -88,7 +88,7 @@ if (0n) { // nunca executa } ``` -Operadores booleanos, como `||`, `&&` e outros também funcionam com bigints semelhante aos números: +Operadores booleanos, como `||`, `&&` e outros também funcionam com BigInts semelhante aos números: ```js run alert( 1n || 2 ); // 1 (1n é considerado verdadeiro) @@ -98,17 +98,17 @@ alert( 0n || 2 ); // 2 (0n é considerado falso) ## Polyfills -Fazer 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. +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. -Por exemplo, a divisão de bigints sempre retorna um bigint (arredondado se necessário). +Por exemplo, a divisão de BigInts sempre retorna um bigint (arredondado se necessário). 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. Então, não há um polyfill bem conhecido e bom. -Embora, o caminho inverso é proposto pelos desenvolvedores da biblioteca [JSBI](https://github.com/GoogleChromeLabs/jsbi). +Apesar disso, o caminho inverso é proposto pelos desenvolvedores da biblioteca [JSBI](https://github.com/GoogleChromeLabs/jsbi). -Esta biblioteca implementa números grandes usando seus próprios métodos. Podemos usá-los em vez de bigints nativos: +Esta biblioteca implementa números grandes usando seus próprios métodos. Podemos usá-los em vez de BigInts nativos: | Operação | `BigInt` nativo | JSBI | |-----------|-----------------|------| @@ -117,11 +117,11 @@ Esta biblioteca implementa números grandes usando seus próprios métodos. Pode | Subtração | `c = a - b` | `c = JSBI.subtract(a, b)` | | ... | ... | ... | -...E então use o polyfill (plugin do Babel) para converter chamadas JSBI para bigints nativos para aqueles navegadores que os suportam. +...E então use o polyfill (plugin do Babel) para converter chamadas JSBI para BigInts nativos para aqueles navegadores que os suportam. -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". +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". -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. +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. ## Referências From eff18a09bdbb684787834c1dc733fcd80c38eeb9 Mon Sep 17 00:00:00 2001 From: DaniloLima122 Date: Wed, 7 Feb 2024 12:15:39 -0300 Subject: [PATCH 3/3] it fixes bigint article reference to MDN --- 1-js/99-js-misc/05-bigint/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1-js/99-js-misc/05-bigint/article.md b/1-js/99-js-misc/05-bigint/article.md index 0f552e511..325da34bd 100644 --- a/1-js/99-js-misc/05-bigint/article.md +++ b/1-js/99-js-misc/05-bigint/article.md @@ -125,5 +125,5 @@ Podemos usar esse código JSBI "como está" para motores que não suportam BigIn ## Referências -- [Documentação da MDN sobre BigInt](mdn:/JavaScript/Reference/Global_Objects/BigInt). +- [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).