Как записывается операция вычисления остатка от деления в целых числах в языке javascript

Вычисление остатка от деления в JavaScript

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

Отслеживать
52.2k 11 11 золотых знаков 108 108 серебряных знаков 312 312 бронзовых знаков
задан 22 окт 2017 в 8:32
77 1 1 золотой знак 1 1 серебряный знак 2 2 бронзовых знака

@Санаев «в интернете полно объяснений» — как мне кажется, без ссылки на источник в Интернет, Ваш комментарий мягко говоря — бесполезен.

22 окт 2017 в 9:31
@АлександрМуксимов первая же ссылка. otvet.mail.ru/question/64174313
22 окт 2017 в 9:47
Данный вопрос следует закрыть, потому он что не связан с программированием.
22 окт 2017 в 21:52

@mymedia: первая редакция о javascript спрашивает. Поведение % разни́тся между языками программирования и не такое очевидное как может показаться. Посмотрите ссылки из моих комментариев.

23 окт 2017 в 18:41
Редко я такое говорю, но учите арифметику. Деление с остатком, вроде бы, в начальной школе проходят.
17 авг 2020 в 6:02

4 ответа 4

Сортировка: Сброс на вариант по умолчанию

Оператор % работает как нормальный оператор возвращающий остаток от деления. При a % b a делится нацело на b и все что остается возвращается. Числа 1, 2, и 3 меньше 7, поэтому нацело они на 7 не делятся (результат их деления на 7 нацело равен нулю) и в остатке остаются сами числа

1 % 7 = ноль целых и один в остатке 2 % 7 = ноль целых и два в остатке 3 % 7 = ноль целых и три в остатке

Отслеживать
13.7k 12 12 золотых знаков 43 43 серебряных знака 75 75 бронзовых знаков
ответ дан 22 окт 2017 в 8:37
2,800 9 9 серебряных знаков 22 22 бронзовых знака
Спасибо, давно мучает этот вопрос. Теперь понятно.
22 окт 2017 в 12:40

@RiseUp: если хотите снова запутаться, то попробуйте отрицательные числа ( % операция является взятием остатка в Питоне ( 0

23 окт 2017 в 6:43

@RiseUp: чтобы получить остаток и в Си, можно (b + (a % b)) % b формулу использовать. См. Деление с остатком, Euclidean division

23 окт 2017 в 6:54

@jfs, благодарю за восстановление математической справедливости. Если не секрет — а исторически, кто у программистов придумал считать остатки от отрицательных чисел отрицательными и зачем?

23 окт 2017 в 16:50

@АлександрБелинский значение a%b следует из свойств a/b . До C99 a/b зависело от реализации. C99 к нулю округляет потому что Fortran так делал, который вероятно в свою очередь использовал то что на CPU быстрее (про Фортран—со слов человека, который черновик стандарта правил

JavaScript. Остаток от деления и деление без остатка

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

Остаток от деления (деление по модулю)

Чтобы получить остаток от деления мы можем воспользоваться оператором %

console.log(20 % 3) // 2 (3 * 6 = 18)

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

Где такое может понадобиться? Как пример, если в цикле вы будете генерировать строки таблицы и каждую 3 строку вам нужно будет стилизовать:

for (let i = 0; i < tableRows.length; i++) < . // Если на данной итерации счетчик i делится на 3 без остатка (т.е. деление равно 0) // Тогда в этом условии мы можем сделать необходимые операции if (i % 3 === 0) < . >>

В данном примере показана каждая третья строка, но можно также сделать и с другим числом:

if (i % 2 === 0) — каждая вторая строка
if (i % 5 === 0) — каждая пятая строка
if (i % 10 === 0) — каждая 10я строка и т.д.

Другой пример, когда вам нужно проверить делимость числа например на 10 и 100 без остатка:

if (num % 10 === 0 && num % 100 === 0)

Деление без остатка

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

Первый вариант, наиболее очевидный, это округление числа после операции деления:

let num1 = 10, num2 = 3; console.log(Math.floor(num1/num2)); // 3 (округление в меньшую сторону) console.log(Math.ceil(num1/num2)); // 4 (округление в большую сторону) console.log(Math.round(num1/num2)); // 3 (математическое округление) console.log(+(num1/num2).toFixed(0)); // 3 (математическое округление) console.log(parseInt((num1/num2))); // 3 (приведение к числу, будет отброшена дробная часть)

Подробнее про разные способы округления чисел (в меньшую и в большую сторону) можете прочитать по ссылке.

Еще один вариант, предложенный пользователем в комментариях:

console.log(~~(10/3)) // 3

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

let num1 = 10, num2 = 3; console.log((num1/num2) | 0); // 3 console.log((num1/num2) >> 0); // 3

Задача. Функция для определения простого числа

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

Итак, напишем функцию, которая на вход принимает какое-то число, дальше в цикле начиная с 2 (т.к. на единицу итак все делиться), пока счетчик меньше передаваемого числа, проверяем будет ли num делиться без остатка. Если делиться, значит num не является простым числом:

function isPrime(num) < for (let i = 2; i < num; i++) < if (num % i === 0) < return false; >> return num > 1; > console.log(isPrime(1)); // false console.log(isPrime(2)); // true console.log(isPrime(3)); // true console.log(isPrime(4)); // false console.log(isPrime(5)); // true

Ваши вопросы и комментарии:

Числа

В данной главе мы рассмотрим только первый тип чисел: числа типа number . Давайте глубже изучим, как с ними работать в JavaScript.

Способы записи числа

Представьте, что нам надо записать число 1 миллиард. Самый очевидный путь:

let billion = 1000000000;

Мы также можем использовать символ нижнего подчёркивания _ в качестве разделителя:

let billion = 1_000_000_000

Символ нижнего подчёркивания _ – это «синтаксический сахар», он делает число более читабельным. Движок JavaScript попросту игнорирует _ между цифрами, поэтому в примере выше получается точно такой же миллиард, как и в первом случае.

Однако в реальной жизни мы в основном стараемся не писать длинные последовательности нулей, так как можно легко ошибиться. Укороченная запись может выглядеть как «1млрд» или «7.3млрд» для 7 миллиардов 300 миллионов. Такой принцип работает для всех больших чисел.

В JavaScript, чтобы укоротить запись числа, мы можем добавить к нему букву «e» и указать необходимое количество нулей:

let billion = 1e9; // 1 миллиард, буквально: 1 и 9 нулей alert( 7.3e9 ); // 7.3 миллиарда (7,300,000,000)

Другими словами, «e» умножает число на 1 с указанным количеством нулей.

1e3 === 1 * 1000 // e3 означает *1000 1.23e6 === 1.23 * 1000000 // e6 означает *1000000

А сейчас давайте запишем что-нибудь очень маленькое. К примеру, 1 микросекунду (одна миллионная секунды):

let mcs = 0.000001;

В этом случае нам также поможет «e» . Если мы хотим избежать записи длинной последовательности из нулей, мы можем сделать так:

let ms = 1e-6; // шесть нулей слева от 1

Если мы подсчитаем количество нулей в 0.000001 , их будет 6. Естественно, верная запись 1e-6 .

Другими словами, отрицательное число после «e» подразумевает деление на 1 с указанным количеством нулей:

// 1 делится на 1 с 3 нулями 1e-3 === 1 / 1000 (=0.001) // 1.23 делится на 1 с 6 нулями 1.23e-6 === 1.23 / 1000000 (=0.00000123)

Шестнадцатеричные, двоичные и восьмеричные числа

Шестнадцатеричные числа широко используются в JavaScript для представления цветов, кодировки символов и многого другого. Естественно, есть короткий стиль записи: 0x , после которого указывается число.

alert( 0xff ); // 255 alert( 0xFF ); // 255 (то же самое, регистр не имеет значения)

Двоичные и восьмеричные числа используются не так часто, но они также поддерживаются: 0b для двоичных и 0o для восьмеричных:

let a = 0b11111111; // двоичная (бинарная) форма записи числа 255 let b = 0o377; // восьмеричная форма записи числа 255 alert( a == b ); // true, с двух сторон число 255

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

toString(base)

Метод num.toString(base) возвращает строковое представление числа num в системе счисления base .

let num = 255; alert( num.toString(16) ); // ff alert( num.toString(2) ); // 11111111

base может варьироваться от 2 до 36 (по умолчанию 10 ).

base=16 — для шестнадцатеричного представления цвета, кодировки символов и т.д., цифры могут быть 0..9 или A..F .
base=2 — обычно используется для отладки побитовых операций, цифры 0 или 1 .
base=36 — максимальное основание, цифры могут быть 0..9 или A..Z . То есть, используется весь латинский алфавит для представления числа. Забавно, но можно использовать 36 -разрядную систему счисления для получения короткого представления большого числового идентификатора. К примеру, для создания короткой ссылки. Для этого просто преобразуем его в 36 -разрядную систему счисления:

alert( 123456..toString(36) ); // 2n9c

Две точки для вызова метода

Внимание! Две точки в 123456..toString(36) это не опечатка. Если нам надо вызвать метод непосредственно на числе, как toString в примере выше, то нам надо поставить две точки .. после числа.

Если мы поставим одну точку: 123456.toString(36) , тогда это будет ошибкой, поскольку синтаксис JavaScript предполагает, что после первой точки начинается десятичная часть. А если поставить две точки, то JavaScript понимает, что десятичная часть отсутствует, и начинается метод.

Также можно записать как (123456).toString(36) .

Округление

Одна из часто используемых операций при работе с числами – это округление.

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

Math.floor Округление в меньшую сторону: 3.1 становится 3 , а -1.1 — -2 . Math.ceil Округление в большую сторону: 3.1 становится 4 , а -1.1 — -1 . Math.round Округление до ближайшего целого: 3.1 становится 3 , 3.6 — 4 , а -1.1 — -1 . Math.trunc (не поддерживается в Internet Explorer) Производит удаление дробной части без округления: 3.1 становится 3 , а -1.1 — -1 .

Ниже представлена таблица с различиями между функциями округления:

Math.floor	Math.ceil	Math.round	Math.trunc
3.1	3	4	3	3
3.6	3	4	4	3
-1.1	-2	-1	-1	-1
-1.6	-2	-1	-2	-1

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

Например, у нас есть 1.2345 и мы хотим округлить число до 2-х знаков после запятой, оставить только 1.23 .

Есть два пути решения:

let num = 1.23456; alert( Math.round(num * 100) / 100 ); // 1.23456 -> 123.456 -> 123 -> 1.23

let num = 12.34; alert( num.toFixed(1) ); // "12.3"

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

let num = 12.36; alert( num.toFixed(1) ); // "12.4"

Обратите внимание, что результатом toFixed является строка. Если десятичная часть короче, чем необходима, будут добавлены нули в конец строки:

let num = 12.34; alert( num.toFixed(5) ); // "12.34000", добавлены нули, чтобы получить 5 знаков после запятой

Неточные вычисления

Внутри JavaScript число представлено в виде 64-битного формата IEEE-754. Для хранения числа используется 64 бита: 52 из них используется для хранения цифр, 11 для хранения положения десятичной точки и один бит отведён на хранение знака.

Если число слишком большое, оно переполнит 64-битное хранилище, JavaScript вернёт бесконечность:

alert( 1e500 ); // Infinity

Наиболее часто встречающаяся ошибка при работе с числами в JavaScript – это потеря точности.

Посмотрите на это (неверное!) сравнение:

alert( 0.1 + 0.2 == 0.3 ); // false

Да-да, сумма 0.1 и 0.2 не равна 0.3 .

Странно! Что тогда, если не 0.3 ?

alert( 0.1 + 0.2 ); // 0.30000000000000004

Ой! Здесь гораздо больше последствий, чем просто некорректное сравнение. Представьте, вы делаете интернет-магазин и посетители формируют заказ из 2-х позиций за $0.10 и $0.20 . Итоговый заказ будет $0.30000000000000004 . Это будет сюрпризом для всех.

Но почему это происходит?

Число хранится в памяти в бинарной форме, как последовательность бит – единиц и нулей. Но дроби, такие как 0.1 , 0.2 , которые выглядят довольно просто в десятичной системе счисления, на самом деле являются бесконечной дробью в двоичной форме.

Другими словами, что такое 0.1 ? Это единица делённая на десять — 1/10 , одна десятая. В десятичной системе счисления такие числа легко представимы, по сравнению с одной третьей: 1/3 , которая становится бесконечной дробью 0.33333(3) .

Деление на 10 гарантированно хорошо работает в десятичной системе, но деление на 3 – нет. По той же причине и в двоичной системе счисления, деление на 2 обязательно сработает, а 1/10 становится бесконечной дробью.

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

Числовой формат IEEE-754 решает эту проблему путём округления до ближайшего возможного числа. Правила округления обычно не позволяют нам увидеть эту «крошечную потерю точности», но она существует.

alert( 0.1.toFixed(20) ); // 0.10000000000000000555

Выражения и операторы

Эта глава описывает выражения и операторы языка JavaScript, такие как операторы присваивания, сравнения, арифметические, битовые, логические, строчные, и различные специальные операторы.

Полный и детальный список операторов и выражений также доступен в этом руководстве.

Операторы

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

Операторы присваивания
Операторы сравнения
Арифметические операторы
Битовые (поразрядные) операторы
Логические операторы
Строковые операторы
Условный (тернарный) оператор
Оператор запятая
Унарные операторы
Операторы отношения
Приоритет операторов

JavaScript поддерживает бинарные и унарные операторы, а также ещё один специальный тернарный оператор — условный оператор. Бинарная операция использует два операнда, один перед оператором и другой за ним:

operand1 operator operand2

Например: 3+4 или x*y .

В свою очередь унарная операция использует один операнд, перед или после оператора:

operator operand

operand operator

Например: x++ или ++x .

Операторы присваивания

В результате операции присваивания операнду слева от оператора присваивания (en-US) (знак » table-container»>

Имя	Сокращённый оператор	Смысл
Присваивание (en-US)	x = y	x = y
Присваивание со сложением (en-US)	x += y	x = x + y
Присваивание с вычитанием (en-US)	x -= y	x = x — y
Присваивание с умножением (en-US)	x *= y	x = x * y
Присваивание с делением (en-US)	x /= y	x = x / y
Присваивание по модулю (en-US)	x %= y	x = x % y
Присваивание с левым сдвигом (en-US)	x	x = x
Присваивание с правым сдвигом (en-US)	x >>= y	x = x >> y
Присваивание с беззнаковым сдвигом вправо (en-US)	x >>>= y	x = x >>> y
Присваивание с побитовым AND (en-US)	x &= y	x = x & y
Присваивание с побитовым XOR (en-US)	x ^= y	x = x ^ y
Присваивание с побитовым OR (en-US)	x \|= y	x = x \| y

Деструктуризация

Для более сложного присваивания в JavaScript есть синтаксис деструктуризации — это выражение, которое позволяет извлекать данные из массивов или объектов, используя синтаксис, который зеркалирует конструкторы массивов и литералы объектов.

var foo = ["one", "two", "three"]; // без деструктуризации var one = foo[0]; var two = foo[1]; var three = foo[2]; // с деструктуризацией var [one, two, three] = foo;

Операторы сравнения

Оператор сравнения (en-US) сравнивает свои операнды и возвращает логическое значение, базируясь на истинности сравнения. Операнды могут быть числами, строками, логическими величинами или объектами. Строки сравниваются на основании стандартного лексикографического порядка, используя Unicode-значения. В большинстве случаев, если операнды имеют разный тип, то JavaScript пробует преобразовать их в тип, подходящий для сравнения. Такое поведение обычно происходит при сравнении числовых операндов. Единственным исключением из данного правила является сравнение с использованием операторов === и !== , которые производят строгое сравнение на равенство или неравенство. Эти операторы не пытаются преобразовать операнды перед их сравнением. Следующая таблица описывает операторы сравнения в контексте следующего примера кода:

var var1 = 3, var2 = 4;

Оператор	Описание	Примеры, возвращающие true
Равно ( == )	Возвращает true, если операнды равны.	3 == var1 «3» == var1 3 == ‘3’
Не равно ( != )	Возвращает true, если операнды не равны.	var1 != 4 var2 != «3»
Строго равно ( === )	Возвращает true, если операнды равны и имеют одинаковый тип. Смотрите также Object.is и sameness in JS.	3 === var1
Строго не равно( !== )	Возвращает true, если операнды не равны и/или имеют разный тип.	var1 !== «3» 3 !== ‘3’
Больше ( > )	Возвращает true, если операнд слева больше операнда справа.	var2 > var1 «12» > 2
Больше или равно ( >= )	Возвращает true, если операнд слева больше или равен операнду справа.	var2 >= var1 var1 >= 3
Меньше ( < )	Возвращает true, если операнд слева меньше операнда справа.	var1 < var2 "2" < 12
Меньше или равно (	Возвращает true, если операнд слева меньше или равен операнду справа.	var1

Примечание: (=>) не оператор, а нотация Стрелочных функций.

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

Арифметические операторы (en-US) используют в качестве своих операндов числа (также литералы или переменные) и в качестве результата возвращают одно числовое значение. Стандартными арифметическими операторами являются сложение (+), вычитание (-), умножение (*), и деление (/). При работе с числами с плавающей точкой эти операторы работают аналогично их работе в большинстве других языках программирования (обратите внимание, что деление на ноль возвращает бесконечность Infinity ). Например:

.log(1 / 2); /* возвращает 0.5 */ console.log(1 / 2 == 1.0 / 2.0); /* возвращает true */

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

Оператор	Описание	Пример
Остаток от деления (en-US) ( % )	Бинарный оператор. Возвращает целочисленный остаток от деления двух операндов.	12 % 5 вернёт 2.
Инкремент (en-US) ( ++ )	Унарный оператор. Добавляет единицу к своему операнду. Если используется в качестве префикса ( ++x ), то возвращает значение операнда с добавленной к нему единицей; а в случае применения в качестве окончания ( x++ ) возвращает значение операнда перед добавлением к нему единицы.	Если x равно 3, тогда ++x установит значение x равным 4 и вернёт 4, напротив x++ вернёт 3 и потом установит значение x равным 4.
Декремент (en-US) ( — )	Унарный оператор. Вычитает единицу из значения своего операнда. Логика данного оператора аналогична оператору инкремента.	Если x равно 3, тогда —x установит значение x равным 2 и вернёт 2, напротив x— вернёт 3 и потом установит значение x равным 2.
Унарный минус (en-US) —	Унарный оператор. Возвращает отрицательное значение своего операнда.	Если x равно 3, тогда -x вернёт -3.
Унарный плюс (en-US) ( + )	Унарный оператор. Пытается конвертировать операнд в число, если он ещё не оно.	+»3″ вернёт 3 . +true вернёт 1.
Возведение в степень (en-US) ( ** ) Экспериментальная возможность	Возводит основание в показатель степени , как, основаниестепень	2 3 вернёт 8 . 10 -1 вернёт 0.1 .

Битовые (поразрядные) операторы

Битовые операторы (en-US) обрабатывают свои операнды как последовательности из 32 бит (нулей и единиц), а не как десятичные, шестнадцатеричные или восьмеричные числа. Например, десятичное число 9 имеет двоичное представление 1001. Битовые операторы выполняют операции над таким двоичным представлением, но результат возвращают как обычное числовое значение JavaScript.

Следующая таблица обобщает битовые операторы JavaScript.

Оператор	Использование	Описание
Побитовое И (en-US)	a & b	Возвращает единицу в каждой битовой позиции, для которой соответствующие биты обеих операндов являются единицами.
Побитовое ИЛИ (en-US)	a \| b	Возвращает единицу в каждой битовой позиции, для которой один из соответствующих битов или оба бита операндов являются единицами.
Исключающее ИЛИ (en-US)	a ^ b	Возвращает единицу в каждой битовой позиции, для которой только один из соответствующих битов операндов является единицей.
Побитовое НЕ (en-US)	~ a	Заменяет биты операнда на противоположные.
Сдвиг влево (en-US)	a	Сдвигает a в двоичном представлении на b бит влево, добавляя справа нули.
Сдвиг вправо с переносом знака (en-US)	a >> b	Сдвигает a в двоичном представлении на b бит вправо, отбрасывая сдвигаемые биты.
Сдвиг вправо с заполнением нулями (en-US)	a >>> b	Сдвигает a в двоичном представлении на b бит вправо, отбрасывая сдвигаемые биты и добавляя слева нули.

Битовые логические операторы

Основной смысл работы битовых логических операторов состоит в следующем:

До : 11100110111110100000000000000110000000000001 После : 10100000000000000110000000000001

Например, двоичным представлением числа 9 является 1001, а двоичным представлением пятнадцати — 1111. Результаты применения к этим числам битовых логических операторов выглядят следующим образом:

Выражение	Результат	Двоичное описание
15 & 9	9	1111 & 1001 = 1001
15 \| 9	15	1111 \| 1001 = 1111
15 ^ 9	6	1111 ^ 1001 = 0110
~15	-16	~«00000000. «00001111 = «1111«1111«. «11110000
~9	-10	~«00000000«. «0000«1001 = «1111«1111«. «1111«0110

Обратите внимание, что все 32 бита преобразуются с использованием битового оператора НЕ, и что величины с наиболее значимым (самым левым) битом равным 1 представляют собой отрицательные числа (в представлении дополнения до двух).

Битовые операторы сдвига

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

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

Операторы сдвига перечислены в следующей таблице.

Оператор	Описание	Пример
Сдвиг влево (en-US) (	Данный оператор сдвигает первый операнд на указанное количество бит влево. Излишние биты, сдвинутые влево, отбрасываются. Справа число дополняется нулевыми битами.	9
Сдвиг вправо с переносом знака (en-US) ( >> )	Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется копиями крайнего слева бита.	9>>2 равно 2, так как 1001 после сдвига на 2 бита вправо превращается в 10, что соответствует числу 2. Подобным же образом -9>>2 равно -3, так как знак сохраняется.
Сдвиг вправо с заполнением нулями (en-US) ( >>> )	Данный оператор сдвигает первый операнд на указанное количество бит вправо. Излишние биты, сдвинутые вправо, отбрасываются. Слева число дополняется нулевыми битами.	19>>>2 равно 4, так как 10011 после сдвига на 2 бита вправо превращается в 100, что соответствует числу 4. Для неотрицательных чисел сдвиг вправо с заполнением нулями и сдвиг вправо с переносом знака дают одинаковый результат.

Логические операторы

Логические операторы (en-US) обычно используются с булевыми (логическими) значениями; при этом возвращаемое ими значение также является булевым. Однако операторы && и || фактически возвращают значение одного из операндов, поэтому, если эти операторы используются с небулевыми величинами, то возвращаемая ими величина также может быть не булевой. Логические операторы описаны в следующей таблице.

Оператор	Использование	Описание
Логическое И (en-US) ( && )	expr1 && expr2	(Логическое И) Возвращает операнд expr1 , если он может быть преобразован в false ; в противном случае возвращает операнд expr2 . Таким образом, при использовании булевых величин в качестве операндов, оператор && возвращает true , если оба операнда true ; в противном случае возвращает false .
Логическое ИЛИ (en-US) ( \|\| )	expr1 \|\| expr2	(Логическое ИЛИ) Возвращает операнд expr1 , если он может быть преобразован в true ; в противном случае возвращает операнд expr2 . Таким образом, при использовании булевых величин в качестве операндов, оператор \|\| возвращает true , если один из операндов true ; если же оба false , то возвращает false .
Логическое НЕ (en-US) ( ! )	!expr	(Логическое НЕ) Возвращает false , если операнд может быть преобразован в true ; в противном случае возвращает true .

Примерами выражений, которые могут быть преобразованы в false являются: null, 0, NaN, пустая строка («») или undefined.

Следующий код демонстрирует примеры использования оператора && (логическое И).

var a1 = true && true; // t && t возвращает true var a2 = true && false; // t && f возвращает false var a3 = false && true; // f && t возвращает false var a4 = false && 3 == 4; // f && f возвращает false var a5 = "Cat" && "Dog"; // t && t возвращает Dog var a6 = false && "Cat"; // f && t возвращает false var a7 = "Cat" && false; // t && f возвращает false

Следующий код демонстрирует примеры использования оператора || (логическое ИЛИ).

var o1 = true || true; // t || t возвращает true var o2 = false || true; // f || t возвращает true var o3 = true || false; // t || f возвращает true var o4 = false || 3 == 4; // f || f возвращает false var o5 = "Cat" || "Dog"; // t || t возвращает Cat var o6 = false || "Cat"; // f || t возвращает Cat var o7 = "Cat" || false; // t || f возвращает Cat

Следующий код демонстрирует примеры использования оператора ! (логическое НЕ).

var n1 = !true; // !t возвращает false var n2 = !false; // !f возвращает true var n3 = !"Cat"; // !t возвращает false

Сокращённая оценка

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

false && anything — сокращение с результатом false.
true || anything — сокращение с результатом true.

Правила логики гарантируют, что данные вычисления всегда корректны. Обратите внимание, что часть «anything» представленных выше выражений не вычисляется, таким образом удаётся избежать любых побочных эффектов вычисления данной части.

Строковые операторы

В дополнение к операторам сравнения, которые могут использоваться со строковыми значениями, оператор (+) позволяет объединить две строки, возвращая при этом третью строку, которая представляет собой объединение двух строк-операндов:

.log("my " + "string"); // в консоли выведется строка "my string".

Сокращённый оператор присваивания += также может быть использован для объединения (конкатенации) строк:

var mystring = "alpha"; mystring += "bet"; // получается значение "alphabet" и присваивается mystring.

Условный (тернарный) оператор

Условный оператор является единственным оператором JavaScript, который использует три операнда. Оператор принимает одно из двух значений в зависимости от заданного условия. Синтаксис оператора:

condition ? val1 : val2

Предупреждение: val1 и val2 обязательно должны что-то возвращать, поэтому в этой конструкции нельзя использовать continue или break

Если condition (условие) — истина, то оператор принимает значение val1 . В противном случае оператор принимает значение val2 . Вы можете использовать условный оператор во всех случаях, где может быть использован стандартный оператор.

var status = age >= 18 ? "adult" : "minor";

Данное выражение присваивает значение «adult» переменной status , если age имеет значение 18 или более. В противном случае переменной status присваивается значение «minor».

Оператор запятая

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

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

for (var i = 0, j = 9; i  9; i++, j--) document.writeln("a[" + i + "][" + j + "] token operator">+ a[i][j]);

Унарные операторы

Унарная операция — операция только с одним операндом.

delete

Оператор delete выполняет удаление объекта, свойства объекта, или элемента массива с заданным индексом. Синтаксис оператора:

delete objectName; delete objectName.property; delete objectName[index]; delete property; // допустимо только внутри with

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

Четвёртый вариант использования позволяет удалить свойство объекта, но допускается только внутри with .

Вы можете использовать оператор delete для удаления переменных, объявленных неявно, но вы не можете с его помощью удалять переменные, объявленные с помощью var .

После применения оператора delete свойство элемента меняется на undefined . Оператор delete возвращает true если выполнение операции возможно; оператор возвращает false , если выполнение операции невозможно.

= 42; var y = 43; myobj = new Number(); myobj.h = 4; // создаём свойство h delete x; // возвращает true (можно удалить переменную объявленную неявно) delete y; // возвращает false (нельзя удалить переменную объявленную с помощью var) delete Math.PI; // возвращает false (нельзя удалить встроенные свойства) delete myobj.h; // возвращает true (можно удалить пользовательские свойства) delete myobj; // возвращает true (можно удалить объект объявленный неявно)

Удаление элементов массива

Удаление элемента массива не влияет на длину массива. Например, если вы удалите a[3] , элемент a[4] останется a[4], a[3] станет undefined.

Когда элемент массива удаляется с помощью оператора delete , то из массива удаляется значение данного элемента. В следующем примере элемент trees[3] удалён с помощью оператора delete . Однако, элемент trees[3] остаётся адресуемым и возвращает значение undefined .

var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); delete trees[3]; if (3 in trees)  // условие не выполняется >

Если вы хотите, чтобы элемент оставался в массиве, но имел значение undefined, то используйте ключевое слово undefined вместо оператора delete . В следующем примере элементу trees[3] присвоено значение undefined , но элемент при этом остаётся в массиве:

var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); trees[3] = undefined; if (3 in trees)  // данный блок кода выполняется >

Оператор typeof

Оператор typeof используется одним из следующих способов:

typeof operand typeof (operand)

Оператор typeof возвращает строку обозначающую тип невычисленного операнда. Значение operand может быть строкой, переменной, дескриптором, или объектом, тип которого следует определить. Скобки вокруг операнда необязательны.

Предположим, вы определяете следующие переменные:

var myFun = new Function("5 + 2"); var shape = "round"; var size = 1; var today = new Date();

Оператор typeof возвращает следующие результаты для этих переменных:

typeof myFun; // возвращает "function" typeof shape; // возвращает "string" typeof size; // возвращает "number" typeof today; // возвращает "object" typeof dontExist; // возвращает "undefined"

Для дескрипторов true и null оператор typeof возвращает следующие результаты:

typeof true; // возвращает "boolean" typeof null; // возвращает "object"

Для чисел и строк оператор typeof возвращает следующие результаты:

typeof 62; // возвращает "number" typeof "Hello world"; // возвращает "string"

Для свойств оператор typeof возвращает тип значения данного свойства:

typeof document.lastModified; // возвращает "string" typeof window.length; // возвращает "number" typeof Math.LN2; // возвращает "number"

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

typeof blur; // возвращает "function" typeof eval; // возвращает "function" typeof parseInt; // возвращает "function" typeof shape.split; // возвращает "function"

Для встроенных объектов оператор typeof возвращает следующие результаты:

typeof Date; // возвращает "function" typeof Function; // возвращает "function" typeof Math; // возвращает "object" typeof Option; // возвращает "function" typeof String; // возвращает "function"

Оператор void

Оператор void используется любым из следующих способов:

void (expression) void expression

Оператор void определяет выражение, которое должно быть вычислено без возвращения результата. expression — это выражение JavaScript, требующее вычисления. Скобки вокруг выражения необязательны, но их использование является правилом хорошего тона.

Вы можете использовать оператор void для указания на то, что операнд-выражение является гипертекстовой ссылкой. При этом выражение обрабатывается, но не загружается в текущий документ.

Следующий код служит примером создания гипертекстовой ссылки, которая бездействует при нажатии на неё пользователем. Когда пользователь нажимает на ссылку, void(0) вычисляется равным undefined , что не приводит ни к каким действиям в JavaScript.

a href="javascript:void(0)">Нажмите здесь, чтобы ничего не произошлоa>

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

a href="javascript:void(document.form.submit())"> Нажмите здесь, чтобы подтвердить отправку формыa >

Операторы отношения

Оператор отношения сравнивает свои операнды и возвращает результат сравнения в виде булева значения.

Оператор in

Оператор in возвращает true, если указанный объект имеет указанное свойство. Синтаксис оператора:

propNameOrNumber in objectName

где propNameOrNumber — строка или числовое выражение, представляющее имя свойства или индекс массива, а objectName — имя объекта.

Некоторые примеры способов использования оператора in :

// Массивы var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); 0 in trees; // возвращает true 3 in trees; // возвращает true 6 in trees; // возвращает false "bay" in trees; // возвращает false (следует указать индекс элемента массива, // а не значение элемента) "length" in trees; // возвращает true (length является свойством объекта Array) // Встроенные объекты "PI" in Math; // возвращает true var myString = new String("coral"); "length" in myString; // возвращает true // Пользовательские объекты var mycar =  make: "Honda", model: "Accord", year: 1998 >; "make" in mycar; // возвращает true "model" in mycar; // возвращает true

Оператор instanceof

Оператор instanceof возвращает true, если заданный объект является объектом указанного типа. Его синтаксис:

objectName instanceof objectType

где objectName — имя объекта, тип которого необходимо сравнить с objectType , а objectType — тип объекта, например, Date или Array .

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

Например, следующий код использует оператор instanceof для проверки того, является ли объект theDay объектом типа Date . Так как theDay действительно является объектом типа Date , то программа выполняет код, содержащийся в утверждении if .

var theDay = new Date(1995, 12, 17); if (theDay instanceof Date)  // выполняемый код >

Приоритет операторов

Приоритет операторов определяет порядок их выполнения при вычислении выражения. Вы можете влиять на приоритет операторов с помощью скобок.

Приведённая ниже таблица описывает приоритет операторов от наивысшего до низшего.

Тип оператора	Операторы
свойство объекта	. []
вызов, создание экземпляра объекта	() new
отрицание, инкремент	! ~ — + ++ — typeof void delete
умножение, деление	* / %
сложение, вычитание	+ —
побитовый сдвиг	> >>>
сравнение, вхождение	< >= in instanceof
равенство	== != === !==
битовое-и	&
битовое-исключающее-или	^
битовое-или	\|
логическое-и	&&
логическое-или	\|\|
условный (тернарный) оператор	?:
присваивание	= += -= *= /= %= <>= >>>= &= ^= \|=
запятая	,

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

Выражения

Выражением является любой корректный блок кода, который возвращает значение.

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

Выражение x = 7 является примером выражения первого типа. Данное выражение использует оператор = для присваивания переменной x значения 7. Само выражение также равняется 7.

Код 3 + 4 является примером выражения второго типа. Данное выражение использует оператор «+» для сложения чисел 3 и 4 без присваивания переменной полученного результата 7.

Все выражения в JavaScript делятся на следующие категории:

Арифметические: вычисляются в число, например: 3.14159 (Используют арифметические операторы).
Строковые: вычисляются в текстовую строку, например: «Fred» или «234» (Используют строковые операторы).
Логические: вычисляются в true или false (Используют логические операторы).
Основные выражения: Базовые ключевые слова и основные выражения в JavaScript.
Левосторонние выражения: Значениям слева назначаются значения справа.

Основные выражения

Базовые ключевые слова и основные выражения в JavaScript.

Оператор this

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

this["propertyName"] this.propertyName

Предположим, функция validate выполняет проверку свойства value некоторого объекта; задан объект, а также верхняя и нижняя граница величины данного свойства:

function validate(obj, lowval, hival)  if (obj.value  lowval || obj.value > hival) alert("Неверное значение!"); >

Вы можете вызвать функцию validate для обработчика события onChange для каждого элемента формы, используя this для указания на элемент формы, как это показано в следующем примере:

b>Введите число от 18 до 99:b> input type="text" name="age" size="3" onChange="validate(this, 18, 99);" />

Оператор группировки

Оператор группировки «скобки» ( ) контролирует приоритет вычислений в выражениях. Например, вы можете переопределить порядок так, чтобы сложение выполнялось до умножения:

var a = 1; var b = 2; var c = 3; // обычный порядок a + b * c; // 7 // по умолчанию выполняется так a + (b * c); // 7 // теперь поменяем приоритет с помощью скобок, // чтобы сложение выполнялось до умножения (a + b) * c; // 9 // что эквивалентно следующему a * c + b * c; // 9

Упрощённый синтаксис создания массивов и генераторов

Упрощённый синтаксис — экспериментальная возможность JavaScript, которая возможно будет добавлена в будущие версии ECMAScript. Есть 2 версии синтаксиса:

Упрощённый синтаксис для массивов.

Упрощённый синтаксис для генераторов.

Упрощённые синтаксисы существуют во многих языках программирования и позволяют вам быстро собирать новый массив, основанный на существующем. Например:

[for (i of [ 1, 2, 3 ]) i*i ]; // [ 1, 4, 9 ] var abc = [ "A", "B", "C" ]; [for (letters of abc) letters.toLowerCase()]; // [ "a", "b", "c" ]

Левосторонние выражения

Значениям слева назначаются значения справа.

new

Вы можете использовать оператор new для создания экземпляра объекта пользовательского типа или одного из встроенных объектов. Используйте оператор new следующим образом:

var objectName = new objectType([param1, param2, . , paramN]);

super

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

super([arguments]); // вызывает конструктор родителя. super.functionOnParent([arguments]);

Оператор расширения

Оператор расширения позволяет выражению расширяться в местах с множеством аргументов (для вызовов функций) или множестве элементов (для массивов).

Пример: Сегодня, если у вас есть массив и вы хотите создать новый с существующей частью первого, то литерального синтаксиса массива уже не достаточно, и вы должны писать императивный (без вариантов) код, используя комбинацию push , splice , concat и т.д. Но с этим оператором код становится более коротким:

var parts = ["shoulder", "knees"]; var lyrics = ["head", . parts, "and", "toes"];

Похожим образом оператор работает с вызовами функций:

function f(x, y, z) > var args = [0, 1, 2]; f(. args);

« Предыдущая статья
Следующая статья »

Found a content problem with this page?

Edit the page on GitHub.
Report the content issue.
View the source on GitHub.

This page was last modified on 7 авг. 2023 г. by MDN contributors.

Your blueprint for a better internet.

MDN

Support

Product help
Report an issue

Our communities

Developers

Web Technologies
Learn Web Development
MDN Plus
Hacks Blog

Website Privacy Notice
Cookies
Legal
Community Participation Guidelines

Visit Mozilla Corporation’s not-for-profit parent, the Mozilla Foundation.
Portions of this content are ©1998– 2023 by individual mozilla.org contributors. Content available under a Creative Commons license.

Читать:

Как в яндекс браузере отключить javascript