JavaScript: операторы сравнения
От автора: вторая группа сравнений в JavaScript (после операторов равенства) это операторы сравнения, когда один операнд больше или меньше другого. Данный тип операторов очень часто используется в математических выражениях, часто при сравнении двух переменных в условии if.
Оператор больше чем
Задается в том случае, если левый операнд больше правого. В консоли выглядит так:
Данные операторы почти всегда используются для сравнения чисел, также их можно использовать со строками. В случае со строками Unicode значения каждого символа складываются, полученные значения для двух строк сравниваются между собой:
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
Узнать подробнее«Kirk» > «Picard» > false
Такое сравнение может привести к неожиданным результатам, т.е. не следует использовать операторы сравнения для строк.
Оператор меньше чем
Задается в том случае, если левый операнд меньше правого:
var romeFounded = -753; var beijingFounded = -1100; beijingFounded < romeFounded; > true
var romeFounded = -753; var beijingFounded = -1100;
beijingFounded < romeFounded; > true |
Если вы запутались в знаках больше или меньше, запомните две вещи:
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
Узнать подробнееМы задаем вопрос, элемент слева больше, меньше или равен элементу справа и…
Символы (> и
Т.е. при выражении 4
Оператор больше или равно
Оператор смотрит, первый операнд больше или равен второму:
var highScore = 1100; var userScore = 700; var message = «»; if (userscore >= highScore) { message = «We have a new winner!»; } else { message = «Sorry, you haven’t beaten or equalled the high score.»; }
var highScore = 1100; var userScore = 700; var message = «»; if (userscore >= highScore) { message = «We have a new winner!»; } else { message = «Sorry, you haven’t beaten or equalled the high score.»; } |
Оператор меньше или равно
Проверяет первый операнд – меньше он или равен второму:
Очень часто люди забывают, где писать знак равенства, перед угловой скобкой или после. Знак равно пишется в том же порядке, как читается: «меньше или равно» — т.е.
А как же оператор неравенства?
Иногда программисты-новички в JavaScript пишут оператор «неравен» <>. К сожалению, такая запись не работает; используйте оператор неравенства (!=) или (предпочтительно) оператор строгого неравенства (!==).
Источник: http://thenewcode.com/
Редакция: Команда webformyself.
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
Узнать подробнее
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
Смотретьзагадочное дело выражения null >= 0 / RUVDS.com corporate blog / Habr
Однажды я собирал материалы чтобы устроить ликбез по JavaScript для пары коллег. Тогда я и наткнулся на довольно интересный пример, в котором рассматривалось сравнение значения null с нулём. Собственно говоря, вот этот пример:
null > 0; // false
null == 0; // false
null >= 0; // trueНа первый взгляд — полная бессмыслица. Как некое значение может быть не больше, чем 0, не равно нулю, но при этом быть больше или равно нулю?
Хотя поначалу я оставил это без особого внимания, решив, что всё дело в том, что JavaScript — это JavaScript, со всеми его странностями, этот пример меня заинтриговал. Связано ли это с типом
nullВ итоге я решил докопаться до сути происходящего и начал рыться в единственном источнике истины для JavaScript — в спецификации ECMA. Сегодня я хочу рассказать вам о том, в какую глубокую кроличью нору я в результате провалился.
Абстрактный алгоритм сравнения для отношений
Рассмотрим первое сравнение:
null > 0; // falseВ соответствии со спецификацией, операторы сравнения
> и <, для того, чтобы выяснить, истинно или ложно выражение, пропускают его через так называемый абстрактный алгоритм сравнения для отношений. Здесь и далее мы будем цитировать фрагменты спецификации по тексту перевода «Стандарт ECMA-262, 3я редакция» с ресурса javascript.ru:Сравнение x < y, где x и y являются значениями, возвращает true, false или undefined (последнее означает, что хотя бы один из операндов равен NaN). Такое сравнение производится следующим образом: 1. Вызвать ToPrimitive(x, подсказка Number). 2. Вызвать ToPrimitive(y, подсказка Number). 3. Если Тип(Результата(1)) равен String и Тип(Результата(2)) равен String - переход на шаг 16. (Заметим, что этот шаг отличается от шага 7 в алгоритме для оператора сложения + тем, что в нём используется и вместо или.) 4. Вызвать ToNumber(Результат(1)). 5. Вызвать ToNumber(Результат(2)). 6. Если Результат(4) равен NaN - вернуть undefined. 7. Если Результат(5) равен NaN - вернуть undefined. 8. Если Результат(4) и Результат(5) являются одинаковыми числовыми значениями - вернуть false. 9. Если Результат(4) равен +0 и Результат(5) равен -0 - вернуть false. 10. Если Результат(4) равен -0 и Результат(5) равен +0 - вернуть false. 11. Если Результат(4) равен +∞, вернуть false. 12. Если Результат(5) равен +∞, вернуть true. 13. Если Результат(5) равен -∞, вернуть false. 14. Если Результат(4) равен -∞, вернуть true. 15. Если математическое значение Результата (4) меньше, чем математическое значение Результата(5) (заметим, что эти математические значения оба конечны и не равны нулю) - вернуть true. Иначе вернуть false. 16. Если Результат(2) является префиксом Результата(1), вернуть false. (Строковое значение p является префиксом строкового значения q, если q может быть результатом конкатенации p и некоторой другой строки r. Отметим, что каждая строка является своим префиксом, т.к. r может быть пустой строкой.) 17. Если Результат(1) является префиксом Результата(2), вернуть true. 18. Пусть k - наименьшее неотрицательное число такое, что символ на позиции k Результата(1) отличается от символа на позиции k Результата(2). (Такое k должно существовать, т.к. на данном шаге установлено, что ни одна из строк не является префиксом другой.) 19. Пусть m - целое, равное юникодному коду символа на позиции k строки Результат(1). 20. Пусть n - целое, равное юникодному коду символа на позиции k строки Результат(2). 21. Если m < n, вернуть true. Иначе вернуть false.
Пройдёмся по этому алгоритму с нашим выражением
null > 0.Шаги 1 и 2 предлагают нам вызвать оператор ToPrimitive() для значений null и 0 для того, чтобы привести эти значения к их элементарному типу (к такому, например, как Number или String). Вот как ToPrimitive преобразует различные значения:
| Входной тип |
Результат |
| Undefined |
Преобразование не производится |
| Null |
Преобразование не производится |
| Boolean |
Преобразование не производится |
| Number |
Преобразование не производится |
| String |
Преобразование не производится |
| Object |
Возвращает значение по умолчанию для объекта. Значение по умолчанию для объекта получается путём вызова для объекта внутреннего метода [[DefaultValue]] с передачей ему опциональной подсказки ПредпочтительныйТип. |
В соответствии с таблицей, ни к левой части выражения,
null, ни к правой части, 0, никаких преобразований не применяется.Шаг 3 алгоритма в нашем случае неприменим, пропускаем его и идём дальше. На шагах 4 и 5 нам нужно преобразовать левую и правую части выражения к типу Number. Преобразование к типу Number выполняется в соответствии со следующей таблицей (здесь опущены правила преобразования для входных типов String и Object, так как они к теме нашего разговора отношения не имеют):
| Входной тип |
Результат |
| Undefined |
NaN |
| Null |
+0 |
| Boolean |
Результат равен 1, если аргумент равен true. Результат равен +0, если аргумент равен false. |
| Number |
Преобразование не производится |
| … |
… |
В соответствии с таблицей,
null будет преобразовано в +0, а 0 останется самим собой. Ни одно из этих значений не является NaN, поэтому шаги алгоритма 6 и 7 можно пропустить. А вот на шаге 8 нам надо остановиться. Значение +0 равно 0, в результате алгоритм возвращает false. Таким образом:null > 0; // false
null < 0; // тоже falseИтак, почему
null не больше и не меньше нуля мы выяснили. Теперь идём дальше — разберёмся с тем, почему null ещё и не равен нулю.Абстрактный алгоритм сравнения для равенств
null и 0:null == 0; //falseОператор
== использует так называемый абстрактный алгоритм сравнения для равенств, возвращая в результате true или false. Вот этот алгоритм:Сравнение x == y, где x и y являются значениями, возвращает true или false. Такое сравнение производится следующим образом: 1. Если Тип(x) отличается от Типа(y) - переход на шаг 14. 2. Если Тип(x) равен Undefined - вернуть true. 3. Если Тип(x) равен Null - вернуть true. 4. Если Тип(x) не равен Number - переход на шаг 11. 5. Если x является NaN - вернуть false. 6. Если y является NaN - вернуть false. 7. Если x является таким же числовым значением, что и y, - вернуть true. 8. Если x равен +0, а y равен -0, вернуть true. 9. Если x равен -0, а y равен +0, вернуть true. 10. Вернуть false. 11. Если Тип(x) равен String - вернуть true, если x и y являются в точности одинаковыми последовательностями символов (имеют одинаковую длину и одинаковые символы в соответствующих позициях). Иначе вернуть false. 12. Если Тип(x) равен Boolean, вернуть true, если x и y оба равны true или оба равны false. Иначе вернуть false. 13. Вернуть true, если x и y ссылаются на один и тот же объект или они ссылаются на объекты, которые были объединены вместе (см. раздел 13.1.2). Иначе вернуть false. 14. Если x равно null, а y равно undefined - вернуть true. 15. Если x равно undefined, а y равно null - вернуть true. 16. Если Тип(x) равен Number, а Тип(y) равен String, вернуть результат сравнения x == ToNumber(y). 17. Если Тип(x) равен String, а Тип(y) равен Number, вернуть результат сравнения ToNumber(x)== y. 18. Если Тип(x) равен Boolean, вернуть результат сравнения ToNumber(x)== y. 19. Если Тип(y) равен Boolean, вернуть результат сравнения x == ToNumber(y). 20. Если Тип(x) - String или Number, а Тип(y) - Object, вернуть результат сравнения x == ToPrimitive(y). 21. Если Тип(x) - Object, а Тип(y) - String или Number, вернуть результат сравнения ToPrimitive(x)== y. 22. Вернуть false.
Пытаясь понять, равно ли значение
null значению 0, мы сразу переходим из шага 1 к шагу 14, так как Тип(x) отличается от Типа(y). Как ни странно, но шаги 14-21 тоже к нашему случаю не подходят, так как Тип(х) — это null. Наконец мы попадаем на шаг 22, после чего false возвращается как значение по умолчанию!В результате и оказывается, что:
null == 0; //falseТеперь, когда ещё одна «тайна» JavaScript» раскрыта, разберёмся с оператором «больше или равно».
Оператор больше или равно (>=)
Выясним теперь, почему истинно такое выражение:
null >= 0; // trueТут спецификация полностью выбила меня из колеи. Вот как, на очень высоком уровне, работает оператор >=:
Если null < 0 принимает значение false, то null >= 0 принимает значение trueВ результате мы и получаем:
null >= 0; // trueИ, на самом деле, в этом есть смысл. С точки зрения математики, если у нас есть два числа,
x и y, и если x не меньше, чем y, тогда x должно быть больше чем y или равно ему.Я предполагаю, что данный оператор работает именно так для того, чтобы оптимизировать вычисления. Зачем сначала проверять, больше ли x чем y, и, если это не так, проверять, равняется ли значение x значению y, если можно выполнить всего одно сравнение, проверить, меньше ли x чем y, а затем использовать результат этого сравнения для того, чтобы вывести результат исходного выражения.
Итоги
Вопрос о сравнении
null и 0, на самом деле, не такой уж и сложный. Однако, поиск ответа открыл мне кое-что новое о JavaScript. Надеюсь, мой рассказ сделал то же самое для вас.Уважаемые читатели! Знаете ли вы о каких-нибудь странностях JavaScript, которые, после чтения документации, уже перестают казаться таковыми?
Операторы Javascript
В JavaScript существует множество различных операторов: арифметические операторы, операторы присваивания, строковые операторы, операторы сравнения, логические операторы, операторы типов, побитовые операторы.
Оператор присваивания (=) присваивает значение переменной:
var x = 5; // присваивает значение 5 переменной x
var y = 2; // присваивает значение 2 переменной y
var z = x + y; // присваивает значение 7 переменной z (x + y)
Оператор сложения (+) складывает числа:
var x = 5;
var y = 2;
var z = x + y;
Оператор умножения (*) перемножает числа:
var x = 5;
var y = 2;
var z = x * y;
Арифметические операторы JavaScript
Арифметические операторы используются для выполнения арифметических операций с числами:
| Оператор | Описание |
|---|---|
| + | Сложение |
| — | Вычитание |
| * | Умножение |
| / | Деление |
| % | Остаток от деления |
| ++ | Увеличение на 1 |
| — | Уменьшение на 1 |
Операторы присваивания JavaScript
Операторы присваивания присваивают значения переменным JavaScript.
| Оператор | Пример | Аналог |
|---|---|---|
| = | x = y | x = y |
| += | x += y | x = x + y |
| -= | x -= y | x = x — y |
| *= | x *= y | x = x * y |
| /= | x /= y | x = x / y |
| %= | x %= y | x = x % y |
Строковые операторы JavaScript
Оператор сложения (+) также может использоваться для объединения (конкатенации) строк.
txt1 = "John";
txt2 = "Doe";
txt3 = txt1 + " " + txt2;
В результате в переменной txt3 будет строка — «John Doe».
Также, для конкатенации строк можно использовать оператор присваивания +=:
txt1 = "Какой теплый ";
txt1 += "и чудесный день";
В результате в переменной txt1 будет строка — «Какой теплый и чудесный день».
При использовании со строками оператор + еще называют оператором конкатенации.
Сложение строк и чисел
Сложение двух чисел вернет сумму этих чисел, однако сложение числа и строки вернет строку:
x = 5 + 5;
y = "5" + 5;
z = "Hello" + 5;
В результате в переменных x, y, z мы получим 10, 55, Hello5 соответственно.
Помните! Если сложить число и строку, в результате получится строка!
Операторы сравнения JavaScript
| Оператор | Описание |
|---|---|
| == | равно |
| === | равно по значению и типу |
| != | не равно |
| !== | не равно по значению и типу |
| > | больше чем |
| < | меньше чем |
| >= | больше или равно |
| <= | меньше или равно |
| ? | тернарный оператор |
Логические операторы JavaScript
| Оператор | Описание |
|---|---|
| && | логическое И |
| || | логическое ИЛИ |
| ! | логическое НЕ |
Операторы типов JavaScript
| Оператор | Описание |
|---|---|
| typeof | Возвращает тип переменной |
| instanceof | Возвращает true, если объект является экземпляром определенного объектного типа |
Побитовые операторы JavaScript
Побитовые операторы работают с 32-битными числами.
Все числовые члены в побитовом операторе преобразуются в 32-битные числа. Результат вычисления преобразуется обратно в число JavaScript.
| Оператор | Описание | Пример | То же, что | Результат | Десятичное число |
|---|---|---|---|---|---|
| & | И | 5 & 1 | 0101 & 0001 | 1 | 1 |
| | | ИЛИ | 5 | 1 | 0101 | 0001 | 101 | 5 |
| ~ | НЕ | ~5 | ~0101 | 1010 | 10 |
| ^ | ИСКЛЮЧАЮЩЕЕ ИЛИ | 5 ^ 1 | 0101 ^ 0001 | 100 | 4 |
| << | Побитовый сдвиг влево | 5 << 1 | 0101 << 1 | 1010 | 10 |
| >> | Побитовый сдвиг вправо со знаком | 5 >> 1 | 0101 >> 1 | 10 | 2 |
| >>> | Побитовый сдвиг вправо | 5 >>> 1 | 0101 >>> 1 | 10 | 2 |
Внимание! В примерах в таблице выше приведены 4-битные числа без знака. В действительности же JavaScript использует 32-битные числа со знаком. Таким образом, в JavaScript выражение ~5 вернет не 10, а -6, т.е. ~00000000000000000000000000000101 возвращает 11111111111111111111111111111010.
JavaScript для начинающих | Операторы
Напоминаю, что это вводный курс по JavaScript для начинающих. Сегодня мы рассмотрим, какие операторы существуют в JavaScript. Пристегните ремни! Букаф будет много.
Когда у вас есть кучка данных, то с ними нужно что-то сделать. Делами-то как раз и заняты операторы. Они вечно что-то складывают, перемножают, делят, отнимают, сравнивают, присваивают и еще черти чем занимаются. Без операторов в программировании просто каши не сваришь.
В языке JavaScript используются следующие виды операторов:
- Арифметические операторы
- Операторы присваивания
- Операторы сравнения
- Логические операторы
- Строковые операторы
- Условные операторы
Это далеко не полный список, но для начала хватит и этого за глаза. Разберем каждый вид представленных операторов, зачем они нужны и с чем их едят. Поехали!
Арифметические операторы в JavaScript
С арифметическими операторами все вы знакомы еще со школы. Это обычные знаки сложения, вычитания, деления и умножения: +, -, /, *. Соответственно, выполняют они в программировании те же самые функции, что и в обычной математике. Сложностей с этим у вас не возникнет.
Данные, с которыми работают операторы, называются операндами.
2 + 3 // здесь числа 2 и 3 — операнды, а знак + — оператор сложения
Как и в математике у арифметических операторов есть свои приоритеты: умножение и деление имеют более высокий приоритет, чем сложение и вычитание.
2 + 3 * 4 // здесь сначала выполняется умножение, а уже потом сложение
И так же, как в математике, активно используются скобки, чтобы изменить приоритет:
(2 + 3) * 4 // здесь сначала выполняется сложение, а потом умножение
Кстати, знак = тоже оператор. Как мы уже выяснили в статье про функции в JavaScript, это оператор присваивания, а вовсе не знак равенства. Не забывайте об этом!
Оператор деления по модулю
А теперь рассмотрим более интересные арифметические операторы. И первым станет значок процентов — %. В JavaScript это не проценты от слова совсем. Так в программировании обозначается деление по модулю. Результатом такой операции будет остаток от деления. Например:
100 % 22 // остаток будет равен 12
100 % 10 // остаток будет равен 0
При вычислениях этот оператор имеет тот же приоритет, что и умножение с делением, так что не забывайте ставить скобочки.
Совмещение операторов
Оператор = можно и нужно совмещать с другими операторами, чтобы сократить запись. Пример:
var n = 2; // присваиваем переменной n значение 2
n = n + 3; // присваиваем переменной n новое значение n + 2, получаем 5
То же самое можно записать так:
var n = 2;
n += 3; // равносильно записи n = n + 3
Операторы инкремента ++ и декремента – –
Среди арифметических операторов есть парочка весьма любопытных — инкремент и декремент. Обозначаются соответственно ++ и ––. Первый увеличивает переменную на единицу, а второй уменьшает. Эта фишка очень часто используется в программировании, так как предоставляет массу удобств. Чаще всего ее можно встретить в условных выражениях, но об этом позже.
У обоих операторов есть определенное местоположение в записи. Они могут быть как в префиксной форме (перед переменной) ++n, так и в постфиксной (после переменной) n++. Разница огромна! Никогда не путайте эти формы и хорошенько запомните их. Если эти операторы стоят перед переменной, то в результате увеличивают ее значение на 1. Но! Если они стоят после переменной, то возвращают исходное значение. Пример:
var n = 2, m = 0;
m = ++n // увеличивает n на 1 (n = 3) и присваивает m тоже значение 3
var n = 2, m = 3;
m = n++ // увеличивает n на 1 (n = 3), но присваивает m предыдущее значение n = 2
С первым примером, уверен, вы легко разберетесь. А вот со вторым могут возникнуть проблемы. Чтобы легче было понять эту штуку и не запутаться, просто представьте, что вы сначала присвоили переменной m значение переменной n, а уже после этого увеличили значение n на единицу. В первом же примере вы сначала увеличили значение n на единицу, а потом уже присвоили это значение переменной m.
На этом с арифметическими операторами все. Разумеется, есть еще куча вариаций и тонкостей использования этих простых операторов, но для начала вам этого будет более чем достаточно.
Операторы сравнения
И снова вспоминаем математику. Знаки и > знакомы всем и каждому. В программировании они называются операторами сравнения. В JavaScript используются следующие операторы сравнения:
< меньше
> больше
<= меньше или равно
>= больше или равно
== равно
!= не равно
=== строго равно
!== строго не равно
Обратите внимание, что знак «больше или равно» пишется именно так >=, а не =>. То есть, стрелка стоит перед знаком равно, а не после него.
Операторы сравнения позволяют сравнивать значения переменных и результатом этой операции всегда выступает булево значение true или false. Обычно их применяют в условных выражениях. От того, что дает результат сравнение зависит, какая часть кода будет выполняться дальше.
В JavaScript можно сравнивать разные типы данных одновременно, например, число и строку:
12345 == "12345" // true
Просто в этом случае строка автоматически преобразуется в число. Строгое же равенство === или неравенство !== используются только при сравнении переменных одинакового типа.
Логические операторы
Логические операции в JavaScript — это одна из довольно мудреных тем для начинающих. С ней стоит хорошенько разобраться, чтобы успешно идти дальше в освоении языка. Они чаще всего применяются вместе с операциями сравнения и выдают булево значение true или false.
Логических операторов три:
&& (И)
|| (ИЛИ)
! (НЕ)
Логический оператор && (И)
Оператор && выполняет операцию «логическое И» над двумя значениями. При этом он возвращает true тогда и только тогда, когда оба операнда имеют значение true. Если же один или оба операнда имеют значение false, то оператор возвращает false. Примеры:
2 < 3 && 4 < 5 // true
2 < 3 && 5 < 4 // false
3 < 2 && 5 < 4 // false
У логических операторов приоритет меньше, чем у операторов сравнения, поэтому в приведенных примерах мы обходимся без скобок. Понятно, что сначала мы сравниваем числа между собой, а уже потом применяем логику.
Логический оператор || (ИЛИ)
С логическим оператором || (ИЛИ) другая песня. Оператор || выполняет операцию «логическое ИЛИ» над двумя операндами. Если один или оба операнда имеют истинное значение, он возвращает истинное значение. Если оба операнда имеют ложные значения, он возвращает ложное значение. Примеры:
2 < 3 || 4 < 5 // true
2 < 3 || 5 < 4 // true
3 < 2 || 5 < 4 // false
У логических операторов есть одна хитрость. Они не любят лишней работы. Как, впрочем, и я. Свои вычисления они всегда начинают слева направо. И если первая часть выражения соответствует их условиям, то остальную часть выражения они даже не вычисляют.
К примеру, если оператор || находит истинное значение в самом начале, то сразу дает истинное значение, а остальное уже не проверяет. Также и оператор &&, если находит в самом начале ложное выражение, то сразу дает ложный результат, а остальную часть не проверяет.
И еще одна фишка: приоритет у оператора И && больше, чем у ИЛИ ||, поэтому он выполняется раньше:
2 < 3 || 4 < 5 && 5 < 6 // здесь сначала будет выполнено вычисление в правой части, а потом уже в левой
Логический оператор ! (НЕ)
Логический оператор ! обозначает «логическое НЕ». Он используется только с одним операндом и меняет значение этого операнда на противоположное. Если значение n истинно, то значение !n будет ложным. Так как этот оператор можно прикрутить лишь к одному операнду, то чтобы инвертировать целое выражение, его надо взять в скобки !(n && m).
!true // false
Строковые операторы
Про строковые операторы мы уже говорили ранее. Это тот самый плюс + что используется для соединения строковых переменных, или иначе — для конкатенации (сложения строк). Пример:
"Игорь " + "Квентор" == "Игорь Квентор"
Обратите внимание, что в первом слове добавлен пробел перед закрывающей кавычкой. Если его не добавить, то строки сольются в одно слово «ИгорьКвентор».
У этого оператора есть одна особенность: если в выражении есть хоть одна строка, то он и все остальные аргументы приводит к строковому типу. Например:
1 + "2" == "12"
Остальные арифметические операторы работают только с числами и всегда приводят аргументы к числу.
Условные операторы
В JavaScript есть два условных оператора if и ?: Хотя, если быть точным, то if — это вообще-то управляющая инструкция и довольно обширная, с кучей плюшек и интересных особенностей. Поэтому о ней будет отдельная статья. Пока же рассмотрим более простой условный оператор ?:
Обычно этот оператор записывается как ?: Но в программах он выглядит иначе. Он имеет три операнда. Первый операнд предшествует символу ?, второй стоит между символами ? и : третий — после :
Пример:
условие ? значение 1 : значение 2
Смысл его работы прост: если выполняется поставленное условие, то возвращается значение 1, если же нет — значение 2. Этот условный оператор часто служит более простой заменой инструкции if, когда в последней нет особой необходимости. При этом и сама запись сокращается и ее легче прочесть.
Пока на этом все!
Надеюсь, с операторам в JavaScript вы теперь немного разобрались. А чтобы мозг не закипел, вот вам короткий мульт для расслабления — Программист может все! 🙂
Автор: Игорь Квентор
www.websovet.com
Справочник javascript: Побитовые операторы
Побитовые операторы интерпретируют операнды как последовательность из 32 битов (нулей и единиц). Они производят операции, используя двоичное представление числа и возвращают новую последовательность из 32 бит (число) в качестве результата.
В следующей таблице перечислены все побитовые операторы.
Далее двоичное представление числа и операторы разобраны более подробно.
| Оператор | Использование | Описание |
|---|---|---|
| Побитовое И (AND) | a & b | Ставит 1 на каждого бита результата, для которого соответствующие биты операндов равны 1. |
| Побитовое ИЛИ (OR) | a | b | Ставит 1 для каждого бита результата, для которого хотя бы один из соответствующих битов операндов равен 1. |
| Побитовое исключающее ИЛИ (XOR) | a ^ b | Ставит 1 для каждого бита результата, для которого только один(но не оба) из соответствующих битов операндов равен 1. |
| Побитовое НЕ (NOT) | ~ a | Заменяет каждый бит операнда на противоположный. |
| Левый сдвиг | a << b | Сдвигает двоичное представление a на b битов влево, добавляя справа нули. |
| Правый сдвиг, переносящий знак | a >> b | Сдвигает двоичное представление a на b битов вправо, отбрасывая сдвигаемые биты. |
| Правый сдвиг с заполнением нулями | a >>> b | Сдвигает двоичное представление a на b битов вправо, отбрасывая сдвигаемые биты и добавляя нули слева. |
Формат 32-битного целого числа со знаком
Операнды всех побитовых операндов интерпретируются как 32-битные целые числа со знаком и старшим битом слева и дополнением до двойки.
«Старший бит слева» — означает, что самый значимый бит (битовая позиция с самым большим значением) находится на крайнем левом месте.
«Дополнение до двойки» означает, что двоичный вид числа, обратного данному (например, 5 и -5) получается путем обращения(двоичного НЕ) всех битов с добавлением 1.
Например, вот число 314:
00000000000000000000000100111010
Чтобы получить -314, первый шаг — обратить биты числа: