Как возвести число в степень в javascript

Объект Math предоставляет ряд математических функций, которые можно использовать при вычислениях. Рассмотрим основные математические функции.

Функция abs() возвращает абсолютное значение числа:

min() и max()

Функции min() и max() возвращают соответственно минимальное и максимальное значение из набора чисел:

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

Функция ceil() округляет число до следующего наибольшего целого числа:

Выражение Math.ceil(9.2) возвращает число 10, так как число 10 следующее наибольшее целое число после 9.2. И также выражение Math.ceil(-5.9) возвращает -5, потому что число -5 следующее наибольшее целое после -5.9

floor()

Функция floor() округляет число до следующего наименьшего целого числа:

round()

Функция round() округляет число до следующего наименьшего целого числа, если его десятичная часть меньше 0.5. Если же десятичная часть равна или больше 0.5, то округление идет до ближайшего наибольшего целого числа:

random()

Функция random() возвращает случайное число с плавающей точкой их диапазона от 0 до 1:

Функция pow() возвращает число в определенной степени. Например, возведем число 2 в степень 3:

Функция sqrt() возвращает квадратный корень числа:

Функция log() возвращает натуральный логарифм числа:

Тригонометрические функции

Целый ряд функций представляют тригонометрические функции: sin() (вычисляет синус угла), cos() (вычисляет косинус угла), tan() (вычисляет тангенс угла).

Функция asin() вычисляет арксинус числа, acos — арккосинус, а atan() — арктангенс числа:

Константы

Кроме методов объект Math также определяет набор встроенных констант, которые можно использовать в различных вычислениях:

Математика и константы — Введение в программирование

Конечно, компьютеры отлично справляются с вычислениями чисел. И когда дело касается простой математики, JavaScript довольно прямолинеен. Есть пять основных операций: сложение, вычитание, умножение, деление и остаток от деления. Ещё есть скобки, как и в обычной математике, которые помогают явно указывать последовательность вычислений.

Взгляните на это: 25 * 91. 25 и 91 называются операндами, а звёздочка — оператором умножения.

Вот немного более усложнённый пример: ((12 * 5) — 4) / 12.

В начале JavaScript производит умножение, затем вычитает 4, поскольку есть скобки, а потом делит результат на 12.

Все операторы здесь инфиксные: они находятся между операндами (в данном случае — между числами). Ещё есть префиксные операторы (например, знак минус, который обозначает отрицательное число: -5 ) и постфиксные (например, быстрое увеличение на один: x++ ). Мы изучим их позже.

В какой-то момент вы столкнётесь с необычной проблемой: если вы попытаетесь сложить 0.1 + 0.2 в JavaScript, результатом будет 0.30000-много-много-нулей-4, а не 0.3. Это потому что компьютеры хранят числа в другом формате. Глубоко внутри все числа — это множество единиц и нулей, подчинённых определённым правилам, и это не лучший формат для хранения любых чисел.

Это может показаться нелепым — почему мы позволяем компьютерам использовать такую плохую систему? На самом деле она не настолько плохая или глупая. Такой формат удобен для определённого набора задач и не слишком удобен для другого.

Также в JavaScript есть несколько терминов, которые нужны для формулировки определённых значений: разделите положительное число на 0 и получится "Бесконечность" — Infinity ; разделите отрицательное число на 0 и получится "-Бесконечность" — -Infinity . В своих программах вы можете использовать Бесконечности как числа с другими операторами. Например, с Бесконечностью можно производить сложение.

Иногда вычисления не производят конкретного числа. Разделите 0 на строку и получится что-то не числовое. Нельзя сказать, что это ничто, это… просто не число. У JavaScript есть термин для такого понятия — NaN, который образован из "Not a Number" (не число).

Как и Бесконечность, NaN можно использовать в вычислениях с другими математическими операторами. Но Not a Number как бы всех подводит: если он присутствует в вычислении, результатом всегда будет NaN.

Вот случайный вопрос: какого размера Марс? Его радиус — 3390 километров, он почти в два раза меньше Земли. Но мы, конечно, заинтересованы там жить, поэтому нам важно, сколько у нас будет поверхности. Другими словами, какая площадь поверхности у Марса?

Может, вы помните формулу: площадь поверхности сферы равна 4πr 2 . r — это радиус, а π примерно 3.14.

Давайте вычислим это в JavaScript:

Теперь представьте как вычислить площадь поверхности другой планеты. Например, Меркурия:

Этот новый код точно такой же, как и предыдущий, изменился только радиус. Если мы продолжим в таком же стиле, нам понадобится писать значение π самим каждый раз. Так не пойдёт, мы не хотим повторений в своих программах.

Мы можем заставить компьютер "помнить", что такое π и использовать это в вычислениях. Такой механизм называется "константы". Давайте создадим новую константу со значением числа π:

const — это специальное ключевое слово, после него — идентификатор — название вашей константы, затем знак равенства и значение.

Теперь мы можем писать "pi" вместо того, чтобы вводить вручную 3.14.

Кстати, двойной слеш и текст после него — это комментарии: JavaScript просто игнорирует их и они не влияют на работу кода. Мы пишем комментарии для себя и других людей, чтобы легче понимать код.

Давайте поместим площадь поверхности Марса в другую константу:

Теперь surface это другой идентификатор, в нём хранится результат вычисления. Тогда как это вычисление произвелось? Ну, во-первых, JavaScript должен вспомнить что такое pi, а потом заменить его на число, значение:

А затем идут умножения слева направо, потому что у нас нет скобок:

Мы можем вывести результат на экран с console.log: console.log(surface) . Заметьте, что в этот раз мы не писали кавычки. Мы не будем выводить слово "surface". Это не строка. Мы выводим значение константы, называемой "surface".

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

Дополнение к уроку

Возведение в степень

Стандарт es7 вводит новый оператор ** , полезный при возведении в степень:

Другой способ возвести число в степень:

Почему константы?

Возможно у вас возник вопрос: "почему константы, а не переменные?". Константы гораздо проще, чем переменные. Они всегда однозначно определены и никогда не меняются. В школе и в ВУЗе, в математике и физике мы имели дело только с константами.

В будущих уроках вы увидите, что единственное место, где требуются переменные — это циклы. Практически во всех других случаях они не нужны, и их присутствие усложняет код (мы объясним это позже в курсе).

Арность

Арность — это количество аргументов. Операторы + , — , * и / применяются к двум операндам. В таком случае их арность составляет 2, поэтому мы можем называть эти операторы бинарными.

Есть ещё один оператор, который выглядит как двоичный минус, но он унарный (одинарный). Это когда — используется для обозначения отрицательного числа, например -327 .

Ещё бывают тернарные (троичные) операторы, но вы их встретите позже.

Ассоциативность

Ассоциативность (или фиксированность) определяет, как операторы группируются при отсутствии скобок. Рассмотрим выражение a

c . Если у оператора

левая ассоциативность, это выражение будет трактоваться как (a

Undefined

Рассмотрим следующий код:

Что в этом случае выведется на экран? Современный JavaScript вообще не позволит вам создать константу без значения, но если позволит, полученный console.log выведет undefined . Это специальный идентификатор.

Вы можете установить значение undefined сами, вот таким способом:

Но самому этого делать не стоит.

Выводы

Математика в JavaScript выглядит и воспринимается как привычная математика:
- Символы + , — , * , / означают то, что вы думаете.
- Ещё есть символ % — остаток от деления. Он вычисляет остаток от деления первого операнда на второй. Например, 11 % 5 это 1, а 10 % 2 это 0.
- Есть Infinity и -Infinity .
- Когда вычисление оказывается не числом, JavaScript использует NaN , который означает "не число" (Not a Number). Например: 0/"word" это NaN
- Если в вычислении присутствует NaN , то результатом всегда будет NaN . Например: 120 + 5 / NaN это NaN
Дополнительные материалы
1. Арность
2. Decimal to IEEE754 number converter — стандарт, описывающий формат хранения чисел с плавающей запятой
3. What Every Computer Scientist Should Know About Floating-Point Arithmetic: long and detailed explanation with formulas
4. Infinity в JavaScript
5. Ассоциативность операторов
6. Floating Point Numbers — Computerphile. Отличное объяснение проблемы чисел с плавающей запятой (та странная проблема из видео-урока)
7. NaN в JavaScript
8. Арифметические операторы в JavaScript
9. What Every Programmer Should Know About Floating-Point Arithmetic or Why don’t my numbers add up? Специальный сайт, посвященный проблеме чисел с плавающей запятой
Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты

Об обучении на Хекслете
- Статья «Как учиться и справляться с негативными мыслями»
- Статья «Ловушки обучения»
- Статья «Сложные простые задачи по программированию»
- Урок «Как эффективно учиться на Хекслете»
- Вебинар «Как самостоятельно учиться»
Открыть доступ

Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно

Name already in use

javascript-tutorial-ru / 1-js / 4-data-structures / 2-number / article.md
- Go to file T
- Go to line L
- Copy path
- Copy permalink
- Open with Desktop
- View raw
- Copy raw contents Copy raw contents
Copy raw contents

Copy raw contents

Все числа в JavaScript, как целые так и дробные, имеют тип Number и хранятся в 64-битном формате IEEE-754, также известном как «double precision».

Здесь мы рассмотрим различные тонкости, связанные с работой с числами в JavaScript.

В JavaScript можно записывать числа не только в десятичной, но и в шестнадцатеричной (начинается с 0x ) системе счисления:

Также доступна запись в «научном формате» (ещё говорят «запись с плавающей точкой»), который выглядит как <число>e<количество нулей> .

Например, 1e3 — это 1 с 3 нулями, то есть 1000 .

Если количество нулей отрицательно, то число сдвигается вправо за десятичную точку, так что получается десятичная дробь:

Деление на ноль, Infinity

Представьте, что вы собираетесь создать новый язык. Люди будут называть его «JavaScript» (или «LiveScript». неважно).

Что должно происходить при попытке деления на ноль?

Как правило, ошибка в программе. Во всяком случае, в большинстве языков программирования это именно так.

Но создатель JavaScript решил пойти математически правильным путем. Ведь чем меньше делитель, тем больше результат. При делении на очень-очень маленькое число должно получиться очень большое. В математическом анализе это описывается через пределы, и если подразумевать предел, то в качестве результата деления на 0 мы получаем «бесконечность», которая обозначается символом ∞ (в JavaScript Infinity ).

Infinity — особенное численное значение, которое ведет себя в точности как математическая бесконечность ∞ .
- Infinity больше любого числа.
- Добавление к бесконечности не меняет её.
Бесконечность можно присвоить и в явном виде: var x = Infinity .

Бывает и минус бесконечность -Infinity :

Бесконечность можно получить также, если сделать ну очень большое число, для которого количество разрядов в двоичном представлении не помещается в соответствующую часть стандартного 64-битного формата, например:

Если математическая операция не может быть совершена, то возвращается специальное значение NaN (Not-A-Number).

Например, деление 0/0 в математическом смысле неопределено, поэтому его результат NaN :

Значение NaN используется для обозначения математической ошибки и обладает следующими свойствами:

Значение NaN — единственное в своем роде, которое не равно ничему, включая себя.

Следующий код ничего не выведет:

Значение NaN можно проверить специальной функцией isNaN(n) , которая преобразует аргумент к числу и возвращает true , если получилось NaN , и false — для любого другого значения.

Значение NaN «прилипчиво». Любая операция с NaN возвращает NaN .

Если аргумент isNaN — не число, то он автоматически преобразуется к числу.

Отсюда вытекает забавный способ проверки значения на NaN : можно проверить значение на равенство самому себе, если не равно — то NaN :

Это работает, но для наглядности лучше использовать isNaN(n) .

Округление до заданной точности

Для округления до нужной цифры после запятой можно умножить и поделить на 10 с нужным количеством нулей. Например, округлим 3.456 до 2-го знака после запятой:

Таким образом можно округлять число и вверх и вниз.

Существует также специальный метод num.toFixed(precision) , который округляет число num до точности precision и возвращает результат в виде строки:

Округление идёт до ближайшего значения, аналогично Math.round :

Итоговая строка, при необходимости, дополняется нулями до нужной точности:

Если нам нужно именно число, то мы можем получить его, применив ‘+’ к результату n.toFixed(..) :

««warn header Например, произведём округление до одного знака после запятой с использованием двух способов: `toFixed` и `Math.round` с умножением и делением:

Как видно результат разный! Вариант округления через Math.round получился более корректным, так как по общепринятым правилам 5 округляется вверх. А toFixed может округлить его как вверх, так и вниз. Почему? Скоро узнаем!

Ради справедливости заметим, что ошибка в точности вычислений для чисел с плавающей точкой сохраняется в любом другом языке, где используется формат IEEE 754, включая Java, C, PHP, Ruby, Perl, Python.

Другие математические методы

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

Встроенные функции для тригонометрических вычислений:

Math.acos(x) : Возвращает арккосинус x (в радианах)

Math.asin(x) : Возвращает арксинус x (в радианах)

Math.atan(x) : Возвращает арктангенс x (в радианах)

Math.atan2(y, x) : Возвращает угол до точки (y, x) . Описание функции: Atan2.

Math.sin(x) : Вычисляет синус x

Math.cos(x) : Вычисляет косинус x

Math.tan(x) : Возвращает тангенс x

Функции общего назначения

Разные полезные функции:

Math.sqrt(x) : Возвращает квадратный корень из x .

Math.log(x) : Возвращает натуральный (по основанию e ) логарифм x .

Math.pow(x, exp) : Возводит число в степень, возвращает x exp , например Math.pow(2,3) = 8 . Работает в том числе с дробными и отрицательными степенями, например: Math.pow(4, -1/2) = 0.5 .

Math.abs(x) : Возвращает абсолютное значение числа

Math.exp(x) : Возвращает e x , где e — основание натуральных логарифмов.

Math.max(a, b, c. ) : Возвращает наибольший из списка аргументов

Math.min(a, b, c. ) : Возвращает наименьший из списка аргументов

Math.random() : Возвращает псевдослучайное число в интервале [0,1) — то есть между 0 (включительно) и 1 (не включая). Генератор случайных чисел инициализуется текущим временем.

Для красивого вывода чисел в стандарте ECMA 402 есть метод toLocaleString() :

Его поддерживают все современные браузеры, кроме IE10- (для которых нужно подключить библиотеку Intl.JS). Он также умеет форматировать валюту и проценты. Более подробно про устройство этого метода можно будет узнать в статье info:intl, когда это вам понадобится.
- Числа могут быть записаны в десятеричной, шестнадцатиричной системах, а также «научным» способом.
- В JavaScript существует числовое значение бесконечность Infinity .
- Ошибка вычислений дает NaN .
- Арифметические и математические функции преобразуют строку в точности в число, игнорируя начальные и конечные пробелы.
- Функции parseInt/parseFloat делают числа из строк, которые начинаются с числа.
- Есть четыре способа округления: Math.floor , Math.round , Math.ceil и битовый оператор. Для округления до нужного знака используйте +n.toFixed(p) или трюк с умножением и делением на 10 p .
- Дробные числа дают ошибку вычислений. При необходимости ее можно отсечь округлением до нужного знака.
- Случайные числа от 0 до 1 генерируются с помощью Math.random() , остальные — преобразованием из них.
Существуют и другие математические функции. Вы можете ознакомиться с ними в справочнике в разделах Number и Math.

Работа с числами в JavaScript

В JavaScript в отличие от некоторых других языков программирования имеется только один числовой тип Number . В качестве него используется формат чисел с плавающей точкой двойной точности по стандарту IEEE-754.

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

Пример записи чисел:

Как показано в примере, в JavaScript числа можно записывать в экспоненциальной форме, а также задавать в других системах счисления: в восьмеричной (впереди 0 ) и шестнадцатеричной (впереди 0x ).

Узнать какой тип данных содержит переменная можно с помощью typeof :

Кроме чисел, формат Number также содержит специальные числовые значения:
- Infinity — положительная бесконечность;
- -Infinity — отрицательная бесконечность;
- NaN — не число.
Примеры выражений, результатами вычисления которых являются специальные числовые значения :

В JavaScript не возникают ошибки при выполнении математических операций. Если в результате вычисления получается очень большое или маленькое число, выходящее за допустимые границы, то интерпретатор соответственно вернёт Infinity или -Infinity .

Значение NaN возвращается, когда интерпретатор JavaScript не может вычислить математическую операцию . Например, если попытаемся вычесть от числа 3 строку ‘1rem’ .

Числовой тип number является примитивным типом. Но при этом к числам можно применять методы как к объектам. Это осуществляется посредством обёртки Number . Она содержит дополнительные значения и методы для работы с числами:

В этом примере мы применили к примитивному типу данных метод toString() как к объекту. При вызове метода числа автоматически оборачиваются в обёртку Number() , а у обёртки имеется метод toString() . Этот метода преобразует число в строку. Этот пример показывает, что числа ведут себя как объекты, хотя на самом деле ими не являются.

При этом использовать обёртку Number напрямую для создания чисел крайне не рекомендуется:

В этом примере num1 и num2 имеют разные типы.

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

Кстати, на самом деле в JavaScript 2 числовых типа данных. Второй тип был добавлен в спецификацию ECMAScript 2020 (11 редакция). Называется он bigint . Этот тип предназначен для представления очень больших целых чисел и на практике используется только для чисел, которые слишком велики для представления с помощью number .

Ограничения по максимальному размеру и точность чисел

В JavaScript при сложении чисел с дробной частью можно получить не то число, которое ожидали.

Погрешности происходят, потому что компьютер оперирует числами в двоичной системе счисления. Т.е. перед тем, как выполнить какие-то действия компьютер сначала должен преобразовать представленные в выражении числа в двоичную систему. Но, не любое десятичное число с дробной частью можно точно представить в двоичной системе счисления.

Например, число 0.25₁₀ в двоичную систему преобразуется точно:

Например, число 0.2₁₀ можно преобразовать в двоичную систему только с определённой точностью:

В результате эти погрешности скажутся при вычислении выражений и это нужно учитывать при написании кода в JavaScript.

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

Например, перепишем код, приведённый выше с определённой точностью используя метод toFixed :

В этом примере, мы сначала с использованием метода toFixed(2) получили строковое представление числа, которое является результатом сложения чисел 0.2 и 0.4 , округленных до 2 знаков после точки. После этого с помощью метода parseFloat преобразовали текст в число и полученное значение присвоили переменной num .

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

Получить минимальное и максимальное безопасное целое число можно с помощью констант:

Теперь, если проверим число, приведённое выше, то увидим что оно больше безопасного:

Кроме этого, проверить находится ли целое число в пределах безопасного диапазона можно посредством метода isSafeInteger :

Основные арифметические операторы

В JavaScript имеются следующие математические операторы:
- сложение: + ;
- вычитание: — ;
- умножение: * ;
- деление: / ;
- остаток от деления: % ;
- возведение в степень: ** ;
- увеличение значения переменной на 1: ++ ;
- уменьшение значения переменной на 1: — .
Операторы ++ и — можно располагать как перед переменной, так и после неё:

Когда мы располагаем оператор ++ после переменной num , то сначала возвращается значение переменной, и только потом увеличивается её значение на 1 .

В другом случае, когда оператор ++ идёт до переменной num, то сначала увеличивается значение этой переменной на 1 , и только потом возвращается её значение.

Оператор — действует аналогично:

Кроме этого имеются комбинированные операторы: += , -= , *= , /= , %= и **= :

Для сравнения чисел в JavaScript используются следующие операторы :
- равенство с учетом типа: === , с попыткой преобразования: == ;
- не равенство с учетом типа: !== , с попыткой преобразования: != ;
- больше: > , больше или равно: >= ;
- меньше: < , меньше или равно: <= .
При сравнении чисел необходимо учитывать точность:

Способ сравнить число до двух знаков после плавающей точки:

Преобразование строки в число и наоборот

1. Преобразование строки в число

Явно привести строку в число можно разными способами:

1.1. Использовать унарный оператор + , который необходимо расположить перед значением.

Этот способ пренебрегает пробелами в начале и конце строки, а также (переводом строки).

При использовании оператора + обратите внимание, что » , ‘ ‘ и ‘ ‘ преобразуется в число 0 . Значение null и логические значения приводятся к следующим числам:

1.2. С помощью глобальной функции parseInt() или метода Number.parseInt() . Они предназначены для преобразования значения, переданного им на вход, в целое число . В отличие от использования унарного оператора + , эти методы позволяют преобразовать строку в число, в которой не все символы являются цифровыми . Эти методы преобразовывают строку, начиная с первого символа. И как только встречают символ, не являющийся цифровым, они останавливают дальнейший разбор строки и возвращают полученное число:

Эти функции могут работать с разными системами счисления (двоичной, восьмеричной, десятичной, шестнадцатеричной). Основание системы счисления передаётся в вызов parseInt() или Number.parseInt() в качестве второго аргумента.

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

1.3. Для преобразования строки в число с плавающей точкой в JavaScript имеются методы parseFloat() и Number.parseFloat() . Друг от друга они ничем не отличаются, просто последний был добавлен в язык немного позднее:

Метод parseFloat в отличие от parseInt всегда рассматривает строку как число в десятичной системе счисления. Указать ему другую систему счисления нельзя.

2. Преобразование числа в строку.

Превратить число в строку можно с помощью метода toString() .

Дополнительно можно передать систему счисления с учётом которой необходимо явно привести число к строке:

Проверки: isFinite, isNaN, isInteger

Этот метод позволяет проверить, является ли значение конечным числом. В качестве результата isFinite возвращает true , если значение является конечным числом. В противном случае false :

Кроме Number.isFinite в JavaScript имеется также глобальная функция isFinite . Она в отличие от Number.isFinite выполняет проверку с учетом принудительное приведение переданного ей аргумента к числу:

Этот метод объекта Number предназначена для определения того, является ли значение NaN . Если это так, то isNaN возвращает true . В противном случае – false :

Кроме Number.isNaN имеется также глобальный метод isNaN , он выполняет проверку с учетом приведения указанного типа данных к числу:

3. Как проверить, является ли значение числом?

В JavaScript имеется метод, который позволяет определить, является ли значение целым числом. Называется он isInteger :

В этом примере для ’20’ мы получили false , т.к. данное значение является строкой.

Если вам нужно проверить является ли значение числом, при это не важно целям или с плавающей точкой, то можно написать, например, вот такую функцию:

Эта функция в зависимости от результата возвращает true или false .

После этого её можно использовать для проверки следующим образом:

Если нужно проверить строковое значение, то его предварительно нужно преобразовать в строку, например, с помощью метода parseFloat :

При проверке строки ’20px’ мы получили true , потому что метод parseFloat(’20px’) возвращает нам число 20 .

Округление

Округление чисел в JavaScript можно выполнить разными способами.

1. С помощью специальных, предназначенных для этой задачи, методов:
- Math.floor – до ближайшего целого в меньшую сторону;
- Math.ceil – до ближайшего целого в большую сторону;
- Math.round – в большую сторону, если дробная часть >= 0.5; иначе в меньшую сторону;
- Math.trunc – путём отбрасывания дробной части;
2. Посредством toFixed() .

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

3. Через toPrecision() .

Данный метод возвращает число в строковом формате, округленное с указанной точностью. При этом он может округлить целую и дробную часть числа. При этом значение может быть представлено как с плавающей точкой, так и в экспоненциальной форме:

4. С использованием логического оператора

Форматирование чисел

В JavaScript вывести число в соответствии с региональными стандартами (языковыми настройками операционной системы) позволяет метод toLocaleString() .

В соответствии с настройками установленными в системе:

Явно указав регион:

Для отображения денежных величин:

В процентном формате:

С разделением групп разрядов (свойство useGrouping ):

С указанием числа десятичных знаков:

Примеры

1. Пример, в котором напишем две функции для проверки числа соответственно на четность и не четность . А затем используем их в коде:

2. Пример на JavaScript в котором получим простые числа от 2 до 100:

3. Пример, в котором вычислим целую и дробную часть числа :

В этом примере, получение целой части числа выполняется посредством Math.floor() , а дробной части с помощью получения остатка от деления на 1 или вычитания числа от его целой части.

4. Пример, в котором определим, делится ли число нацело , используя оператор % :
Похожие публикации:

Как возвести число в степень в javascript