JavaScript. Операторы языка JavaScript. Классификация операторов

Операторы языка JavaScript. Классификация операторов


Содержание


Поиск на других ресурсах:

1. Понятие оператора

Операторы позволяют выполнять различные действия над данными (значениями) и возвращать результаты этих действий. В языке JavaScript в зависимости от количества операндов (значений) операторы делятся на две группы:

  • унарные. Это операторы, требующие одного операнда. Например, оператор — (минус), определяющий отрицательное число: -28, -3.55;
  • бинарные. Для получения результата эти операторы используют два операнда. Например, операторы + (сложение), (вычитание), * (умножение) и т.д.

Операндами в операторах могут быть:

  • константы;
  • переменные;
  • выражения (также содержат операторы);
  • функции.

Операторы возвращают только одно значение.

Примеры.

var x = 25
var y = 37
var z

// бинарный оператор * (умножение)
z = x * y

// унарный оператор - (минус), отрицательное число
z = -37

 

2. Классификация операторов

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

  • математические операторы;
  • операторы присваивания;
  • операторы сравнения;
  • логические операторы;
  • двоичные операторы или побитовые операторы;
  • строчный оператор +;
  • специальные операторы.

 

3. Математические (арифметические) операторы

К математическим операторам относятся:

  • + – сложение;
  • – вычитание;
  • * – умножение;
  • / — деление;
  • % – деление по модулю;
  • ++ – оператор инкремента;
  • –– оператор декремента.

Пример.

// Математические операторы
// 1. Сложение +
var x, y, z;

x = 2.88
y = 3
z = x + y // z = 5.88
z = x + y + y // z = 8.88

// 2. Вычитание -
z = x - y // z = -0.12
x = 5 - y // x = 2

// 3. Умножение *
x = 8
y = 20.5
z = x * y   // z = 164

// 4. Деление /
z = 10 / 5 // z = 2
z = x / 3  // z = 2.6666666666666665

// 5. Инкремент ++
x = 5
x++ // x = x + 1 =>   x = 6

x = 5
z = x++ // z = 5, x = 6   - постфиксная форма

x = 5
z = ++x // x = 6, z = 6   - префиксная форма

// 6. Декремент --
y = 3
y-- // y = y - 1 =>   y = 2

y = 3
z = y-- // z = 2, y = 3

y = 3
z = --y // y = 3, z = 3

// 7. Разделить по модулю (остача от деления нацело)
x = 8
y = 3
z = x % y // z = 2
z = 5 % 1 // z = 0
z = 3 % 8 // z = 3
z = 0 % 10 // z = 0
z = 7 % 7 // z = 0

 

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

Операторы присваивания позволяют устанавливать значения переменным, увеличивать или уменьшать значения переменных на указанную величину и т.п.

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

  • = – придает переменной некоторое значение;
  • += – увеличивает значение переменной на указанную величину;
  • -= – уменьшает значение переменной на указанную величину;
  • *= – умножает значение переменной на указанную величину;
  • /= – делит значение переменной на заданную величину;
  • %= – делит значение переменной на указанную величину и возвращает остаток от деления.

Пример.

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

// 1. Оператор =
x = 120

// 2. Оператор +=
x += 30 // x = x+30 =>   150

// 3. Оператор -=
x -= 10 // x = x-10 =>   140

// 4. Оператор *=
x = 100
x *= 2.5   // x = x*2.5 => 250

// 5. Оператор /=
x = 55
x /= 3   // x = x/3 =>   18.333333333333332

// 6. Оператор %=
x = 8
x %= 3   // x = x%3   => 2

 

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

Операторы сравнения осуществляют проверку операндов на равенство, неравенство и т.д. Результатом возврата оператора сравнения является true или false

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

  • == – равенство (если операнды равны, то возвращается значение true);
  • != – не равенство;
  • === – строго равно;
  • !== – строго не равно;
  • > – больше;
  • >= – больше или равно;
  • < – меньше;
  • <= – меньше или равно.

Пример.

// Операторы сравнения
var x, y
var b

// 1. == - равенство
// 1.1. Сравнение чисел
x = 3
y = 4
b = x == y // b = false

// 1.2. Сравнение строк
b = "abc" == "abc" // b = true
b = "abcd" == "abcde" // b = false

// 1.3. Сравнение числа и строки
b = "5" == 5 // b = true

// 2. != - не равно
b = 6 != 6 // b = false
b = "ab" != "ba" // b = true
b = true != false // b = true
b = "2.2" != 2.2 // b = false - сравнение числа и строки

// 3. >, >= - больше, больше или равно
x = 8; y = 10
b = x > y   // b = false
b = y >= x // b = true
b = y >= 10 // b = true
b = "abc" >= "abcd" // b = false

// 4. <, <= - меньше, меньше или равно
x = 5.2; y = 3.4
b = x < y   // b = false
b = y < x   // b = true
b = y <= x // b = true
b = x <= 5.2 // b = true
b = "aaa" <= "aaaa" // b = true

// 5. === - строго равно
b = 5==="5" // b = false

// 6. !== - строго не равно
b = 5!=="5" // b = true

 

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

Логические операторы определяют истинность (true) или ложность (false) логического выражения. В языке JavaScript есть три логических оператора.

  1. ! – отрицание или логическое НЕТ (NOT).

При логическом отрицании значение true становится false, а значение false становится равным true.

  1. && – логическое И (AND). Для двух операндов логического типа использование этого оператора дает следующий результат:
false && false = false
false && true   = false
true   && false = false
true   && true = true
  1. || – логическое ИЛИ (OR). Оператор || возвращает логическое true или false соответственно следующей таблице
false || false = false
false || true  = true
true  || false = true
true  || true  = true

Пример.

// Логические операторы
var x, y, z

// 1. Оператор ! - логическое отрицание
x = true
z = !x   // z = false
z = !(9<=6) // z = true

// 2. Оператор && - логическое И (AND)
x = true
y = false

z = x && y // z = false
z = (5>4) && (3<=7) // z = true

// 3. Оператор || - логическое ИЛИ (OR)
z = true || (6>0) // z = true
z = (5<3) || (4>10) // z = false

 

7. Двоичные (побитовые) операторы

Двоичные операторы выполняют действия над разрядами чисел, представленными двоичной системой исчисления. Эти операторы еще называют поразрядными или побитовыми операторами.

Язык JavaScript содержит следующие двоичные операторы:

  1. ~ – двоичная инверсия (поразрядное логическое отрицание). Значения битов 1 становятся равными 0, и, напротив, значения битов 0 становятся равными 1.
  2. & – двоичное (побитовое) И (AND). Результат обработки двух бит определяются операцией логического умножения по следующему принципу:
0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1
  1. | – двоичное ИЛИ (OR). Биты каждого из двух операндов взаимодействуют по следующей схеме:
0 | 0 = 0
0 | 1 = 1
1 | 0 = 1
1 | 1 = 1
  1. ^ – двоичное исключающее ИЛИ (XOR). Результат этой операции для двух заданных битов формируется по следующим правилам
0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 1
  1. << – смещение влево на заданное количество разрядов с заполнением младших разрядов нулями. С помощью сдвига влево можно получить число, умноженное на 2n, где n – количество разрядов на которые сдвигается исходное число.
  1. >> – смещение вправо на заданное количество разрядов с заполнением старших разрядов значением бита старшего разряда. Смещение вправо делит исходное число на 2n, где n – количество разрядов на сдвигающееся исходное число.
  1. >>> – смещение вправо без учета знака. Это смещение вправо на один или более разрядов с заполнением старших разрядов нулями.

Пример.

// Двоичные операторы
var x
var y

// 1. Оператор & - логическое И (AND)
x = 10    // x = 1010
y = 7     // y = 0111
z = x & y // z = 0010   => 2

// 2. Оператор | - логическое ИЛИ (OR)
x = 10    // x = 1010
y = 6     // x = 0110
z = x | y // z = 1110   => 14

// 3. Оператор ~ - двоичная инверсия
x = 255    // x =   11111111
z = ~x     // z = (1)00000000 => -256

x = 1      // x =   00000001
z = ~x     // z =   11111110   => -2

// 4. Оператор ^ - двоичное исключающее ИЛИ
x = 12    // x = 1100
y = 6     // y = 0110
z = x ^ y // z = 1010 => 10

// 5. Оператор << - сдвиг влево с заполнением нулями
x = 3      // x = 00000011
z = x << 2 // z = 00001100   => 12

x = 5      // x = 00000101
z = x << 1 // z = 00001010   => 10

// 6. Оператор >> - сдвиг вправо с заполнением старшим разрядом
x = 5      // x = 00000101
z = x >> 1 // z = 00000010   => 2

x = -5     // x = 11111010 => -5
z = x >> 1 // z = 11111101   => -3

// 7. Оператор >>> - сдвиг вправо без учета знака
x = -1      // x = 111...111 - 32 разряда
z = x >>> 1 // z = 011...111 => 2147483647

x = 5       // x = 000...0101 - 32 разряда
z = x >>> 1 // z = 000...0010 => 2

 

8. Строковый оператор +

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

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

Пример.

// Оператор обработки строк +
// 1. Конкатенация строк
var s1 = "Hello"
var s2 = "world"
var s3
s3 = s1 + ", " + s2 + "!" // s3 = "Hello, world!"

// 2. Обработка строки и числа
s3 = "25" + 25 // s3 = "2525"
s3 = 25.8 + "25.8" // s3 = "25.825.8"

 

9. Операторы взаимодействия чисел и строк -, *, /

Операторы (минус), * (умножение), / (деление) могут использовать в качестве операндов числа и строки одновременно. В этом случае строковое значение будет преобразовано в числовое и выполнена соответствующая операция.

Пример.

// Операторы обработки чисел и строк -, *, /
// 1. Оператор - (минус)
var str = "35"
var num = 50
var res = num - str // res = 50 - 35 = 15
res = "20" - 80 // res = -60

// 2. Оператор * (умножение)
str = "200"
num = 10
res = num * str   // res = 2000
res = "5" * 23.5 // res = 117.5

// 3. Оператор / (деление)
res = 50 / "50" // res = 1
res = "2.5" / 10 // res = 0.25

 


Связанные темы