SNK Software
Web Studio Монополия Metaproducts Утилиты Игры
Монополию Web Studio Библиотека
Вебмастер Дельфи Работа на ПК Самоучитель
Для PHP Для Delphi
Веб-дизайн Программирование Компьютеры Девайсы Заметки
SNK Software Индустрия hardware Индустрия software
О студии Портфолио Сопровождение сайтов

Новые материалы

Девайсы:
Сравнительный обзор Nokia Lumia 920 и HTC 8X
Девайсы:
Обзор Nokia Lumia 820 – смартфона на WP8
Вебмастеру:
Настройка Apache, PHP и MySQL для Linux-VPS
Вебмастеру:
VPS на домашнем ПК: настройка сети в VM VirtualBox и Debian
Вебмастеру:
VPS на домашнем ПК: устанавливаем Linux Debian 6
Вебмастеру:
VPS на домашнем ПК: установка VM VirtualBox
Работа на компьютере:
Иные возможности текстового процессора Word
Работа на компьютере:
Вставка объектов
Работа на компьютере:
Таблицы в Word
Работа на компьютере:
Печать и сохранение документов
Работа на компьютере:
Сноски, колонтитулы, оглавление и указатели в Word

Операторы JavaScript

В этой главе:

  1. Условный оператор if
  2. Семафор switch
  3. Оператор цикла for
  4. Операторы цикла while и do-while
  5. Операторы break и continue
  6. Операторы манипулирования объектами
  7. Операторы обработки исключений

Операторы – это основа для построения любой программы. На самом деле, любая программа на JavaScript состоит из множества операторов: каждое из рассмотренных нами выражений, заканчивающееся символом точки с запятой (;), также является оператором. Фактически, точка с запятой – это тоже оператор (в других языках он называется «пустым оператором»).

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

Программы на JavaScript могут состоять как из одиночных операторов, так и из программных блоков. Программный блок – это группа операторов, заключенных в фигурные скобки ({ и }).

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

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

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

К условным операторам в JavaScript относятся if…else и switch. Они служат для определения набора команд, которые должны быть выполнены в случае, если условие, заданное в таком операторе, истинно.

Оператор if выполняет проверку своего условия, после чего, если результатом будет истина (true), то выполняется блок операторов, следующих за условием. Если же результат – ложь (false), то в том случае, если предусмотрена часть else, будет выполнен блок операторов, определенных для else, в противном случае программа просто будет выполняться дальше. Например, если нам требуется вывести приветствие только в том случае, если значение переменной x больше 100, то при помощи условного оператора мы можем реализовать следующий код:

if (x>100) alert("Привет!");

В данном примере, когда условие истинно (т.е. z больше 100), выводится окно с текстом «Привет!». В противном случае ничего не выводится. Если же требуется что-то сообщить посетителю в любом случае, то можно предусмотреть часть else:

if (x>100) alert("Привет!"); else alert(x);

Теперь, если значение переменной x будет меньше 100, то вместо приветствия будет выведено окно со значением переменной x.

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

if (x>100) { alert("Привет!"); x = 0; }

Блок в данном случае объединяет 2 выражения-оператора. Если бы мы не использовали блок, то выражение «alert("Привет!");» относился бы к уловному оператору if, а второе выражение было бы выполнено в любом случае. Вообще же предпочтительно всегда использовать блоки для любых операторов, в том числе и условных – это позволяет более наглядно видеть то, что и когда должно быть выполнено. Например, одно и то же выражение можно записать как без блоков:

if (a!=b) alert("Не равно!") else alert("Равно");

А можно и с их использованием:

if (a!=b) { alert("Не равно!"); } else { alert("Равно"); };

Сравните эти записи: хотя для машины (интерпретатора JavaScript) обе они идентичны, человеку гораздо проще увидеть суть программы во втором случае, особенно если представить себе, что данный код является всего лишь фрагментом программы.

ВНИМАНИЕ
Обратите внимание на 2 вещи: прежде всего, здесь использованы отступы. При чтении кода программы они оказывают просто неоценимую помощь! Другой, тоже важный момент – наличие точки с запятой после окончания второго блока. Этот пустой оператор никак не влияет на выполнение, но при изучении исходного кода подскажет вам, что именно здесь заканчивается оператор if.

Условный оператор if имеет также сокращенную форму – в виде условной операции “? :”. Так, рассмотренной выше пример можно записать в таком вот виде:

(a!=b) ? alert("Не равно!") : alert("Равно");

Кроме того, оператор if может быть вложенным (как, впрочем, и любой другой оператор языка JavaScript). Например, если нам надо проверить определенное условие (скажем, является ли значение переменной x больше 200) только в том случае, если другое условие верно. В таком случае один оператор if вкладывается в другой:

if (x>100) { if (x>200) { alert("Большой привет!"); } else { alert("Привет!"); }; };

Здесь сначала проверяется, действительно ли x больше 100, и если такое условие верно, то значение x проверяется вновь, но уже на предмет того, больше ли оно, чем 200 или нет. Если второе условие верно, то при помощи alert выводится фраза «Большой привет!», а если нет (блок else для вложенного if), то выводится «Привет!». Ну а в том случае, если не верно первое условие, что ничего не выводится, поскольку весь блок, вложенный во «внешний» оператор if, будет проигнорирован.

Наконец, допустимо множественно последовательное сравнение при помощи комбинации нескольких операторов if-else. Для этого непосредственно после else помещают следующий оператор if:

if (a>b) { alert("Больше"); } else if (a<b) { alert("Меньше"); } else if (a==b) { alert("Равно"); };

В данном случае сначала проверяется условие (a>b), и если оно истинно, то выводится сообщение «Больше» и дальнейшее выполнение оператора завершается. Если же значением сравнения окажется ложь, то выполнение передается следующему оператору if, расположенному после else, в котором проверяется условие (a<b). Если оно окажется верным, то будет выведено сообщение «Меньше», иначе состоится проверка последнего значения – на равенство (a==b) и при условии совпадения будет выведено сообщение «Равно». В общем-то, поскольку для данного примера иного варианта быть не может, (т.е. если не больше и не меньше, значит равно), то последнее условие можно было бы и опустить.

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

if (x==1) { y=100; } else if (x==2) { y=150; } else if (x==3) { y=50; } else if (x==4) { y=200; } else { y=0; };

В данном случае значение переменной x будет сравниваться с 1, 2, 3, 4, и в зависимости от того, какое условие окажется верным, переменная y получит то или иное значение. При этом если значение x не окажется ни одним из перечисленных, то будет выполнено последнее выражение, в котором переменной y будет присвоено значение 0.

Семафор switch

Только что мы рассмотрели пример использования условного оператора if для проверки на множество условий. Однако для этих целей в JavaScript имеется специализированный оператор – switch. Оператор switch (семафор, переключатель) выполняет тот блок операторов, метка которого соответствует значению выражения переключателя. Он имеет следующий синтаксис:

switch (выражение) { case метка: выражение; break; ... default: выражение; }

Выполнение оператора switch начинается с вычисления значения переключателя (т.е. выражения, находящегося в скобках сразу после ключевого слова switch). После этого управление передается блоку операторов, следующих за меткой, совпадающей со значением. Если таковой не находится, то управление будет передано специальной метке – default (если она имеется). Так, последний пример с if можно представить с использованием семафора следующим образом:

switch (x) { case 1: y=100; break; case 2: y=150; break; case 3: y=50; break; case 4: y=200; break; default: y=0; }

В этом примере, когда переменная x имеет значения от 1 до 4, для нее предусмотрены определенные действия, если же она не впишется ни в одно из предусмотренных значений, то будет выполнено выражение, указанное в части default, а если бы таковой не оказалось, то ничего не было бы выполнено.

Что касается оператора break, то он используется для того, чтобы указать интерпретатору, что после того, как будет найдено подходящее условие, а написанное для него выражение – выполнено, следует завершить выполнение оператора. В противном случае (если после выражения не указать break), то будет выполнены все последующие условия – до тех пор, пока не попадется break или не будет достигнут конец данного оператора switch.

Наконец, подобно случаю с if, для семафора так же полезно использовать блоки, поскольку это улучшает простоту восприятия исходного кода программы:

switch (x) { case 1: { y=100; break; } case 2: { y=150; break; } ... };

Следует отметить, что в качестве значений, оцениваемых при помощи оператора switch, могут быть не только числа, но и строки. Этим JavaScript в лучшую сторону отличается от некоторых других языков программирования, имеющих ограничения на оцениваемые при помощи семафора типы данных.

Оператор цикла for

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

for ([начальное значение]; [условие]; [выражение приращения]) ТелоЦикла;

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

for (;;);

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

for (var i=0; i<10; i++) ;

Здесь сначала инициализируется переменная цикла (i), которой назначается значение 0, после чего определяется условие, которое разрешает дальнейшие итерации цикла до тех пор, пока является истинным, и, наконец, задается приращение переменной цикла. Данный цикл будет выполнен 10 раз – до тех пор, пока значение переменной i (счетчика цикла) не достигнет 10 и не приведет к тому, что условие станет ложью.

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

  1. Инициализируется значение переменной-счетчика
  2. Проверяется условие. Если оно оказывается ложью, цикл прекращает работу, если нет – то он выполняется
  3. Происходит собственно выполнение тела цикла
  4. Выполняется приращение счетчика и происходит возврат на этап 2.

Соответственно, если условие изначально ложно, то цикл не будет выполнен ни разу. А если условие задано неверно (например, для рассматриваемого примера было бы задано условие i=>0), то цикл будет выполняться бесконечно.

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

for (var i=0; i<10; i++) MyArray[i+1]=i+1;

В данном случае элементам массива MyArray последовательно назначаются значения от 1 до 10. Собственно говоря, учитывая гибкость языка JavaScript, можно указать действие по заполнению непосредственно в выражении приращения:

for (var i=0; i<10; MyArray[i++]=i);

В данном случае значение счетчика (переменной i) все равно будет увеличиваться на 1 при каждой итерации цикла, при этом попутно будет происходить и заполнение массива.

Поскольку для циклов требуется наличие хотя бы одного оператора в теле цикла, то в случаях, подобных рассмотренному выше, используется пустой оператор. А если используется более одного оператора, то блок операторов должен быть заключен в фигурные скобки.

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

Рассмотрим цикл for с отрицательным приращением на примере вычисления математического факториала (последовательное произведение всех целых чисел от 1 до самого числа). Для этого нам понадобится следующий цикл:

var num; for (var rez=1; num; num--) { rez=rez*num; };

Здесь в начальном условии определена переменная, в которой будет храниться вычисляемое значение (rez) и ей присвоено значение 1. В качестве условия указана другая переменная (num), представляющая собой число, для которого и будет вычисляться факториал. Поскольку нам надо будет прекратить выполнение цикла, как только num достигнет 0, то мы указали просто переменную num: истиной она будет считаться только до тех пор, пока ее значение отличается от нуля. Наконец, в конце каждого цикла будет происходить декрементация переменной num.

В итоге, если переменной num присвоить значение 5, то после прохождения цикла переменная rez получит значение 120. Хотя в результате работы такого цикла получится выполнение как бы наоборот (т.е. не вместо 1*2*3*4*5, на самом деле выполняется 5*4*3*2*1), это никак не помешает получить верный результат.

Еще одним вариантом цикла for является его использование совместоно с оператором in, применяемого для обхода свойств объекта (или ассоциативного массива). Очень часто его используют в JavaScript в качестве аналога оператора foreach в PHP (так же имеется в VB, C# и в последних версиях Delphi). Такое его использование будет рассмотрено в параграфе "Операторы манипулирования объектами".

Операторы цикла while и do-while

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

while (условие) { Тело цикла }

В простейшем случае использование цикла while может сводиться к следующему:

while (a>5) { a--; }

Здесь переменная a будет уменьшаться при каждой итерации до тех пор, пока условие не станет ложью.

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

for ( ; a>5 ; ) { a--; }

Подобно тому, как у цикла for, сначала происходит оценка выражения, указанного в качестве условия. И если заданное условие неверно изначально, то цикл while не будет выполнен ни разу – точно так же, как и for. Поэтому в тех случаях, когда требуется выполнить операторы цикла хотя бы один раз, можно использовать оператор do…while. Этот оператор выглядит как перевернутый цикл while:

do { Тело цикла } while (условие)

Когда интерпретатор JavaScript доходит до оператора do…while, то сначала выполняются операторы тела цикла, и уже потом – проверяется условие. Если условие истинно, то цикл повторяется, и так до тех пор, пока условие не станет ложным. Это может быть полезным во многих случаях – например, когда надо в любом случае произвести какую-либо операцию, вне зависимости от того, что задано в условии. Конечно, можно было бы обойти это условие, например, несколько изменив условие цикла или продублировав «обязательный» код перед циклом, но, в конечном итоге, оба цикла while служат, прежде всего, для удобства разработчиков.

ПРИМЕЧАНИЕ
Изначально в языке JavaScript (и по стандарту ECMA-262) были определены только циклы for и while. После того, как JavaScript 1.2 Netscape добавила цикл do…while, JavaScript стал поддерживать все основные виды циклов, встречающихся в языках структурного программирования.

Таким образом, мы рассмотрели все 3 оператора JavaScript, позволяющие выполнять циклы (на самом деле, имеется еще один оператор – for-in – вариант цикла for для объектов, но о нем поговорим чуть позже).

Операторы break и continue

Завершение работы цикла определяется его условием. Но нередко случаются такие ситуации, когда цикл требуется завершить досрочно, или выполнить только часть операторов в теле цикла, перейдя к его следующей итерации. В таких случаях используют операторы break и continue совместно с условным оператором.

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

do { i++; y++; if (i>100) break; } while (y<50);

Здесь мы определили цикл, который будет завершен либо после того, как значение переменной y достигнет 50 (что задано в самом условии цикла), либо если значение переменно x превысит указанное в условии if значение 100 – здесь как раз будет задействован оператор break.

Иногда бывает необходимо перейти к следующему шагу цикла досрочно, пропустив часть операторов. Для этих целей используют оператор continue. В отличие от break, этот оператор не завершает цикл, а заставляет интерпретатор досрочно перейти к новой проверке условия цикла. Рассмотрим эту ситуацию на примере. Допустим, что нам надо получить список чисел, на которые число 100 делится без остатка:

var i=0, j=100; while (i<j) { i++; if (j%i != 0) continue; document.writeln(i); }

Для этого мы определили цикл, в котором при каждой итерации делитель увеличивается на единицу, после чего производится операция «остаток от деления». Если остаток равен нулю, то интерпретатор переходит к следующему оператору в теле цикла, который выводит число в окно браузера, в противном случае выполняется оператор continue и начинается новый шаг цикла.

Следует отметить, что операторы break и continue могут использоваться совместно с оператором-меткой (label). Метки – это специальные идентификаторы, которые указывают на определенную точку входа в программе. Например, если при срабатывании оператора continue надо передать управление в какое-либо иное место программы, а не в начало цикла, то можно записать так:

label5: for (var i=0; i<10; i++) { if (i==5) continue label5; }

Здесь при достижении переменной i значения 5 выполнение программы переносится на точку, следующую вслед за меткой «label5». На самом деле, сочетать операторы break и continue с метками аналогично по своему принципу использованию оператора безусловного перехода goto, которого нет в JavaScript, но который вам, скорее всего, известен, если вы когда-либо изучали BASIC. В любом случае использование goto и меток – признак дурного тона в программировании.

Операторы манипулирования объектами

Для манипулирования объектами JavaScript предоставляет в наше распоряжение два оператора – with и for…in.

Оператор with определяет объект, к которому будут обращаться вложенные в него операторы. Он имеет следующий синтаксис:

with (имя объекта) { операторы }

Этот оператор позволяет экономить ваше время и существенно сокращать размеры программы, когда целый блок операторов обращается к одному объекту. Например, вывод текста в документ HTML можно написать так:

document.open(); document.writeln("Строка1"); document.writeln("Строка2"); document.close();

Но с использованием оператора with запись становится гораздо лаконичнее:

with (document) { open(); writeln("Строка1"); writeln("Строка2"); close(); }

Оператор for…in является специальной разновидностью цикла for и используется для организации цикла по всем свойствам объекта. Его синтаксис: for (Индекс in ИмяОбъекта) { операторы }

Индексная переменная предназначена для хранения текущего имени свойства заданного объекта. Использование оператора for…in может быть самым разным, одно из них – изучение объектной модели браузера. Для этого создадим небольшой сценарий, который выведет список всех свойств, скажем, объекта window в виде нумерованного списка: document.writeln('<ol>'); for (i in window) { document.writeln('<li>'+i+'</li>'); } document.writeln('</ol>'); В зависимости от того, в каком браузере вы запустите этот скрипт, результат будет разный. Например, MSIE 6 выводит такой список из 37 свойств, Opera 7.2 – из 43, а Firefox 1.0 – свыше 80, а Firefox 5 - все 100. Обратитесь к примеру for_in.html, в котором рассматривается применение этого оператора для нескольких объектов.

Еще одно применение for...in - это эмуляция оператора foreach, отсутствующего в JavaScript. Например, для обхода всех значений в ассоциативном массиве можно воспользоваться таким методом:

arr = new Object; //инициализируем массив как объект arr["a"]=1; arr["b"]=2; for (var key in arr) { var val = arr[key]; //в переменной val получаем значение alert(val); }

Операторы обработки исключений

Начиная с версии 1.4, в JavaScript появилась такой полезный механизм, как обработка исключительных ситуаций, или, говоря иными словами – ошибок времени выполнения. Такие ошибки могут возникать, например, в таких случаях, когда программа обращается к несуществующему элементу массива, при попытке деления на 0 и т.д. Для этих целей определены операторы throw и try…catch.

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

throw "Ошибка данных!"; throw 404;

Допустимо так же создавать собственные объекты для работы с исключительными ситуациями и использовать их в качестве значения для оператора throw:

// определяем объект-исключительную ситуацию function myErrorObject(id, msg) { this.errorId=id; this.message=msg; this.name="myErrorObject" } // создаем экземпляр объекта myError = new myErrorObject(5,"Значение вне допустимого диапазона!"); // вызываем исключение throw myError;

Что касается практического использования вызова исключительных ситуаций, то они могут применяться, например, для прерывания работы сценария или для выполнения действия для назначения допустимых значений по умолчанию и т.д. Допустим, нам надо проверить переменную на допустимое значение, и если оно вне допустимого диапазона, – то присвоить ей значение по умолчанию и проинформировать пользователя об ошибке. В таком случае можно прибегнуть к оператору try…catch, вложив в него код для проверки переменной, как это показано в листинге 4.2.

Листинг 4.2. Обработка исключений

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"> <html> <head> <title>Обработка исключений</title> </head> <body> <script type="text/javascript"><!-- function myErrorObject(id, msg) { this.errorId=id; this.message=msg; this.name="myErrorObject" } var a=5; // переменная для проверки try { if (a < 10) { document.write(a); } else { myError = new myErrorObject(5,"Значение вне допустимого диапазона!"); throw myError; } } catch (e) { a=0; // присваиваем переменной a значение по умолчанию alert("Ошибка "+e.errorId+": "+e.message); // выводим сообщение об ошибке } //--></script> </body> </html>

Для оператора try…catch предусмотрен еще один блок – finally. Он используется для того, чтобы определить код, который должен быть выполнен в любом случае, вне зависимости от того, произошла или нет ошибка перед ним. Например, мы можем выводить в документ значения некоторых переменных, причем заведомо неясно, содержат ли все они допустимые значения (например, не окажется ли NULL). В таком случае блок вывода вкладывается в блок try, а функция закрытия документа – в блок finally:

try { document.open(); document.write(x); document.write(z/y); } finally document.close(); }

В данном случае, вне зависимости от того, что произойдет в процессе работы фрагмента кода, заключенного в блок try, поток записи в документ будет закрыт.

Остается добавить, что использование операторов обработки исключительных ситуаций будет работать в браузерах, поддерживающих JavaScript 1.5 и выше. На сегодня это все версии встречающихся программ просмотра интернета, но что касается Gecko-браузеров, то в них поддерживается еще и «фирменное» расширение JavaScript 1.5, позволяющее вкладывать несколько блоков try друг в друга. При этом, если вложенный во внешний блок try…catch оператор try может иметь собственного блока catch – в таком случае будет использован блок catch от внешнего оператора.

2011-07-27 // Есть вопросы, предложения, замечания? Вы можете обсудить это на форуме !

Избранное

SNK GSCP
SNK GSCP - новая библиотека для PHP 5!
Web Studio
Web Studio и Visual Workshop
Библиотека:
Стандарты на web-технологии
Монополия
Монополия Android
Загрузки:
скачать программы
Продукция:
программы и книги
Техподдержка / Связаться с нами
Copyright © 1999-2013 SNK. Все права защищены.
При использовании материалов с сайта ссылка на источник обязательна.
Рейтинг@Mail.ru