From 0bf0fe270131d7a86f535a93ef77d8400b3ed320 Mon Sep 17 00:00:00 2001
From: Amirhossein Shahbazi <rballshahbazi2@gmail.com>
Date: Tue, 4 May 2021 21:46:32 +0430
Subject: [PATCH 1/3] correct true and false

---
 1-js/99-js-misc/05-bigint/article.md | 87 ++++++++++++++--------------
 1 file changed, 43 insertions(+), 44 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..3ac15e29c 100644
--- a/1-js/99-js-misc/05-bigint/article.md
+++ b/1-js/99-js-misc/05-bigint/article.md
@@ -2,21 +2,20 @@
 
 [recent caniuse="bigint"]
 
-`BigInt` is a special numeric type that provides support for integers of arbitrary length.
-
-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.
+`BigInt` یک نوع داده عددی خاص است که پشتیبانی برای تعریف اعداد صحیح با طول دلخواه را فراهم می کند.
 
+یک bigint را می توان با اضافه کردن حرف `n` به انتهای یک عدد صحیح و یا با فراخوانی تابع `BigInt` که bigint ها را از اعداد، رشته ها و غیره بوجود می آورد، ساخت.
 ```js
 const bigint = 1234567890123456789012345678901234567890n;
 
 const sameBigint = BigInt("1234567890123456789012345678901234567890");
 
-const bigintFromNumber = BigInt(10); // same as 10n
+const bigintFromNumber = BigInt(10); // با 10n یکسان است
 ```
 
-## Math operators
+## عملیات ریاضی
 
-`BigInt` can mostly be used like a regular number, for example:
+یک `BigInt` را می توان عمدتا به صورت یک عدد عادی استفاده کرد، برای مثال:
 
 ```js run
 alert(1n + 2n); // 3
@@ -24,44 +23,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.
+در نظر داشته باشید: عملیات تقسیم 5/2 نتیجه را بدون قسمت اعشار و رند شده به سمت صفر، باز می گرداند. همه ی عملیات بر روی bigint ها، مقداری را از نوع bigint باز می گردانند.
 
-We can't mix bigints and regular numbers:
+اعداد نوع bigint را نمی توان با اعداد معمولی مخلوط کرد:
 
 ```js run
-alert(1n + 2); // Error: Cannot mix BigInt and other types
+alert(1n + 2); // خطا: Cannot mix BigInt and other types
 ```
 
-We should explicitly convert them if needed: using either `BigInt()` or `Number()`, like this:
+می بایست آن ها ابتدا به صورت زیر، توسط `BigInt()` یا `Number()` تبدیل کرد:
 
 ```js run
 let bigint = 1n;
 let number = 2;
 
-// number to bigint
+// تبدیل نوع number به bigint
 alert(bigint + BigInt(number)); // 3
 
-// bigint to number
+// تبدیل نوع bigint به 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.
+عملیات تبدیل به صورت ساکت عمل می کنند، و خطایی باز نمی گردانند، اما اگر مقدار bigint بسیار بزرگ باشد و در نوع عدد (number) نگنجد، ارقام اضافی آن از بین خواهد رفت، پس در این نوع تبدیل همیشه مراقب باشید.
 
-````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="جمع یکانی بر روی bigint ها پشتیبانی نمی شود"
+عملگر جمع یکانی `+value` راهی شناخته شده برای تبدیل یک `value` به نوع داده عددی (number) است.
 
-In order to avoid confusion, it's not supported on bigints:
+برای جلوگیری از درهم شدن، این عملگر روی bigint ها پشتیبانی نمی شود.
 ```js run
 let bigint = 1n;
 
-alert( +bigint ); // error
+alert( +bigint ); // خطا
 ```
-So we should use `Number()` to convert a bigint to a number.
+باید ابتدا از `Number()` برای تبدیل یک bigint به نوع عددی استفاده کرد.
 ````
 
-## Comparisons
+## عملگرهای مقایسه
 
-Comparisons, such as `<`, `>` work with bigints and numbers just fine:
+عملگرهای مقایسه نظیر `<` و `>` بدون مشکل بر روی bigint ها و اعداد (number) کار می کنند:
 
 ```js run
 alert( 2n > 1n ); // true
@@ -69,7 +68,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 `===`:
+البته در نظر داشته باشید که با توجه به متفاوت بودن نوع داده ای bigint و number، با عملگر `==` می توان آن ها را مقایسه کرد، اما با عملگر `===` خیر.
 
 ```js run
 alert( 1 == 1n ); // true
@@ -77,54 +76,54 @@ alert( 1 == 1n ); // true
 alert( 1 === 1n ); // false
 ```
 
-## Boolean operations
+## عملیات منطقی
 
-When inside `if` or other boolean operations, bigints behave like numbers.
+داخل ساختارهای شرطی `if` یا سایر عملیات منطقی، bigint ها همچون اعداد معمولی رفتار می کنند.
 
-For instance, in `if`, bigint `0n` is falsy, other values are truthy:
+برای مثال، مقدار bigint برابر با `0n`، در ساختارهای شرطی، ناصحیح (false) است و سایر مقادیر، صحیح (true) هستند.
 
 ```js run
 if (0n) {
-  // never executes
+  // هیچ وقت اجرا نمی شود.
 }
 ```
 
-Boolean operators, such as `||`, `&&` and others also work with bigints similar to numbers:
+عملگرهای منطقی نظیر `||` و `&&` روی bigint ها، مشابه نوع عددی (number) عمل می کنند:
 
 ```js run
-alert( 1n || 2 ); // 1 (1n is considered truthy)
+alert( 1n || 2 ); // 1 (1n برابر با true است)
 
-alert( 0n || 2 ); // 2 (0n is considered falsy)
+alert( 0n || 2 ); // 2 (0n برابر با false است)
 ```
 
-## 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.
+پالیفیل کردن bigint ها مقداری متفاوت است، به این علت که بسیاری از عملگرهای جاوا اسکریپت، مثل `+`، `-` و بسیاری دیگر، واکنش های مختلفی را را با bigint ها نسبت به اعداد معمولی دارند.
 
-For example, division of bigints always returns a bigint (rounded if necessary).
+برای مثال، تقسیم bigint ها، همیشه یک مقدار bigint باز می گرداند، که در صورت لزوم، گرد می شود.
 
-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.
+برای تقلید چنین رفتاری، یک پالیفیل باید کد را بررسی کرده، و تمامی عملگرهای این چنین را با توابعش جایگزین کند. اما انجام چنین کاری سنگین است و به مقدار زیادی کارایی را کاهش می دهد.
 
-So, there's no well-known good polyfill.
+به همین خاطر، پالیفیل شناخته شده خوبی برای این کار وجود ندارد.
 
-Although, the other way around is proposed by the developers of [JSBI](https://github.com/GoogleChromeLabs/jsbi) library.
+با این حال، روش دیگری توسط توسعه دهندگان کتابخانه [JSBI](https://github.com/GoogleChromeLabs/jsbi) پیشنهاد شده است.
 
-This library implements big numbers using its own methods. We can use them instead of native bigints:
+این کتابخانه، اعداد بزرگ را به روش های خود پیاده سازی می کند. می توانیم از آنها به جای bigint های بومی جاوا اسکریپت استفاده کنیم: 
 
-| Operation | native `BigInt` | JSBI |
+| عملیات | بومی `BigInt` | 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)` |
+| ساختن از روی عدد | `a = BigInt(789)` | `a = JSBI.BigInt(789)` |
+| افزودن | `c = a + b` | `c = JSBI.add(a, b)` |
+| تفریق	| `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.
+و سپس می توان از پالیفیل (پلاگین Babel) برای تبدیل فراخوانی های JSBI به bigint های بومی استفاده کرد تا مرورگرها از آن پشتیبانی کنند.
 
-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".
+به بیانی دیگر، این رویکرد پیشنهاد می کند که به جای استفاده از bigint های بومی جاوا اسکریپت، کدهای مربوطه را در JSBI بنویسیم. اما JSBI با اعداد، همانند bigint ها به صورت داخلی کار می کند، و مطابق مشخصات تعیین شده، آن ها را به گونه ای تقلید می کند که کد، آماده استفاده bigint (bigint-ready) باشد.
 
-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.
+ما می توانیم کد JSBI را همان گونه که هست، چه برای موتور(engine) هایی که bigint ها را پشتیبانی می کنند، و چه برای آن هایی که پشتیبانی نمی کنند، استفاده کنیم. پالیفیل، فراخوانی های مربوطه را به bigint های بومی تبدیل می کند.
 
-## References
+## منابع
 
-- [MDN docs on BigInt](mdn:/JavaScript/Reference/Global_Objects/BigInt).
+- [مستندات MDN درباره BigInt](mdn:/JavaScript/Reference/Global_Objects/BigInt).
 - [Specification](https://tc39.es/ecma262/#sec-bigint-objects).

From 7254d00ef5199c30d396c1418479391d5eb807f3 Mon Sep 17 00:00:00 2001
From: Amirhossein Shahbazi <rballshahbazi2@gmail.com>
Date: Tue, 4 May 2021 23:44:46 +0430
Subject: [PATCH 2/3] add missed new line

---
 1-js/99-js-misc/05-bigint/article.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1-js/99-js-misc/05-bigint/article.md b/1-js/99-js-misc/05-bigint/article.md
index 3ac15e29c..3095f868d 100644
--- a/1-js/99-js-misc/05-bigint/article.md
+++ b/1-js/99-js-misc/05-bigint/article.md
@@ -5,6 +5,7 @@
 `BigInt` یک نوع داده عددی خاص است که پشتیبانی برای تعریف اعداد صحیح با طول دلخواه را فراهم می کند.
 
 یک bigint را می توان با اضافه کردن حرف `n` به انتهای یک عدد صحیح و یا با فراخوانی تابع `BigInt` که bigint ها را از اعداد، رشته ها و غیره بوجود می آورد، ساخت.
+
 ```js
 const bigint = 1234567890123456789012345678901234567890n;
 

From 75993541c4a75a25ddb11d7ba0ea0b725a7a4468 Mon Sep 17 00:00:00 2001
From: Amirhossein Shahbazi <rballshahbazi2@gmail.com>
Date: Thu, 6 May 2021 01:37:29 +0430
Subject: [PATCH 3/3] replace incorrect translations

---
 1-js/99-js-misc/05-bigint/article.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/1-js/99-js-misc/05-bigint/article.md b/1-js/99-js-misc/05-bigint/article.md
index 3095f868d..600a5994a 100644
--- a/1-js/99-js-misc/05-bigint/article.md
+++ b/1-js/99-js-misc/05-bigint/article.md
@@ -14,7 +14,7 @@ const sameBigint = BigInt("1234567890123456789012345678901234567890");
 const bigintFromNumber = BigInt(10); // با 10n یکسان است
 ```
 
-## عملیات ریاضی
+## عملگرهای ریاضی
 
 یک `BigInt` را می توان عمدتا به صورت یک عدد عادی استفاده کرد، برای مثال:
 
@@ -24,15 +24,15 @@ alert(1n + 2n); // 3
 alert(5n / 2n); // 2
 ```
 
-در نظر داشته باشید: عملیات تقسیم 5/2 نتیجه را بدون قسمت اعشار و رند شده به سمت صفر، باز می گرداند. همه ی عملیات بر روی bigint ها، مقداری را از نوع bigint باز می گردانند.
+در نظر داشته باشید: عملیات تقسیم `5/2` نتیجه را بدون قسمت اعشار و رند شده به سمت صفر، باز می گرداند. همه ی عملیات بر روی bigint ها، مقداری را از نوع bigint باز می گردانند.
 
 اعداد نوع bigint را نمی توان با اعداد معمولی مخلوط کرد:
 
 ```js run
-alert(1n + 2); // خطا: Cannot mix BigInt and other types
+alert(1n + 2); // Error: Cannot mix BigInt and other types
 ```
 
-می بایست آن ها ابتدا به صورت زیر، توسط `BigInt()` یا `Number()` تبدیل کرد:
+در صورت نیاز می بایست آن ها را به صورت زیر، توسط `BigInt()` یا `Number()` تبدیل کرد:
 
 ```js run
 let bigint = 1n;
@@ -56,10 +56,10 @@ let bigint = 1n;
 
 alert( +bigint ); // خطا
 ```
-باید ابتدا از `Number()` برای تبدیل یک bigint به نوع عددی استفاده کرد.
+پس باید از `Number()` برای تبدیل یک bigint به نوع عددی استفاده کنیم.
 ````
 
-## عملگرهای مقایسه
+## عملگرهای مقایسه ای
 
 عملگرهای مقایسه نظیر `<` و `>` بدون مشکل بر روی bigint ها و اعداد (number) کار می کنند:
 
@@ -92,9 +92,9 @@ if (0n) {
 عملگرهای منطقی نظیر `||` و `&&` روی bigint ها، مشابه نوع عددی (number) عمل می کنند:
 
 ```js run
-alert( 1n || 2 ); // 1 (1n برابر با true است)
+alert( 1n || 2 ); // 1 (1n، true در نظر گرفته می شود)
 
-alert( 0n || 2 ); // 2 (0n برابر با false است)
+alert( 0n || 2 ); // 2 (0n، false در نظر گرفته می شود)
 ```
 
 ## پالیفیل ها