Без операторов любой язык программирования бесполезен. Именно с помощью различных операторов производятся все расчёты, действия программ. В JavaScript не так много операторов, как в других языках высокого уровня. В JavaScript есть основные правила, которые должны соблюдаться для любых операторов. Если в одной строке кода записаны несколько выражений (законченных последовательностей вычислений, расчётов), то они должны быть разделены точкой с запятой (знак ";"), а если в строке только одно выражение, то разделителем служит возврат каретки (Enter).

a = b + c; d = "if (a > 0) {round(a) ++}"; eval(d)
alert(a)
Оператор присваивания

Служит для присваивания значений переменным. Слева от этого оператора пишется имя переменной, которой присваивается значение, находящееся справа от оператора. Знаком оператора присваивания служит "=". Если этот знак равенства пишется в каком-либо условии (например, оператора if), то он служит оператором сравнения и никаких значений не присваивает.

a = "34"
b = 5
c = a + b /* в результате получится строка "345", т.к. значение
переменной a является не числом, а строкой. */
Арифметические операторы

Простые операции сложения, вычитания, умножения и т.д. в языке JavaScript применимы к числовым и логическим типам переменных. Знак плюс ("+") в строках осуществляет конкатенацию (приписывание второй строки к концу первой строки). Если плюсовать к строке число или логическое значение, то оно будет интерпретироваться, как строка и получится конкатенация.

+      сложение                                    x + y
-      вычитание                                   x - y
*      умножение                                   x * y
/      деление                                     x / y
%      деление по модулю (возвращает остаток)      x % y
++     увеличение значения на единицу              x++
--     уменьшение значения на единицу              x--

Как уже говорилось раньше, данные логического типа при арифметических операциях над ними просто преобразуются в числовые данные: true в 1, false в 0. После этого вычисления над ними производятся как для обычных чисел. Операции над логическими данными такие-же, как и для числовых. Вот некоторые примеры:

a   b  a+b           a   b  a*b
0   0   0            0   0   0
0   1   1            0   1   0
1   0   1            1   0   0
1   1   2            1   1   1

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

true + true      // в результате 2
true * false     // в результате 0
3 / true         // в результате 3
"7" + true       // в результате "7true"
"Next" * true    // в результате NaN, т.е. расчёт не возможен
"7" * true       // в результате 7
true / 5         // в результате 0.2
Дополнительные операторы присваивания

Эти операторы служат для упрощения записи простых арифметических операторов.

оператор          пример           эквивалент
   +=              a+=b            a = a + b
   -=              a-=b            a = a - b
   *=              a*=b            a = a * b
   /=              a/=b            a = a / b
   %=              a%=b            a = a % b
Операторы сравнения

Эти операторы необходимы при задании различных условий. Операторы сравнения возвращают логические значения true или false. То есть любое выражение может или выполняться или нет, другого не дано. Числовые данные сравниваются по обычным правилам арифметики. Логические значения переводятся в числовые (true в 1, false в 0) и сравниваются как числа. А вот строки сравниваются по сумме ASCII-кодов содержащихся в строках символов. Если один из двух сравниваемых операндов имеет строковый тип, то и второй операнд тоже переводится в строку. Если одно из операндов - логическое значение, а другое - строка, пустая или содержащая только пробелы, операнды будут приведены к числовому значению. Такая строка будет значить 0, а если строка не пуста - в любой операции сравнения возвратится значение false, а с оператором "!=" - true.

==            равно                a == b
!=            не равно             a != b
>             больше               a > b
<             меньше               a < b
>=            не меньше            a >= b
<=            не больше            a <= b
Логические операторы

Они нужны для создания более сложных условий, нежели простые операции сравнения. Логические операторы возвращают логические значения true или false. Часто нужно проверить, является ли строка пустой (не содержащей ни одного знака, только пустые кавычки). Допустим, переменная z = "" (пустой стороке), тогда условие !z истинно, а просто z - ложно. И всё наоборот, если строка z не пуста.

!         не          !a
&&        и           a && b
||        или         a || b

Таблица истинности для двух логических значений:

  a       b          a && b         a || b
false   false        false          false
false   true         false          true
true    false        false          true
true    true         true           true

Примеры принципов действия логических операций:

x = true || 2*2==1            // результат true
y = 1/3<=0.3 && 2*3==6     // результат false
Оператор условия if

Данный оператор используют в том случае, когда нужно проверить какое-либо условие. Поэтому он и называется условным оператором. Работа оператора заключается в следующем. Если условие в скобках после слова if истинно, то выполняются операторы, находящиеся в фигурных скобках после слова if. Если условие ложно, то выполняются операторы в фигурных скобках после слова else. Если в фигурных скобках только один оператор, то их можно не писать. Оператор if может возвращать значение последнего выполненного выражения во внутреннем коде.

if (document.all) alert('В документе есть содержимое')
else alert('Документ пуст, не содежит ни одного элемента')

Если надо выполнить только один оператор, тогда фигурные скобки можно не писать:

if (a > 0 && b >= 0) { b = log(b); alert(b / a) }
else alert('Решений нет')

Фигурные скобки можно расположить как угодно, на вкус программиста:

if (clr) { my.style.fontWeight = '700'; my.style.color = 'maroon' }
// сработает, если clr имеет значение true.
else myfunction2()

if (event.srcElement.tagName == 'P') {
  mytext.style.fontWeight = '700'; mytext.style.color = 'maroon'
  }
else myfunction2()

if (event.srcElement.tagName == 'P')
{
mytext.style.fontWeight = '700'; mytext.style.color = 'maroon'
}
else myfunction2()

Часть синтаксиса условного оператора, начинающаяся со слова else не обязательна. В таком случае скрипт проверит условие, если оно истинно, выполнит/не выполнит операторы после слова if и перейдёт на следующий код.

if (form[2].slct[0].checked) mytext.style.fontStyle = 'italic'

Условные операторы можно вкладывать друг в друга. Вот пример такого вкладывания:

if (document.all) // проверяется, а не пуст ли документ
{
   if (event.srcElement.className == 'toplinks')
   {
   mylink.src = 'http://www.ya.ru/'        // подмена цели
   mylink2.src = 'http://www.rambler.ru/'
   }
}
else window.open('http://www.dronn.ru/alternate/', 'My Site')
Оператор выбора switch

Если нужно проверить несколько вариантов переменной или выражения, необходимо использовать оператор switch. Действует он так. После слова switch в круглых скобках пишется выражение (любое: логическое, строковое, числовое...), которое имеет какое-то значение (true/false для логических, строки для строковых типов, числовые значения для числовых типов выражений). После слова case пишется какое-либо значение. Если значение выражения после слова switch совпадает со значением в каком-нибудь из case'ков, то, выполняется код, заданный в совпавшем case'ке. Есть одно "но": если после case, значение которого совпало, не стоит слова break, то выполняются коды и всех последующих case'ков до слова break. Вот так. Встретив после элемента case (значение которого совпало со значением выражения после switch) ключевое слово break, скрипт, выполнив только код этого case, закончит выполнять данный оператор switch и перейдёт к следующему оператору. Интерпретатор сверху вниз сравнивает каждое значение case, и, пока не найдено верное значение, break'и не действуют. Операторы после слова default выполняются, если интерпретатор не нашёл ни одного верного значения case.

z = 2
switch (z) // проверяются различные значения переменной z
{
case 1: alert('z равно одному')
break
case 2: alert('z равно двум') // этот код выполнится, т.к.
break                         // мы задали значение переменной z = 2.
case 3: alert('z равно трём')
break
default: alert('Чёрт его знает, какое сейчас значение переменной z')
break
}
Этот пример (почти)

Ключевые слова break можно опустить или писать только после некоторых элементов case, не всех. Строку defaul тоже можно убрать, если она не нужна. Фигурные скобки можете ставить как вам нравится, это дело вкуса. Оператор switch может возвращать значение последнего выполненного выражения, конечно, если ему приравнять какую-нибудь переменную.

text = 'Hello'
switch (text)
{
case '': alert('Значение переменной text равно пустой строке')
case 'Hello': alert('Значение переменной text равно "Hello"')
     // этот код и код ниже выполнятся, т.к. break'ов мы здесь не написали
case 'Hello! World': alert('Значение text  равно "Hello! World"')
}
Оператор for

Это цикл со счётчиком циклов прохождения. Его обычно используют в случаях, когда необходимо проделать одну и ту же операцию определённое количество раз. Параметры в квадратных скобках не обязательны. Начальное выражение выполняется только один раз перед запуском цикла. Пока выполнено условие, цикл повторяется. Выражение обновления выполняется каждый раз после прохождения тела цикла (кода). Оператор for, как и все операторы цикла и операторы условия (if, switch), может возвращать значение последнего выполненного выражения.

for ([начальное_выражение]; [условие]; [выражение_обновления])
{
код
}

Чтобы создать счётчик, надо задать начальное значение переменной счётчика (например, i) и условие переменной счётчика. Например, в следующем примере цикл повторится 10 раз (повторения тела цикла называются итерациями). Находим сумму всех целых чисел от 1 до 10:

x = 1
for (i = 1; i <= 10; i++)
{
x = x + i
}
Пример оператора for

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

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

for ([начальное_выражение]; [условие]; [выражение_обновления])
{
код
if (вторичное_условие)
   {
   код
   break // или continue
   }
код
}
Оператор while

Подходит для многократного выполнения кода при каком-либо условии. Сначала интерпретатор проверяет условие. Если условие истинно, выполняется тело цикла. Потом снова проверяется условие... Вобщем, пока условие истинно, цикл выполняется. В теле цикла не забывайте изменять переменную, корую интерпретатор проверяет в условии. Иначе цикл будет повторяться бесконечно, браузер зависнет. Во вторичном условии (смотрите предыдущий оператор) можно использовать операторы прерывания continue и break. Оператор while может возвращать значение последнего выполненного выражения в теле цикла.

while (условие)
{
код
}

В следующем примере найдём сумму всех чётных целых чисел от 2 до 100. Переменная x будет хранить поочерёдно все чётные значения от 2 до 100. Переменная z будет хранить результат.

x = 2
z = x
while (x <= 100)
{
z = z + x
x = x + 2
}
Пример оператора while
Оператор с постусловием do... while...

Этот оператор очень похож на предыдущий (while) и принципиально отличается от него только тем, что в нём сначала выполняются операторы тела цикла, а потом проверяется истинность условия. Таким образом, независимо от того, истинно или ложно условие, одна итерация (повторение тела цикла) произойдёт. В остальном операторы do.. while... и while одинаковы. Оператор do... while... тоже может возвращать значение последнего выполненного в теле цикла выражения.

do
{
код
}
while (условие)

В следующем примере пока вы не просмотрите все 5 цифр, цикл будет вас мучить:

var x = 0
do
{
  ++x
  alert(x)
}
while (x < 5)
Примерчик с do... while...
Приоритеты операторов

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

круглые скобки                               ()
отрицание                                    -
логическое отрицание                         !
инкремент                                    ++
декремент                                    --
умножение                                    *
деление                                      /
деление по модулю                            %
сложение                                     +
вычитание                                    -
меньше                                       <
не больше                                    <=
больше                                       >
не меньше                                    >=
равенство                                    ==
неравенство                                  !=
логическое И                                 &&
логическое ИЛИ                               ||
условное выражение                           ?
операторы присваивания                       =
                                             +=
                                             -=
                                             *=
                                             /=
                                             %=
запятая - разделитель параметров             ,