javascript-programming-tutorial/JS_07_script_operators.html at master · paulinelemenkova/javascript-programming-tutorial · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
<!DOCTYPE html>
<html>

    <head>
        <meta charset="utf-8">
    </head>

    <body>
        <script>
            "use strict";
            // https://learn.javascript.ru/operators#slozhenie-strok-binarnyy
            var x = 1;

            x = -x;
            alert( x ); // -1, применили унарный минус

            var x = 1, y = 3;
            alert( y - x ); // 2, бинарный минус

            // если бинарный оператор '+' применить к строкам, то он их объединяет в одну, т.е. плюс производит конкатенацию (сложение) строк.
            var a = "моя" + "строка";
            alert( a ); // моястрока

            // Если хотя бы один аргумент является строкой, то второй будет также преобразован к строке! Это приведение к строке – особенность исключительно бинарного оператора "+". Остальные арифметические операторы работают только с числами
            alert( '1' + 2 ); // "12"
            alert( 2 + '1' ); // "21"

            //сначала выполнятся унарные плюсы, приведут строки к числам, а затем – бинарный '+' их сложит. унарные плюсы выполнились до бинарного сложения, т.к. дело в их приоритете.
            var apples = "2";
            var oranges = "3";
            alert( +apples + +oranges ); // 5, число

            // оператор присваивания =. У него – один из самых низких приоритетов? поэтому, когда переменную ч-л присваивают, например, x = 2 * 2 + 1 сначала выполнится арифметика, а уже затем – произойдёт присваивание =.
            var x = 2 * 2 + 1;
            alert( x ); // 5

            // присваивание по цепочке: работает справа-налево, то есть сначала вычислятся самое правое выражение 2+2, присвоится в c, затем выполнится b = c и, наконец, a = b.
            var a, b, c;
            a = b = c = 2 + 2;
            alert( a ); // 4
            alert( b ); // 4
            alert( c ); // 4

            // Вызов x = выражение записывает выражение в x, а затем возвращает его. Благодаря этому присваивание можно использовать как часть более сложного выражения:
            var a = 1;
            var b = 2;
            var c = 3 - (a = b + 1);
            alert( a ); // 3
            alert( c ); // 0

            // Оператор взятия остатка % никакого отношения к процентам не имеет. Его результат a % b – это остаток от деления a на b.
            alert( 5 % 2 ); // 1, остаток от деления 5 на 2
            alert( 8 % 3 ); // 2, остаток от деления 8 на 3
            alert( 6 % 3 ); // 0, остаток от деления 6 на 3

            // Инкремент/декремент: ++, --. Инкремент/декремент можно применить только к переменной. Код 5++ даст ошибку. Вызывать эти операторы можно не только после, но и перед переменной: i++ (называется «постфиксная форма») или ++i («префиксная форма»). Обе эти формы записи делают одно и то же: увеличивают на 1.
            var i = 2;
            i++;      // более короткая запись для i = i + 1.
            alert(i); // 3

            var i = 2;
            i--;      // более короткая запись для i = i - 1.
            alert(i); // 1

            //  разница
            //  Префиксная форма: вызов ++i увеличит переменную, а ЗАТЕМ вернёт ее значение в a. Так что в a попадёт значение i после увеличения.
            var i = 1;
            var a = ++i; // (*)
            alert(a); // 2

            // Постфиксная форма i++ отличается от префиксной ++i тем, что возвращает старое значение, бывшее до увеличения. В примере ниже в a попадёт старое значение i, равное 1:
            var i = 1;
            var a = i++; // (*)
            alert(a); // 1

            // Если результат оператора не используется, а нужно только увеличить/уменьшить переменную – без разницы, какую форму использовать:
            var i = 0;
            i++;
            ++i;
            alert( i ); // 2

            // Если хочется тут же использовать результат, то нужна префиксная форма:
            var i = 0;
            alert( ++i ); // 1

            // Если нужно увеличить, но нужно значение переменной до увеличения – постфиксная форма:
            var i = 0;
            alert( i++ ); // 0

            // Инкремент/декремент имеет более высокий приоритет и выполняется раньше, чем арифметические операции:
            var i = 1;
            alert( 2 * ++i ); // 4

            // для быстрого вертикального чтения кода: Три строки, по одному действию в каждой – длиннее, зато нагляднее:
            var i = 1;
            alert( 2 * i );
            i++;

            // применить оператор к переменной и сохранить результат в ней же
            var n = 2;
            n += 5; // теперь n=7 (работает как n = n + 5)
            n *= 2; // теперь n=14 (работает как n = n * 2)
            alert( n ); // 14

            // Оператор запятая. Один из самых необычных операторов – запятая ','. Запятая – единственный оператор, приоритет которого ниже присваивания. В выражении a = (5,6) для явного задания приоритета использованы скобки, иначе оператор '=' выполнился бы до запятой ',', получилось бы (a=5), 6.
            var a = (5, 6);
            alert( a );

            ////////////
            var a = 1, b = 1, c, d;

            // префиксная форма сначала увеличивает a до 2, а потом возвращает
            c = ++a; alert(c); // 2

            // постфиксная форма увеличивает, но возвращает старое значение
            d = b++; alert(d); // 1

            // сначала увеличили a до 3, потом использовали в арифметике
            c = (2+ ++a); alert(c); // 5

            // увеличили b до 3, но в этом выражении оставили старое значение
            d = (2+ b++); alert(d); // 4

            // каждую переменную увеличили по 2 раза
            alert(a); // 3
            alert(b); // 3

        </script>
    </body>

</html>