جاوا اسکریپت بیگ آئن

ਕੋਰਸ ਸਿਫਾਰਸ਼:

JavaScript BigInt ਪਰਿਵਾਰ ਦਾ ਵਰਗ ਵਰਗ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਪੂਰੇ ਸੰਖਿਆ ਦੇ ਮੁੱਲ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜੋ ਆਮ JavaScript ਨੰਬਰ ਵਿੱਚ ਪ੍ਰਤੀਬਿੰਬਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ。

JavaScript ਪੂਰੇ ਸੰਖਿਆ ਪ੍ਰਤੀਬਿੰਬਿਤ

JavaScript ਪੂਰੇ ਸੰਖਿਆ ਦੀ ਪ੍ਰਤੀਬਿੰਬਿਤ ਸਮਰੱਥਾ 15 ਦੇ ਬਾਅਦ ਕਮ ਹੋ ਜਾਂਦੀ ਹੈ:

ਪੂਰਾ ਸੰਖਿਆ ਪ੍ਰਤੀਬਿੰਬਿਤ
let x = 999999999999999;

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

let y = 9999999999999999;

ਜਿਵੇਂ ਕਿ JavaScript ਵਿੱਚ ਸਾਰੇ ਨੰਬਰ ਨੂੰ 64 ਬਿਟ ਫਲੌਟਿੰਗ ਪ੍ਰਫਾਰਮੈਟ (IEEE 754 ਮਿਆਰ) ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ。

ਇਸ ਮਿਆਰ ਅਨੁਸਾਰ، ਵੱਡੇ ਸੰਖਿਆ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਤੀਬਿੰਬਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਕਟੋਤੀ ਹੋ ਜਾਵੇਗੀ。

  • ਸਭ ਤੋਂ ਵੱਡਾ ਹੈ 9007199254740991（253-1）
  • ਸਭ ਤੋਂ ਛੋਟਾ ਹੈ -9007199254740991（-(253-1)）

ਇਸ ਪੱਧਰ ਤੋਂ ਵੱਧ ਦੇ ਪੂਰੇ ਸੰਖਿਆ ਦੇ ਮੁੱਲ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਤੀਬਿੰਬਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ。

ਕਿਵੇਂ BigInt ਬਣਾਉਣਾ ਹੈ

ਜੇਕਰ ਤੁਸੀਂ BigInt ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਪੂਰਾ ਸੰਖਿਆ ਦੇ ਅੰਤ ਵਿੱਚ 0x ਜੋੜ ਸਕਦੇ ਹੋ n، ਜਾਂ ਕਿਰਤੀਕਰਨ BigInt() ਫੰਕਸ਼ਨ:

ਉਦਾਹਰਣ 1

let x = 9999999999999999;
let y = 9999999999999999n;

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਉਦਾਹਰਣ 2

let x = 1234567890123456789012345n;
let y = BigInt(1234567890123456789012345);

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

BigInt: ਇੱਕ ਨਵਾਂ JavaScript ਤੇਜ਼ੀ ਤਰੀਕਾ

BigInt ਦਾ JavaScript ਤੇਜ਼ੀ ਤਰੀਕਾ "bigint：

ਮੰਤਰ

let x = BigInt(999999999999999);
let type = typeof x;

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

BigInt JavaScript ਵਿੱਚ ਦੂਜਾ ਨੰਬਰ ਤੇਜ਼ੀ ਤਰੀਕਾ ਹੈ (Number ਤੋਂ ਬਾਅਦ)

BigInt ਲਈ، JavaScript ਵਿੱਚ ਸਮਰੱਥ ਤੇਜ਼ੀ ਦਾ ਕੁੱਲ ਸੰਖਿਆ 8 ਤੋਂ ਵੱਧ ਹੈ:

  1. String
  2. Number
  3. Bigint
  4. Boolean
  5. Undefined
  6. Null
  7. Symbol
  8. Object

BigInt ਆਪਰੇਟਰ

JavaScript Number ਦੇ ਆਪਰੇਟਰਾਂ ਨੂੰ BigInt ਵਿੱਚ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ。

BigInt ਮੁੱਲ ਮੁਕਾਬਲਾ

let x = 9007199254740995n;
let y = 9007199254740995n;
let z = x * y;

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਧਿਆਨ

BigInt ਅਤੇ Number ਦਰਮਿਆਨ ਗਣਿਤਿਕ ਕਾਰਵਾਈ (ਪ੍ਰਕਾਰ ਤਬਦੀਲੀ) ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ (ਪ੍ਰਕਾਰ ਤਬਦੀਲੀ ਨਾਲ ਜਾਣਕਾਰੀ ਨੂੰ ਗਵਾ ਜਾ ਸਕਦਾ ਹੈ).

BigInt ਨੂੰ ਸਥਾਨਾਂ ਤੋਂ ਬਾਹਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਨਹੀਂ (>>>), ਕਿਉਂਕਿ ਇਸ ਕੋਲ ਨਿਸ਼ਚਿਤ ਚੌਦਾਈ ਨਹੀਂ ਹੈ。

BigInt ਛੋਟੀ ਗਿਣਤੀ

BigInt ਨੂੰ ਛੋਟੀ ਗਿਣਤੀ ਨਹੀਂ ਹੋ ਸਕਦੀ。

BigInt ਗਿਣਤੀ ਇੰਸਟੈਂਸ

let x = 5n;
let y = x / 2;
// ਐਰਰਰ: ਬਿਗਇੰਟ ਅਤੇ ਹੋਰ ਪ੍ਰਕਾਰਾਂ ਨੂੰ ਮਿਸ਼ਰਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ, ਪ੍ਰਤੀਯੋਗੀ ਤਬਦੀਲੀ ਵਰਤੋਂ.

let x = 5n;
let y = Number(x) / 2;

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

BigInt ਹੈਕਸਡੈਸੀਮਲ, ਆਕਟਲ ਅਤੇ ਬਾਈਨਰੀ

BigInt ਹੈਕਸਡੈਸੀਮਲ, ਆਕਟਲ ਜਾਂ ਬਾਈਨਰੀ ਪ੍ਰਤੀਯੋਗੀ ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ:

BigInt ਹੈਕਸਡੈਸੀਮਲ ਇੰਸਟੈਂਸ

let hex = 0x20000000000003n;
let oct = 0o400000000000000003n;
let bin = 0b100000000000000000000000000000000000000000000000000011n;

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਪ੍ਰੈਸਿਸ਼ਨ ਕੁਇਰੀ

ਰਾਉਂਡਿੰਗ ਪ੍ਰੋਗਰਾਮ ਸੁਰੱਖਿਆ ਨੂੰ ਹਾਨੀ ਪਹੁੰਚਾ ਸਕਦਾ ਹੈ:

MAX_SAFE_INTEGER ਇੰਸਟੈਂਸ

9007199254740992 === 9007199254740993; // ਕੀ ਨਹੀਂ!

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਬਰਾਉਜ਼ਰ ਸਮਰਥਨ

2020 ਸਾਲ ਸਤੰਬਰ ਤੋਂ ਲੈ ਕੇ ਸਾਰੇ ਬਰਾਉਜ਼ਰਾਂ ਨੇ BigInt ਨੂੰ ਸਮਰਥਨ ਕੀਤਾ:

ਚਰਾਮ ਐਂਜਲ ਫਾਇਰਫਾਕਸ ਸਫਾਰੀ ਓਪਰਾ
ਚਰਾਮ 67 ਐਂਜਲ 79 ਫਾਇਰਫਾਕਸ 68 ਸਫਾਰੀ 14 ਓਪਰਾ 54
2018 ਸਾਲ ਮਈ 2020 ਸਾਲ ਜਨਵਰੀ 2019 ਸਾਲ ਜੁਲਾਈ 2020 ਸਾਲ ਸਤੰਬਰ 2018 ਸਾਲ ਜੂਨ

ਸਭ ਤੋਂ ਛੋਟੇ ਅਤੇ ਸਭ ਤੋਂ ਵੱਡੇ ਸੁਰੱਖਿਅਤ ਨੰਬਰ

ES6 ਨੇ Number ਅਧਿਆਇ ਨੂੰ max ਅਤੇ min ਪ੍ਰਤੀਯੋਗੀਆਂ ਜੋੜੇ ਹਨ:

  • MAX_SAFE_INTEGER
  • MIN_SAFE_INTEGER

MAX_SAFE_INTEGER ਇੰਸਟੈਂਸ

let x = Number.MAX_SAFE_INTEGER;

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

MIN_SAFE_INTEGER ਇੰਸਟੈਂਸ

let x = Number.MIN_SAFE_INTEGER;

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਨਵੇਂ ਨੰਬਰ ਮੈਥਡ

ES6 ਨੇ Number ਅਧਿਆਇ ਨੂੰ ਦੋ ਨਵੇਂ ਮੈਥਡ ਜੋੜੇ ਹਨ:

  • Number.isInteger()
  • Number.isSafeInteger()

Number.isInteger() ਮੈਥਡ

ਜੇਕਰ ਪੈਰਾਮੀਟਰ ਇੰਟੀਜਰ ਹੈ ਤਾਂ Number.isInteger() ਮੈਥਡ ਵਾਪਸ ਠੀਕ ਹੈ.

isInteger() ਇੰਸਟੈਂਸ

Number.isInteger(10);
Number.isInteger(10.5);

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

Number.isSafeInteger() ਮੈਥਡ

ਸੁਰੱਖਿਅਤ ਨੰਬਰ ਹਨ ਜੋ ਕਿ ਦੋ ਪੁਲਾਂਗ ਨੰਬਰ ਵਿੱਚ ਨਿਸ਼ਚਿਤ ਰੂਪ ਨਾਲ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰ ਸਕਦੇ ਹਨ。

ਜੇਕਰ ਪੈਰਾਮੀਟਰ ਸੁਰੱਖਿਅਤ ਨੰਬਰ ਹੈ ਤਾਂ Number.isSafeInteger() ਮੈਥਡ ਵਾਪਸ ਠੀਕ ਹੈ.

isSafeInteger() ਇੰਸਟੈਂਸ

Number.isSafeInteger(10);
Number.isSafeInteger(12345678901234567890);

ਸੁਭਾਵਿਕ ਰੂਪ ਵਿੱਚ ਕੋਸ਼ਿਸ਼ ਕਰੋ

ਸੁਰੱਖਿਅਤ ਨੰਬਰ ਹਨ - (253 - 1) ਤੋਂ +(253 - 1) ਦੇ ਸਾਰੇ ਨੰਬਰ

ਇਹ ਇੱਕ ਸੁਰੱਖਿਅਤ ਨੰਬਰ ਹੈ: 9007199254740991।ਇਹ ਇੱਕ ਸੁਰੱਖਿਅਤ ਨੰਬਰ ਨਹੀਂ ਹੈ: 9007199254740992।