Деление по модулю js: # Оператор деления по модулю · Странный JavaScript

Арифметика в Javascript

Арифметические операторы используются для выполнения арифметических операций с числами (константами или переменными):

Оператор	Описание
+	Сложение
—	Вычитание
*	Умножение
/	Деление
%	Остаток от деления
++	Увеличение на 1
—	Уменьшение на 1

Арифметические операции

Типичная арифметическая операция осуществляется с двумя числами.

Этими числами могут быть константы:

var x = 100 + 50; 

или переменные:

var x = a + b; 

или выражения:

var x = (100 + 50) * a; 

Операторы и операнды

Числа в арифметической операции называют операндами.

Операция, совершаемая между двумя операндами, называется оператор.

Операнд	Оператор	Операнд
100	+	50

Оператор сложения (+) вычисляет сумму чисел:

 var x = 5;
 var y = 2;
 var z = x + y; 

Оператор вычитания (-) вычисляет разницу чисел:

 var x = 5;
 var y = 2;
 var z = x - y; 

Оператор умножения (*) перемножает числа:

 var x = 5;
 var y = 2;
 var z = x * y; 

Оператор деления (/) делит одно число на другое:

 var x = 5;
 var y = 2;
 var z = x / y; 

Оператор деления по модулю (%) возвращает остаток от деления двух чисел:

 var x = 5;
 var y = 2;
 var z = x % y; 

Оператор инкремента (++) увеличивает число на 1:

 var x = 5;
 x++;
 var z = x;

Оператор декремента (—) уменьшает число на 1:

 var x = 5;
 x--;
 var z = x; 

Старшинство операторов

Старшинство операторов определяет порядок, в котором совершаются операции в арифметических выражениях.

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

 var x = 100 + 50 * 3; 

Какой результат мы получим? Как при вычислении 150 * 3 или 100 + 150?

Что вычисляется первым — сложение или умножение?

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

Умножение (*) и деление (/) имеют более высокий приоритет, чем сложение (+) и вычитание (-).

И также как и в обычной математике старшинство можно изменить при помощи круглых скобок:

 var x = (100 + 50) * 3; 

В этом случае первым вычисляется операция, расположенная внутри круглых скобок.

Если у нескольких операций одинаковое старшинство (как у сложения и вычитания), то они вычисляются слева направо:

 var x = 100 + 50 - 3; 

Коэффициенты старшинства операторов в JavaScript:

Коэффициент	Оператор	Описание	Пример
20	( )	Группирование выражений	(3 + 4)
19	.	Член объекта	person.name
19	[]	Член объекта или массива	person[«name»]
19	()	Вызов функции	myFunction()
19	new	Создание объекта	new Date()
17	++	Постфиксный инкремент	i++
17	—	Постфиксный декремент	i—
16	++	Префиксный инкремент	++i
16	—	Префиксный декремент	—i
16	!	Логическое НЕ	!(x==y)
15	typeof	Тип	typeof x
15	**	Возведение в степень	10 ** 2
14	*	Умножение	10 * 5
14	/	Деление	10 / 18
14	%	Деление по модулю	10 % 5
13	+	Сложение	10 + 5
13	—	Вычитание	10 — 8
12	<<	Сдвиг влево	x << 2
12	>>	Сдвиг вправо	x >> 2
12	>>>	Сдвиг вправо (без знака)	x >>> 2
11	<	Меньше чем	x < y
11	<=	Меньше или равно	x <= y
11	>	Больше чем	x > y
11	>=	Больше или равно	x >= y
10	==	Равенство	x == y
10	===	Строгое равенство	x === y
10	!=	Неравенство	x != y
10	!==	Строгое неравенство	x !== y
6	&&	Логическое И	x && y
5	||	Логическое ИЛИ	x || y
3	=	Присваивание	x = y
3	+=	Присваивание	x += y
3	-=	Присваивание	x -= y
3	*=	Присваивание	x *= y
3	%=	Присваивание	x %= y
3	<<=	Присваивание	x <<= y
3	>>=	Присваивание	x >>= y
3	>>>=	Присваивание	x >>>= y
3	&=	Присваивание	x &= y
3	^=	Присваивание	x ^= y
3	|=	Присваивание	x |= y

Внимание! Выражения в круглых скобках полностью вычисляются до применения коэффициентов остальных выражений.

Числа | JavaScript Camp

В современном JavaScript существует два 2️⃣ типа чисел:

number​

Обычные числа в JavaScript хранятся в 64-битном формате IEEE-754, который также называют «числа с плавающей точкой двойной точности» (double precision floating point numbers). Это числа, которые мы будем использовать чаще всего. Целые числа не рассматриваются как отдельный тип чисел. В дополнение к числам с плавающей запятой, к числовому типу данных относятся также три символьные величины: Infinity, -Infinity, и NaN (не-число).

Видео​

bigInt​

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

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

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

caution

Будьте внимательны при использование нулей в начале чисел! Значит не надо ставить ноль перед десятичным числом.

1234567890
42
0888 // 888 обрабатывается как десятичное
0777 // обрабатывается как восьмеричное в нестрогой форме (511 в десятичной)

Арифметические действия​

По двум или нескольким целым числам можно составить новое целое число. Способов составлять новое целое число очень много. Способ составлять новое число по двум или нескольким числам называется арифметическим действием. Вообще арифметических действий много, но основных только четыре: сложение, вычитание, умножение и деление. Они названы основными, ибо все остальные действия приводятся к ним.

Знак плюс + используется для выражения сложения: 4 + 4 Ответ: 8

Минус – для вычитания: 7 - 6 Ответ: 1

Звёздочкой * изображается умножение: 3 * 4 Ответ: 12

Прямым слэшем / деление: 15 / 5 Ответ: 3

Если в строке совершается более одного действия, то, чтобы отделить их друг от друга, а также сделать код📟 более читабельным, мы пользуемся — (скобками). Давайте наберём следующие предложения в консоли. Ответ по каждому из них должен состоять только из одной цифры9️⃣:

 3 * (2 + 1)
(3 + 24) / (10 - 7)
(2 + 5 * 5) / (6 -  3)
3 * (5 - 8 / 2) * (2 + 1)

Введите в LIVE EDITOR перечисленые значения 👇 :

function learnJavaScript() { let result = 2 + 3 // здесь return result }

function learnJavaScript() {
let result = 2 + 3 // здесь
return result
}

Loading…

Комбинированное присваивание​

Оператор представляет собой символическое обозначение некоторого действия, выполняемого с операндами в выражении(Например: +, -, *, /).

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

Основной оператор комбинированного присваивания — это знак равно =, он и присваивает значение правого операнда, левому. То есть — x = y присваивает значение переменной 🔔 y, переменной 🔔 x.

Вы уже не раз видели, как при помощи математических операторов происходит присваивание значений переменным 🔔 . Например, так:

let sum = 2 + 3 // значение суммы 7

А ещё вы, наверное, не успели позабыть, что в любой момент можно изменить значение уже известной переменной 🔔 :

function learnJavaScript() { let sum = 2 + 3 sum = sum + 3 // теперь значение суммы стало 8 return sum }

function learnJavaScript() {
let sum = 2 + 3
sum = sum + 3 // теперь значение суммы стало 8
return sum
}

Loading…

Присваивание со сложением += для того, чтобы быстро увеличить значение переменной! Вот вам несколько примеров:

let значение = 5
значение += 2 // значение теперь 7 (то же самое, что значение = // значение + 2)
значение += 3 // значение теперь 10 (то же самое, что значение = // значение + 3)
значение = значение + значение // 20 (а можно просто значение += // значение)
значение += значение // 40 (то же самое, что значение = значение + // значение)

Вы ведь уже догадались, что подобные штуки работают и с прочими математическими действиями, да?!

значение –= 25 // значение теперь 15 (то же, что и значение = значение − // 25)
значение -= 2 // значение теперь 30 (то же самое, что значение = // значение - 2)
значение /= 3 // значение теперь 10 (то же самое, что значение = // value / 3)
значение // Ответ: 10

Далее проверьте все перечисленые примеры в LIVE EDITOR:

function learnJavaScript() { let значение = 0 + 0 return значение }

function learnJavaScript() {
let значение = 0 + 0
return значение
}

Loading. ..

Подробней о комбинированном присваивании можно почитать здесь

Инкремент и декремент​

Оператор ++ (инкремент) увеличивает значение своего операнда на единицу. Если значение операнда не является числом, оператор автоматически преобразует его в число, увеличивает на единицу и возвращает результат, который присваивается обратно операнду:

function learnJavaScript() { let increment = 0 increment++ return increment }

function learnJavaScript() {
let increment = 0
increment++
return increment
}

Loading…

Оператор -- (декремент) работает аналогично оператору инкремент, но не увеличивает значение своего операнда, а наоборот, уменьшает его на единицу:

function learnJavaScript() { let decrement = 6 decrement— return decrement }

function learnJavaScript() {
let decrement = 6
decrement--
return decrement
}

Loading. ..

Оператор modulo​

Знаком % (процентов) мы обозначаем остаток от деления. Оператор возвращает🔄 целый остаток от деления левого операнда на правый. Возвращаемое🔄 значение всегда получает знак делимого, а не делителя. Он использует встроенную функцию⚙️ modulo, для получения результата, которая является целочисленным остатком деления let1 на let2.

12 % 5 результат 2

NaN % 2 результат NaN

1 % 2 результат 1

2 % 3 результат 2

4 % 2 результат 0

5.5 % 2 результат 1.5

Проверьте все перечисленые примеры в LIVE EDITOR и сразу все поймете:

function learnJavaScript() { let modulo = 12 % 5 return modulo }

function learnJavaScript() {
let modulo = 12 % 5
return modulo
}

Loading. ..

Округление​

Метод Math.round() возвращает🔄 число, округлённое к ближайшему целому. Если дробная часть числа больше, либо равна 0,5, аргумент будет округлён до ближайшего большего целого. Если дробная часть числа меньше 0,5, аргумент будет округлён до ближайшего меньшего целого.

result = Math.round(20.49) Вернёт значение 20

result = Math.round(20.5) Вернёт значение 21

проверьте сами:

function learnJavaScript() { let result = Math.round(20.49) return result }

function learnJavaScript() {
let result = Math.round(20.49)
return result
}

Loading…

React Native​

Числа вставляются в React Native приложения также просто как и строки.

Проблемы?​

Пишите в Discord или телеграмм чат, а также подписывайтесь на наши новости

Вопросы:​

Какие арифметические действия названы основными?

1. Сложение, вычитание
2. Умножение, деление
3. Сложение, вычитание, умножение, деление

Как правильно читается +=?

1. Инкремент
2. Присваивание со сложением
3. Плюс и равно

Как инкремент записывается знаком(знаками)?

1. ++
2. --
3. +

Каким знаком обозначается остаток от деления?

1. %
2. /
3. \

Какое значение Math. round вернёт при действии Math.round (20.62)?

1. 22
2. 20
3. 21

Какой специальный символ вы могли бы использовать, чтобы упростить это задание? \n myVariable = myVariable * 2

1. =*
2. *=
3. *

Какой символ используется для обозначения модуля(остаток от деления) в JavaScript?

1. %
2. $
3. &

Каков самый простой (то есть самый короткий) способ записать это (используя специальный символ)? Как называется специальный символ?\n myVariable = myVariable + 1

1. myVariable++
2. myVariable+
3. myVariable+=

Каков самый простой (то есть самый короткий) способ записать это (используя специальный символ)? Как называется специальный символ? \n myVariable = myVariable - 1

1. myVariable--
2. myVariable-
3. myVariable-=

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

1. 2
2. 4
3. 0

Какой специальный символ вы могли бы использовать, чтобы упростить это задание?\n myValue = myValue - 8

1. - (myValue - 8)
2. -= (myValue -= 8)
3. =- (myValue =- 8)

Каково собирательное имя символов, которые сначала выполняют операцию с переменной, а затем присваивают новое значение той же переменной (например, +=, -=, *= и /=)?

1. Комбинированое присвоение
2. Математическое присвоение
3. Условное присвоение

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

Ссылки:​

1. MDN web docs
2. Код для подростков: прекрасное руководство по программированию для начинающих, том 1: Javascript — Jeremy Moritz
3. JavaScript.ru
4. Арифметические действия с целыми числами

Contributors ✨​

Thanks goes to these wonderful people (emoji key):

Dmitriy Vasilev 📖💵

Resoner2005 🐛 🎨 🖋

Остаток (%) — JavaScript | MDN

В этой статье

• Попробуйте
• Синтаксис
• Описание
• Примеры
• Технические характеристики
• Совместимость с браузерами

  6

6
• См. также
• Оператор остатка ( % ) возвращает оставшийся остаток, когда один операнд делится на второй операнд. Он всегда принимает знак делимого.

  Для операции n % d , n

  называется делимым и d называется делителем. Операция возвращает NaN , если один из операндов равен NaN , n равен ±бесконечности или если d равен ±0. В противном случае, если d равно ±бесконечности или если n равно ±0, возвращается делимое n .

  Когда оба операнда отличны от нуля и конечны, остаток r вычисляется как r := n - d * q , где q — целое число, такое что r имеет тот же знак, что и делимое n , максимально приближаясь к 0.

  Обратите внимание, что хотя в большинстве языков ‘%’ является оператором остатка, в некоторых (например, Python, Perl) это оператор по модулю. Модуль определяется как k := n - d * q , где q — это целое число, такое что k

  имеет тот же знак, что и делитель d , но при этом максимально близко к 0. Для двух значений одного и того же знака они эквивалентны, но когда операнды имеют разные знаки, результат по модулю всегда имеет тот же знак, что и 9. 0067 делитель , а остаток имеет тот же знак, что и делимое , что может привести к тому, что они будут отличаться на одну единицу от d . Чтобы получить модуль в JavaScript, вместо n % d используйте ((n % d) + d) % d . В JavaScript операция по модулю (у которой нет специального оператора) используется для нормализации второго операнда операторов побитового сдвига ( << , >> и т. д.), что делает смещение всегда положительным.

  Остаток с положительным дивидендом

   13 % 5 // 3
   1 % -2 // 1
   1 % 2 // 1
   2 % 3 // 2
  5,5 % 2 // 1,5
   

  Остаток с отрицательным дивидендом

   -13 % 5 // -3
  -1 % 2 // -1
  -4 % 2 // -0
   

  Остаток с NaN

    NaN % 2 // NaN
   

  Остаток с бесконечностью

   Бесконечность % 2 // NaN
  Бесконечность % 0 // NaN
  Бесконечность % Бесконечность // NaN
  2 % Бесконечность // 2
  0 % Бесконечность // 0
   

  Спецификация
  Спецификация языка ECMAScript # sec-multiplicative-operators

  Таблицы BCD загружаются только в браузере

  с включенным JavaScript. Включите JavaScript для просмотра данных.
  • Оператор сложения
  • Оператор вычитания
  • Оператор отделения
  • Оператор умножения
  • Оператор возведения в степень
  • Оператор приращения
  • Оператор декремента
  • Унарный оператор отрицания
  • Унарный плюс оператор
  • Оператор остатка против оператора по модулю

  Последнее изменение: 17 сентября 2022 г. , участниками MDN

  JavaScript % Оператор: полное руководство по модулям

  В математике модуль дает вам остаток от деления. Чтобы вычислить остаток от деления в JavaScript, используйте оператор по модулю (%).

  Например:

   const r = 10 % 3
  console. log(r) 

  Вывод:

   1 ​​

  Вы можете интерпретировать это как разделение 10 кусков пиццы на 3 едоков. В результате справедливой доли останется один кусочек. Это результат модуля.

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

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

  Прежде чем перейти к вычислению по модулю в JavaScript, давайте взглянем на модуль в математике.

  Модуль в математике

  В математике модуль описывает остаток от деления. В математике модуль обычно обозначается как mod .

   a mod b 

  Где:

  • называется дивидендом .
  • b называется делителем .

  Модуль возвращает остаток от деления.

  Например:

   7 mod 3 = 1 

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

  Чтобы это стало возможным, вы должны разделить по 2 яблока с каждым человеком. Это означает, что вы поделились 6 яблоками. Таким образом, осталось одно яблоко. Это остаток в дивизии.

  Другим примером модулей являются 12-часовые часы. Когда вы считаете время, вы считаете до 12 и возвращаетесь к 0.

  Например, давайте вычислим, который час ровно через 11 часов после 7:00.

  Для этого нельзя прибавить 11 к 7:00, потому что это даст 18:00. Вместо этого прибавляйте 11 часов к 7:00, пока не дойдете до 12:00. Затем 6 оставшихся часов добавляются к новому раунду, чтобы сделать его 6:00.

  Именно так работает модуль. Другими словами, более простым решением приведенного выше примера является вычисление 11 + 7 по модулю 12 , в результате чего получается 6.

   18 по модулю 12 = 6 

  Таким образом, в 12-часовом формате 18:00 и 6:00 это одно и то же.

  Математически этот факт обозначается как:

   18 ≡ 6 (mod 12) 

  Это читается как «18 и 6 сравнимы по модулю 12».

  Как правило, в модульной арифметике эти модульные отношения можно выразить следующим образом:

   a ≡ b (mod n) 

  Что означает «a и b сравнимы по модулю n».

  Для теории достаточно.

  Теперь вы понимаете, что такое модульная арифметика. Далее, давайте перейдем к вычислению модулей в JavaScript.

  Модуль в JavaScript

  В JavaScript вы можете использовать оператор % для вычисления модуля.

   a % b 

  Вы можете вычислять по модулю с числовыми типами int и float и отрицательными числами.

  Модуль для целых чисел в JavaScript

  Обычно вы вычисляете модуль между двумя целыми числами.

  Вот несколько примеров:

   console.log(4 % 3) // 1
  console. log(10 % 7) // 3
  console.log(78 % 14) // 8
  console.log(1000 % 10) // 0 

  Как видите, результат по модулю тоже может быть 0. Но брать по модулю с 0 бессмысленно. Результат всегда NaN .

   console.log(1000 % 0) // NaN 

  Теперь вы понимаете, как вычислять остатки в JavaScript с использованием целых чисел.

  Далее рассмотрим несколько примеров использования отрицательных чисел и модуля.

  Модуль для отрицательных чисел

  Вычисление по модулю отрицательных чисел возможно в JavaScript.

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

  В JavaScript результат по модулю принимает знак делимого (значение слева).

  Например, результат этого вычисления положительный, хотя делитель отрицательный:

   console.log(7 % -4) // 3 

  Но в Python тот же расчет дает другой результат, который имеет знак делителя:

   >>> 7 % -4
  -1 

  Но почему результаты разные?

  Все сводится к тому, как под капотом рассчитывается модуль.

  Как оказалось, в JavaScript модуль вычисляется иначе, чем в Python.

  Вот как a % b вычисляется за кулисами:

   javascript: r = a - (b * trunc(a / b))
  python: r = a - (b * floor(a / b)) 

  Взгляните на последний член в обоих этих уравнениях. Есть разница. В JavaScript последний термин равен trunc(a / b) . В Python это этаж(а/б) .

  • trunc(a / b) означает усеченное деление. Это округляет отрицательное число до 0.
  • этаж(a / b) означает деление этажей. Это округляет отрицательное число от 0.

  Вот иллюстрация обеих этих функций:

  Но как насчет положительных значений?

  Оба floor() и trunc() округляют положительные значения до ближайшего целого числа. Другими словами, они работают одинаково с положительными числами.

  Это приводит к различиям по модулю с использованием отрицательных значений.

  Давайте воспользуемся приведенным выше уравнением, чтобы вручную вычислить 7 % -4 в JavaScript и Python.

  Вот версия JavaScript:

   r = a - (b * trunc(a / b))
  а = 7
  б = -4
  г = 7 - (-4 * усечение (7 / -4))
    = 7 - (-4 * усечение (-1,75))
    = 7 - (-4 * -1)
    = 7 - 4
    = 3 

  А вот версия Python:

   r = a - (b * floor(a / b))
  а = 7
  б = -4
  г = 7 - (-4 * пол (7 / -4))
    = 7 - (-4 * пол(-1,75))
    = 7 - (-4 * -2)
    = 7 - 8
    = -1 

  Как видите, версия JS дает 3, а Python дает -1.

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

  Теперь давайте посмотрим на модули между числами с плавающей запятой.

  Модуль с числами с плавающей запятой

  Подобно тому, как вы можете использовать целые числа для вычисления модулей, вы можете использовать числа с плавающей запятой.

  Вот несколько примеров:

   console.log(10,5 % 4,5) // 1,5
  console.log(10 % 1.5) // 1
  console.log(12,5 % 3,5) // 2
  console.log(10.0 % 3.0) // 1 

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

  Например:

   console. log(10.0 % 3.1) // 0.6999999999999997 

  Теперь вы получили полное представление о том, как вычислять остатки в JavaScript.

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

  Приоритет оператора с модулем

  Приоритет оператора описывает, какие операции выполняются первыми при объединении в одном уравнении.

  В JavaScript оператор по модулю имеет тот же уровень приоритета, что и:

  • Умножение (*)
  • Деление (/)
  • Деление этажа (//).

  Например, если вы сначала умножаете, а затем берете модуль, умножение происходит первым.

  Но если вы сложите два числа и возьмете по модулю, модуль будет предшествовать.

  Например:

   console.log(3 * 4 % 5 - 6) // -4 

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

   ((3 * 4) % 5) - 6 

  JavaScript evaluates this as follows:

  • ((3 * 4) % 5) – 6
  • (12 % 5) – 6
  • 2 – 6
  • -4

  Теперь вы хорошо понимаете модуль в целом. Далее рассмотрим некоторые распространенные приложения.

  Общие случаи использования модуля по модулю в JavaScript

  Существует множество вариантов использования модуля по модулю в JavaScript.

  Типичный пример — проверить, является ли число четным или нечетным. Еще одна популярная задача — проверить, является ли число простым.

  Далее рассмотрим эти и еще несколько примеров.

  Использование модуля по модулю для работы с периодичностью

  Модуль по модулю помогает вам, когда в вашем коде есть периодичность.

  Подумайте об игровом персонаже. Он выходит из экрана с правой стороны и снова появляется с левой стороны. Код, который делает это возможным, определяет x-позицию игрока по модулю ширины экрана .

  С точки зрения непрофессионала, когда позиция x игрока превышает ширину экрана, операция по модулю возвращает ее обратно к 0,

   x_pos = x_pos % screen_width 

  Давайте посмотрим на другой пример с использованием 12-часового формата, о котором мы говорили ранее.

  Несмотря на то, что в сутках 24 часа, 12-часовые часы делают оборот вокруг себя за 12 часов до конца дня.

  Но это по-прежнему вполне рабочий способ отслеживать время.

  Это возможно, потому что, например, 15:00 в 24-часовом формате равно 3:00. Единственная проблема заключается в том, что время показывает одно и то же место два раза в день. Но поскольку мы можем четко отличить день от ночи, это не проблема.

  Давайте смоделируем 12-часовые часы в JavaScript.

  Чтобы отобразить часы дня в 12-часовом формате, возьмите модуль между часом дня и 12.

  Вот как это выглядит в коде:

   function wallclock(hour) {
      постоянный результат = час % 12
      console.log(`${hour}:00 равен ${result}:00 в 12-часовом формате`)
  }
  // Создает массив от 0 до 24
  постоянные часы = [...Массив(25).keys()]
  за (час часов) {
      настенные часы (час)
  } 

  Вывод:

   0:00 равно 0:00 в 12-часовом формате.
  1:00 - это 1:00 в 12-часовом формате
  2:00 это 2:00 в 12-часовом формате
  3:00 это 3:00 в 12-часовом формате
  4:00 это 4:00 в 12-часовом формате
  5:00 это 5:00 в 12-часовом формате
  6:00 это 6:00 в 12-часовом формате
  7:00 это 7:00 в 12-часовом формате
  8:00 это 8:00 в 12-часовом формате
  9:00 - это 9:00 в 12-часовом формате
  10:00 это 10:00 в 12-часовом формате
  11:00 это 11:00 в 12-часовом формате
  12:00 это 0:00 в 12-часовом формате
  13:00 - это 1:00 в 12-часовом формате
  14:00 это 2:00 в 12-часовом формате
  15:00 это 3:00 в 12-часовом формате
  16:00 это 4:00 в 12-часовом формате
  17:00 это 5:00 в 12-часовом формате
  18:00 это 6:00 в 12-часовом формате
  19:00 это 7:00 в 12-часовом формате
  20:00 это 8:00 в 12-часовом формате
  21:00 это 9:00 в 12-часовом формате
  22:00 это 10:00 в 12-часовом формате
  23:00 это 11:00 в 12-часовом формате
  24:00 — это 0:00 в 12-часовом формате 

  Чет или нечет?

  Чтобы проверить, является ли число нечетным или четным, используйте модуль.

  • Если число четное, оно делится на 2 без остатка. Другими словами, число по модулю 2 дает 0.
  • Если число нечетное, оно нечетное.

  Например:

   function isEven(number) {
      возвращаемое число% 2 == 0
  }
  console.log(равномерно(10))
  console.log(isEven(7)) 

  Вывод:

   правда
  false 

  Точно так же, чтобы узнать, является ли число нечетным, вы можете либо использовать isEven() функция с отрицанием:

   функция isOdd(число) {
      вернуть !isEven(число)
  } 

  Или вы можете использовать тот факт, что любое нечетное число по модулю 2 дает остаток от деления 1:

   function isOdd(number) {
      возвращаемое число% 2 == 1
  } 

  Повторять код с интервалами

  Иногда при выполнении цикла вы не хотите запускать код на каждой итерации. Вместо этого вы указываете интервал того, как часто следует запускать код.

  Чтобы выполнять код с интервалами, проверьте, делится ли текущий индекс итерации нацело на интервал. Другими словами, используйте модуль.

  Например, выведем каждое 3-е число в массиве чисел:

   const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
  переменная я = 0
  постоянный интервал = 3
  в то время как (я <числа.длина) {
      если (я% интервал == 0) {
          console.log(я)
      }
      я += 1
  } 

  Вывод:

   0
  3
  6
  9
  12 

  Заключение

  Сегодня вы научились вычислять остатки в JavaScript.