Java, UX, HTML, CSS, WEB-design

Основное руководство по новейшему типу данных JavaScript: BigInt

Краткое описание по статье Основное руководство по новейшему типу данных JavaScript: BigInt

Название: Основное руководство по новейшему типу данных JavaScript: BigInt . Краткое описание: [ad_1] ⭐ Фараз К . Дата публикации: 23.01.2022 . Автор: Алишер Валеев .

Для чего создан сайт Novosti-Nedeli.ru

Данный сайт посвящен новостям мира и мира технологий . Также тут вы найдете руководства по различным девайсам.

Сколько лет сайту?

Возраст составляет 3 года

[ad_1]

  • Фараз Кельхини

  • 0 Комментарии

Основное руководство по новейшему типу данных JavaScript: BigInt

  • 8 минут чтения

  • JavaScript, Техники

Краткое резюме ↬

В JavaScript Number тип не может безопасно представлять целочисленные значения больше 253. Это ограничение вынуждает разработчиков использовать неэффективные обходные пути и сторонние библиотеки. BigInt — это новый тип данных, призванный исправить это.

То BigInt Тип данных предназначен для того, чтобы позволить программистам JavaScript представлять целочисленные значения, превышающие диапазон, поддерживаемый типом данных. Number тип данных. Возможность представления целых чисел с произвольной точностью особенно важна при выполнении математических операций над большими целыми числами. С участием BigInt, целочисленное переполнение больше не будет проблемой.

Кроме того, вы можете безопасно работать с временными метками высокого разрешения, большими целочисленными идентификаторами и многим другим, не прибегая к обходным решениям. BigInt в настоящее время находится на этапе 3 предложения. После добавления в спецификацию он станет вторым числовым типом данных в JavaScript, что доведет общее количество поддерживаемых типов данных до восьми:

  • логический
  • Нулевой
  • Неопределенный
  • Число
  • BigInt
  • Нить
  • Символ
  • Объект

В этой статье мы хорошо рассмотрим BigInt и посмотреть, как это может помочь преодолеть ограничения Number введите JavaScript.

Проблема

Отсутствие явного целочисленного типа в JavaScript часто сбивает с толку программистов из других языков. Многие языки программирования поддерживают несколько числовых типов, таких как float, double, integer и bignum, но это не относится к JavaScript. В JavaScript все числа представлены в 64-битном формате двойной точности с плавающей запятой, как определено стандартом IEEE 754-2008.

Еще после прыжка! Продолжить чтение ниже ↓

В соответствии с этим стандартом очень большие целые числа, которые не могут быть точно представлены, автоматически округляются. Чтобы быть точным, Number тип в JavaScript может безопасно представлять только целые числа между -9007199254740991 (-(253-1)) и 9007199254740991 (253-1). Любое целочисленное значение, выпадающее из этого диапазона, может потерять точность.

Это можно легко проверить, выполнив следующий код:

console.log(9999999999999999);    // → 10000000000000000

Это целое число больше, чем наибольшее число, которое JavaScript может надежно представить с помощью Number примитивный. Поэтому он округлый. Неожиданное округление может поставить под угрозу надежность и безопасность программы. Вот еще один пример:

// notice the last digits
9007199254740992 === 9007199254740993;    // → true

JavaScript предоставляет Number.MAX_SAFE_INTEGER константа, позволяющая быстро получить максимально безопасное целое число в JavaScript. Точно так же вы можете получить минимальное безопасное целое число, используя Number.MIN_SAFE_INTEGER постоянный:

const minInt = Number.MIN_SAFE_INTEGER;

console.log(minInt);         // → -9007199254740991

console.log(minInt - 5);     // → -9007199254740996

// notice how this outputs the same value as above
console.log(minInt - 4);     // → -9007199254740996

Решение

Чтобы обойти эти ограничения, некоторые разработчики JavaScript представляют большие целые числа с помощью String тип. То Твиттер API, например, добавляет строковую версию идентификаторов к объектам при ответе в формате JSON. Кроме того, для облегчения работы с большими целыми числами был разработан ряд библиотек, таких как bignumber.js.

С участием BigInt, приложениям больше не нужны обходные пути или библиотеки для безопасного представления целых чисел за пределами Number.MAX_SAFE_INTEGER и Number.Min_SAFE_INTEGER. Арифметические операции над большими целыми числами теперь можно выполнять в стандартном JavaScript без риска потери точности. Дополнительным преимуществом использования собственного типа данных по сравнению со сторонней библиотекой является более высокая производительность во время выполнения.

Чтобы создать BigInt, просто добавьте n до конца целого числа. Сравнивать:

console.log(9007199254740995n);    // → 9007199254740995n
console.log(9007199254740995);     // → 9007199254740996

В качестве альтернативы вы можете позвонить в BigInt() конструктор:

BigInt("9007199254740995");    // → 9007199254740995n

BigInt литералы также могут быть записаны в двоичной, восьмеричной или шестнадцатеричной системе счисления:


// binary
console.log(0b100000000000000000000000000000000000000000000000000011n);
// → 9007199254740995n

// hex
console.log(0x20000000000003n);
// → 9007199254740995n

// octal
console.log(0o400000000000000003n);
// → 9007199254740995n

// note that legacy octal syntax is not supported
console.log(0400000000000000003n);
// → SyntaxError

Имейте в виду, что вы не можете использовать оператор строгого равенства для сравнения BigInt на обычный номер, потому что они не одного типа:

console.log(10n === 10);    // → false

console.log(typeof 10n);    // → bigint
console.log(typeof 10);     // → number

Вместо этого вы можете использовать оператор равенства, который выполняет неявное преобразование типов перед сравнением своих операндов:

console.log(10n == 10);    // → true

Все арифметические операторы могут использоваться на BigInts кроме унарного плюса (+) оператор:

10n + 20n;    // → 30n
10n - 20n;    // → -10n
+10n;         // → TypeError: Cannot convert a BigInt value to a number
-10n;         // → -10n
10n * 20n;    // → 200n
20n / 10n;    // → 2n
23n % 10n;    // → 3n
10n ** 3n;    // → 1000n

let x = 10n;
++x;          // → 11n
--x;          // → 10n

Причина того, что унарный плюс (+) не поддерживается, заключается в том, что некоторые программы могут полагаться на инвариант, который + всегда производит Numberили выдает исключение. Изменение поведения + также сломает код asm.js.

Естественно, при использовании с BigInt операндов, ожидается, что арифметические операторы вернут BigInt ценность. Поэтому результат деления (/) автоматически усекается. Например:

25 / 10;      // → 2.5
25n / 10n;    // → 2n

Неявное преобразование типов

Поскольку неявное преобразование типов может привести к потере информации, смешанные операции между BigIntпесок Numberс не допускаются. При смешивании больших целых чисел и чисел с плавающей запятой результирующее значение может быть неточно представлено с помощью BigInt или Number. Рассмотрим следующий пример:

(9007199254740992n + 1n) + 0.5

Результат этого выражения находится за пределами домена обоих BigInt и Number. А Number с дробной частью нельзя точно преобразовать в BigInt. И BigInt больше 253 не может быть точно преобразован в Number.

В результате этого ограничения невозможно выполнять арифметические операции со смесью Number и BigInt операнды. Вы также не можете пройти BigInt к веб-API и встроенным функциям JavaScript, которые ожидают Number. Попытка сделать это вызовет TypeError:

10 + 10n;    // → TypeError
Math.max(2n, 4n, 6n);    // → TypeError

Обратите внимание, что реляционные операторы не следуют этому правилу, как показано в этом примере:

10n > 5;    // → true

Если вы хотите выполнить арифметические вычисления с BigInt и Number, сначала нужно определить домен, в котором должна выполняться операция. Для этого просто преобразуйте любой из операндов, вызвав Number() или BigInt():

BigInt(10) + 10n;    // → 20n
// or
10 + Number(10n);    // → 20

При встрече в Boolean контекст, BigInt лечится аналогично Number. Другими словами, BigInt считается истинным значением, пока оно не 0n:

if (5n) {
    // this code block will be executed
}

if (0n) {
    // but this code block won't
}

Нет неявного преобразования типов между BigInt и Number типы возникают при сортировке массива:

const arr = [3n, 4, 2, 1n, 0, -1n];

arr.sort();    // → [-1n, 0, 1n, 2, 3n, 4]

Побитовые операторы, такие как |, &, <<, >>, и ^ работать на BigInts аналогично Numberс. Отрицательные числа интерпретируются как дополнение до бесконечности до двух. Смешанные операнды не допускаются. Вот некоторые примеры:

90 | 115;      // → 123
90n | 115n;    // → 123n
90n | 115;     // → TypeError

Конструктор BigInt

Как и в случае с другими примитивными типами, BigInt может быть создан с помощью функции конструктора. Аргумент перешел к BigInt() автоматически преобразуется в BigInt, если возможно:

BigInt("10");    // → 10n
BigInt(10);      // → 10n
BigInt(true);    // → 1n

Типы данных и значения, которые не могут быть преобразованы, вызывают исключение:

BigInt(10.2);     // → RangeError
BigInt(null);     // → TypeError
BigInt("abc");    // → SyntaxError

Вы можете напрямую выполнять арифметические операции над BigInt созданный с помощью конструктора:

BigInt(10) * 10n;    // → 100n

При использовании в качестве операндов оператора строгого равенства BigInts, созданные с помощью конструктора, обрабатываются аналогично обычным:

BigInt(true) === 1n;    // → true

Библиотечные функции

JavaScript предоставляет две библиотечные функции для представления BigInt значения как целые числа со знаком или без знака:

  • BigInt.asUintN(width, BigInt): обертывает BigInt от 0 до 2ширина-1
  • BigInt.asIntN(width, BigInt): обертывает BigInt между -2ширина-1 и 2ширина-1-1

Эти функции особенно полезны при выполнении 64-битных арифметических операций. Таким образом, вы можете оставаться в пределах намеченного диапазона.

Поддержка браузера и транспиляция

На момент написания этой статьи Chrome +67 и Opera +54 полностью поддерживают BigInt тип данных. К сожалению, Edge и Safari еще не реализовали его. Фаерфокс не поддерживает BigInt по умолчанию, но его можно включить, настроив javascript.options.bigint к true в about:config. Актуальный список поддерживаемых браузеров доступен на странице Могу ли я использовать….

К сожалению, транспиляция BigInt это чрезвычайно сложный процесс, который влечет за собой значительное снижение производительности во время выполнения. Также невозможно напрямую полифиллировать BigInt потому что предложение меняет поведение нескольких существующих операторов. На данный момент лучшей альтернативой является использование библиотеки JSBI, которая представляет собой реализацию библиотеки на чистом JavaScript. BigInt предложение.

Эта библиотека предоставляет API, который ведет себя точно так же, как собственный BigInt. Вот как вы можете использовать JSBI:

import JSBI from './jsbi.mjs';

const b1 = JSBI.BigInt(Number.MAX_SAFE_INTEGER);
const b2 = JSBI.BigInt('10');

const result = JSBI.add(b1, b2);

console.log(String(result));    // → '9007199254741001'

Преимущество использования JSBI заключается в том, что после улучшения поддержки браузера вам не нужно будет переписывать свой код. Вместо этого вы можете автоматически скомпилировать код JSBI в родной код. BigInt код с помощью плагина babel. Кроме того, производительность JSBI находится на одном уровне с родным BigInt реализации. Вы можете рассчитывать на более широкую поддержку браузеров для BigInt скоро.

Вывод

BigInt — это новый тип данных, предназначенный для использования, когда целочисленные значения превышают диапазон, поддерживаемый Number тип данных. Этот тип данных позволяет нам безопасно выполнять арифметические операции над большими целыми числами, представлять временные метки с высоким разрешением, использовать идентификаторы больших целых чисел и многое другое без необходимости использования библиотеки.

Важно иметь в виду, что вы не можете выполнять арифметические операции со смесью Number и BigInt операнды. Вам нужно будет определить домен, в котором должна выполняться операция, путем явного преобразования любого из операндов. Кроме того, по соображениям совместимости вам не разрешено использовать унарный плюс (+) оператор на BigInt.

Что вы думаете? Вы находите BigInt полезный? Дайте нам знать об этом в комментариях!

Сокрушительная редакция
(дм, ук, иль)



[ad_2]
Source: https://smashingmagazine.com

Заключение

Вы ознакомились с статьей — Основное руководство по новейшему типу данных JavaScript: BigInt

Пожалуйста оцените статью, и напишите комментарий.

Похожие статьи

Добавить комментарий

Ваш адрес email не будет опубликован.

Кнопка «Наверх»