Эта статья дает вам необходимые знания о JavaScript и в основном знакомит с соответствующими сведениями о числовых типах. В JavaScript есть два типа чисел: типы Number и BigInt. Надеюсь, они будут вам полезны. помощь.
[Рекомендации по теме: видеоурок по JavaScript, веб-интерфейс]
В JavaScript есть два типа чисел:
Тип Number , который представляет собой числовой тип в традиционном смысле этого слова, хранится в 64 битном формате IEEE-754 и представляет собой «число с плавающей запятой двойной точности». типа Number ;
Тип BigInt представляет целые числа любой длины. Обычно мы не используем их, если они не представляют числа, отличные от 2 53 до -2 53. Мы подробно представим эти профессиональные типы данных в последующих главах;
Способ записи чисел очень прост, но JavaScrpt есть много удобных и быстрых синтаксических сахаров, которые мы можем использовать. Изучение этих синтаксических сахаров не только улучшит наши способности к чтению кода, но и улучшит его понимание на высоком уровне.
Десятичные числа — самые простые, и мы будем использовать их практически в каждой статье. Например, мы создаем переменную и храним 100 миллиардов:
пусть десять миллиардов = 10000000000;
Хотя операция очень простая, есть проблема: сложно посчитать, сколько 0 следует 1 Если мы пишем код перевода, неправильный 0 может привести к банкротству.
На данный момент мы можем использовать _ в качестве разделителя следующим образом:
пусть десять миллиардов = 10_000_000_000;
Приведенный выше код может явно подсчитать количество 0 , что, очевидно, является оптимальным решением!
_ здесь — это синтаксический сахар JavaScript , который будет игнорироваться движком во время выполнения. Два вышеупомянутых метода записи имеют одинаковый эффект, но опыт чтения сильно различается.
Мозговая цепь Цинци
Некоторая детская обувь должна спросить, я всегда был в группах по 4 0 с детства, почему мне нужно группировать 3 0 ? Поэтому мы можем без проблем записать это следующим образом:
пусть десять миллиардов = 100_0000_0000;
Или это можно было бы написать так:
пусть десять миллиардов = 1_0000_0000_00;
Здесь я хочу сказать, что какой бы метод деления вы ни использовали, он не повлияет на размер самого числа. Придумайте самый мощный метод!
Хотя с помощью _ можно элегантно разделить множество 0 , в реальной жизни мы обычно так не пишем. Например, мы часто пишем 10000000000 как «10 миллиардов», так что многие 0 можно опустить, тем самым уменьшая возможность создания. ошибки.
JavaScript также предоставляет возможность опустить 0 Мы можем использовать букву e за которой следует число, чтобы представить число 0 Например:
let tenbillion = 1e10;//10 миллиардов, 1, за которым следует 10 0sconsole.log(3.14e9);//3140000000, за которым следуют 7 0, пожалуйста, посмотрите вниз, если у вас есть вопросы.
Понимание приведенного выше кода очень просто. e10 можно понимать как 1_0000_0000_00 0 то есть 1 за которым следует 10 , поэтому мы можем подумать:
1e10 === 1 * 1_0000_0000_00;//e10 означает 1, за которым следует 10 03.14e9 === 3.14 * 1_000_000_000;//e9 означает 1, за которым следуют 9 0
Мы также можем использовать этот метод для представления очень малых чисел, например 1 нанометра:
пусть нм = 0,000000001 //Единица измерения (метр)
Поскольку 0 слишком много, мы также можем использовать _ :
пусть нм = 0,000_000_001;
Конечно, вы также можете использовать e , чтобы опустить все 0 , следующим образом:
пусть nm = 1e-9;//9 0 слева от 1, включая 0 перед десятичной запятой
Другими словами, e-9 означает 1 -9 , что равно 1/1000_000_000 , поэтому следующее уравнение верно:
1e-9 === 1/1_000_000_000;3.14e-8 === 3.14/1_000_000_00;
Шестнадцатеричный формат — это формат, обычно используемый в программировании, например, цвет, кодировка и т. д. Мы можем добавить 0x перед обычными числами, чтобы представить шестнадцатеричные числа:
let hex = 0xff;//255, регистр не учитывается, 0xFF то же самое
Двоичные числа начинаются с 0b :
пусть bin = 0b1011;//11
Восьмеричные числа начинаются с 0o :
пусть окт = 0o777;//511
Этот простой метод записи поддерживает только эти три специальных типа. Что касается других базовых чисел, для их генерации можно использовать специальные функции ( parseInt ).
Метод toString может преобразовать число в строковую форму, соответствующую base .
Дайте каштан:
пусть число = 996; console.log(num.toString(8));//Преобразовать в восьмеричную строку console.log(num.toString(16));//Преобразовать в шестнадцатеричную строку console.log(num.toString( 32));// Преобразовать в 32-шестнадцатеричную строку
Результаты выполнения кода следующие:
Диапазон base может быть от 2 до 36 Если не заполнен, значение по умолчанию — 10 .
Обратите внимание: если вы используете числа для прямого вызова метода toString , в некоторых случаях вам нужно применить два . например:
console.log(123.toString(8));//Ошибка, синтаксическая ошибка console.log(123..toString(8));//Исправно, 173
После числа есть два . Это связано с тем, что в JavaScript первая . после числа считается десятичной точкой, а вторая точка — это .
Если это десятичное число, этой проблемы не существует. Например:
console.log(3.14.toString(8));
Или мы можем использовать круглые скобки, чтобы избежать использования двух точек, например:
console.log((123).toString(8));//'173
Округление является одной из наиболее распространенных операций над числами и обычно включает в себя:
Округлить вниз, Math.floor(num)
console.log(Math.floor(3.14));//3 console.log(Math.floor(9.99));//9 console.log(Math.floor(-3.14));//-4 console.log(Math.floor(-9.99));//-10
Не следуйте принципу округления и сразу берите ближайшее целое число, меньшее или равное текущему значению.
Округление вверх, Math.ceil(num)
console.log(Math.ceil(3.14));//4 console.log(Math.ceil(9.99));//10 console.log(Math.ceil(-3.14));//-3 console.log(Math.ceil(-9.99));//-9
Не следуйте принципу округления и сразу берите ближайшее целое число, большее или равное текущему числу.
Округление до ближайшего целого числа, Math.round(num)
console.log(Math.round(3.14));//3 console.log(Math.round(9.99));//10 console.log(Math.round(-3.14));//-3 console.log(Math.round(-9.99));//-10
Следуя принципу округления, берется ближайшее к текущему числу целое число.
Удалить десятичные дроби, Math.trunc(num)
console.log(Math.trunc(3.14));//3 console.log(Math.trunc(9.99));//9 console.log(Math.trunc(-3.14));//-3 console.log(Math.trunc(-9.99));//-9
Непосредственно удалите числа после десятичной точки и округлите до целых цифр. Браузер IE не поддерживает этот метод
Сравните четыре вышеуказанных метода:
| Мат.пол | Math.ceil | Матем.раунд | Math.trunc | |
|---|---|---|---|---|
| 3.14 | 3 | 4 | 3 | 3 |
| 9,99 | 9 | 10 | 10 | 9 |
| -3,14 | -4 | -3 | -3 | -3 |
| -9,99 | -10 | -9 | -10 | -9 |
Приведенный выше метод просто округляет десятичное число до целого числа. В некоторых случаях нам нужны десятичные дроби с определенной точностью. Например, что нам делать, если мы возьмем последние 4 цифры числа Пи?
Есть два метода:
математический счет умножения и деления
let pi = 3.1415926;console.log(Math.round(pi * 10000)/10000);//3.1416
Приведенный выше код сначала умножает pi на 10000 , затем округляет его, а затем делит на 10000 , получая таким образом результат, соответствующий требованиям точности. Однако это кажется глупым, и JavaScript предоставляет нам более простой путь.
toFixed(n)
let pi = 3.1415926;console.log(pi.toFixed(4));//3.1416
Кажется, что в приведенном выше коде нет проблем с выводом. Фактически, toFixed возвращает строку. Если нам нужен числовой тип, нам нужно его преобразовать. Мы можем использовать унарный оператор + pi.toFixed(4) .
Кроме того, если десятичная мантисса недостаточно длинна, toFixed добавит в конце '0' :
пусть num = 3.1;console.log(num.toFixed(9));
Результаты выполнения кода следующие: 
Это также доказывает, что возвращаемое значение toFixed является строкой, в противном случае 0 будет опущен.
Представления с плавающей запятой во многих случаях всегда предвзяты.
Внутри компьютера числа с плавающей запятой представлены в соответствии со стандартом IEEE-754 , где числа с плавающей запятой одинарной точности составляют 32 бита, а числа с плавающей запятой двойной точности — 64 бита. В числах двойной точности с плавающей запятой 1 бит используется для представления знака, 52 бита используются для хранения значащих цифр и 11 бит используются для хранения положения десятичной точки.
Хотя 64 бита уже могут представлять очень большие числа, все же существует возможность пересечь границу, например:
let bigNum = 1e999;console.log(bigNum);//Бесконечность
Число, превышающее максимальное значение, станет Infinity (бесконечностью), потеряв при этом размер исходного числа, что является своего рода отклонением.
Есть еще один вид отклонения, который нам нужно изучить:
console.log(0.1+0.2 === 0.3);//falseconsole.log(0.1 + 0.2);
Результаты выполнения кода следующие:
Правильно, результат 0.1 + 0.2 — это не 0.3 , а набор 0 за которыми следует 4 .
Такое отклонение очень фатально, особенно в сценариях работы торговых центров и банков. Даже очень небольшое отклонение приведет к потере бесконечного богатства в сценариях с высоким оборотом.
Однажды я слышал историю о служащем банка, который украл миллионы долларов, вычитая зарплату работникам. Зарплата каждого сотрудника составляла всего 20 центов!
Думаю, если бы такое случилось со мной, я бы точно не смог его найти, поэтому так важно всегда быть точным.
Я не знаю, правдива эта история или нет~~
Давайте возьмем в качестве примера нашу обычную десятичную систему. Мы все знаем, что в десятичных дробях есть две странные вещи: одна называется бесконечными повторяющимися десятичными дробями, а другая — бесконечными неповторяющимися десятичными дробями. Например, 1/3 — это бесконечное повторение. десятичное 0.3333333(3) и пи. Это бесконечная неповторяющаяся десятичная дробь. Бесконечность означает, что размер числа невозможно четко описать численно, а то, что мы можем написать, является неточным.
Существуют также бесконечно повторяющиеся числа в двоичной системе счисления. Разница в том, что в десятичной системе число вроде 0.1 которое выглядит очень просто, представляет собой бесконечно повторяющуюся десятичную дробь.
Например:
пусть x = 0,1;console.log(x.toFixed(20));
Результаты выполнения кода следующие:
Вам не кажется, что это невероятно? Мы просто создали переменную и присвоили ей значение 0.1 , а затем взяли 20 знаков после запятой, и получили невероятный результат.
Если мы изменим угол, возможно, будет легче понять это явление. В десятичной системе любое целое число, разделенное на 10 или 10 целых степеней, является нормальным и точным числом, например 1/10 или 996/1000 . Однако если вы разделите на 3 , вы получите зацикленный результат, например 1/3 .
Это описание также действительно, если оно преобразовано в двоичный формат.
В двоичном формате любое целое число, разделенное на 2 , или целая степень 2 является обычным точным числом. Однако, если вы разделите его на 10 , вы получите бесконечный цикл двоичных чисел.
Следовательно, мы можем заключить, что двоичные числа не могут точно представлять 0.1 и 0.2 точно так же, как десятичные не могут описать 1/3 .
Уведомление:
Такое отклонение данных не является дефектом JavaScript, это тот же результат для PHP, Java, C, Perl и Ruby.
Округление
При отображении бесконечно повторяющейся десятичной дроби мы можем напрямую использовать метод toFixed для округления десятичной дроби. Этот метод напрямую возвращает строку, что очень удобно для отображения цен.
0.3.toFixed(2);//0.30
Используйте небольшие единицы
Другой способ заключается в том, что мы можем использовать более мелкие единицы для расчета цен и расстояний, например, использовать центы вместо юаней для расчета общей цены. Фактически, многие торговые сайты делают это. Однако этот метод только уменьшает количество вхождений десятичных знаков, и полностью избежать их появления невозможно.
В числах JavaScript есть два специальных значения: Infinity и NaN .
Как определить, является ли число нормальным числом?
Мы можем использовать два метода:
isFinite (значение)
Эта функция преобразует параметр val в числовой тип, затем определяет, является ли число конечным, и возвращает true если число не имеет значения NaN , Infinity или -Infinity .
console.log(isFinite(NaN));//falseconsole.log(isFinite(Infinity));//falseconsole.log(isFinite(3));//trueconsole.log(isFinite('12'));// истинный Результаты выполнения кода следующие: 
Поскольку строка, которую невозможно преобразовать в число, будет преобразована в NaN , мы можем использовать метод isFinite чтобы определить, является ли строка числовой строкой:
console.log(isFinite('xxxx'));//falseconsole.log(isFinite('Infinite'));//falseconsole.log(isFinite(' '));//true, пустая строка преобразуется в 0Результаты выполнения кода следующие:
isNaN(val)
Возвращает true если val равно NaN или другому значению, которое невозможно преобразовать в число.
console.log(isNaN(NaN));//trueconsole.log(isNaN('Infinite'));//true Результаты выполнения кода: 
Зачем использовать функцию isNaN вместо того, чтобы читать ее напрямую?
Например:
console.log(NaN === NaN);//false
Результаты выполнения кода следующие: 
Это связано с тем, что NaN не равно никакому числу, включая само себя.
Object.is(a,b) может определить, равны ли параметры a и b . Если они равны, он возвращает true , в противном случае он возвращает false . Его результаты имеют только три ситуации:
Можно сравнить с NaN
console.log(Object.is(NaN,NaN));//true
Результаты выполнения кода:
0 и -0
console.log(Object.is(0,-0));//false
Результаты выполнения кода:
В компьютере положительные и отрицательные значения обозначаются 0 и 1 Из-за разных знаков 0 и -0 на самом деле разные и выражаются по-разному.
другой
Другие ситуации сравнения точно такие же, как a === b .
parseInt и parseFloat могут преобразовывать строки в числа. В отличие от + и Number их ограничения менее строгие. Например, использование + и Number для строки типа "100￥" неизбежно вернет NaN , но parseInt и parseFloat легко с этим справятся.
Например:
console.log(+"100￥");console.log(parseInt("100￥"));console.log(parseFloat("12.5￥"));Результаты выполнения кода:
parseInt и parseFloat считывают числа из строки до тех пор, пока их больше нельзя будет прочитать. Оба особенно подходят для обработки строк, начинающихся с таких чисел, как "99px" и "11.4em" , но NaN возвращается для строк, начинающихся с других символов.
console.log(parseInt('ff2000'));//NaN Однако мы обнаружили, ff2000 на самом деле представляет собой шестнадцатеричную цифровую строку. parseInt также может справиться с этой ситуацией, но ему необходимо добавить шестнадцатеричный параметр.
Например:
console.log(parseInt('FF2000',16));
//16719872
console.log(parseInt('0xFF2000',16));
//16719872
console.log(parseInt('nnnnnn',36));
//1430456963Результаты выполнения кода:
Встроенный объект Math содержит множество констант и методов, которые мы часто используем. Вот лишь несколько примеров часто используемых:
Матем.ПИ
Pi Π — бесконечная нециклическая константа, вместо нее мы можем использовать Math.PI :
console.log(Math.PI);
Мат.случайный()
Сгенерируйте случайное число в интервале [0,1) :
console.log(Math.random());console.log(Math.random());
Если нам нужно случайное число в определенном диапазоне, мы можем умножить его на определенное значение, а затем округлить.
Math.pow(a,b)
Вычислите a b , например:
console.log(Math.pow(2,3));//8
Мат.макс()/Матем.мин()
Выберите максимальное/минимальное значение из любого количества аргументов:
console.log(Math.max(1,2,3,4,5));//5console.log(Math.min(1,2,3,4,5));//1
