Инструкция function

Часто используемые фрагменты программного кода целесообразно оформлять в виде функций. Такой фрагмент кода заключается в фигурные скобки, а перед ним пишется ключевое слово function, за которым следуют круглые скобки, обрамляющие список параметров.

Чтобы вызвать функцию в программе, следует написать выражение в следующем формате:

Имя_функции (параметры)

Если требуются параметры, то они указываются в круглых скобках через запятую. Функция может и не иметь параметров. В этом случае в круглых скобках ничего не указывается.

Инструкция function в JavaScript определяет функцию. Она имеет следующий синтаксис:

function имя_функции([арг1 [,арг2 [..., аргn]]]) {

Инструкции

}

Здесь имя_функции – это имя определяемой функции. Оно должно быть идентификатором, а не строкой или выражением. За именем функции следует заключенный в скобки список имен аргументов, разделенных запятыми. Эти идентификаторы могут использоваться в теле функции для ссылки на значения аргументов, переданных при вызове функции.

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

Определение функции создает новый объект функции и сохраняет объект в только что созданном свойстве с именем имя_функции. Вот несколько примеров определений функций:

function welcome() { alert("Добро пожаловать на мою домашнюю страницу!"); }

function print(msg) {

document.write(msg, "<br>");

}

function hypotenuse(x, y) {

return Math.sqrt(x*x + y*y);// Инструкция return описана далее

}

function factorial(n) {// Рекурсивная функция

if (n <= 1) return 1;

return n * factorial(n-1);

}

Определения функций обычно находятся в JavaScript-коде верхнего уровня.

Они также могут быть вложенными в определения других функций, но только на «верхнем уровне», т. е. определения функции не могут находиться внутри инструкций if, циклов while или любых других конструкций.

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

Инструкция return

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

return выражение;

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

Инструкция return прекращает исполнение функции, даже если в теле функции остались другие инструкции. Инструкция return используется для возвращения значения следующим образом:

function square(x) { return x*x; }

Инструкция return может также использоваться без выражения, тогда она просто прерывает исполнение функции, не возвращая значение. Например:

function display_object(obj) {

// Сначала убедимся в корректности нашего аргумента

// В случае некорректности пропускаем остаток функции

if (obj == null) return;

// Здесь находится оставшаяся часть функции...

}

Если в функции выполняется инструкция return без выражения или если выполнение функции прекращается по причине достижения конца тела функции, значение выражения вызова функции оказывается неопределенным (undefined).

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

Инструкция throw

Исключение – это сигнал, указывающий на возникновение какой-либо исключительной ситуации или ошибки. Генерация исключения (throw) – это способ просигнализировать о такой ошибке или исключительной ситуации.

Перехватить исключение (catch), значит, обработать его, т. е. предпринять действия, необходимые или подходящие для восстановления после исключения. В JavaScript исключения генерируются в тех случаях, когда возникает ошибка времени выполнения, тогда программа явно генерирует его с помощью инструкции throw. Исключения перехватываются с помощью инструкции try/catch/finally.

Инструкция throw имеет следующий синтаксис:

throw выражение;

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

function factorial(x) {

// Если входной аргумент не является допустимым,

// генерируем исключение!

if (x < 0) throw new Error("x не может быть отрицательным");

// В противном случае вычисляем значение и нормальным образом выходим

// из функции

for(var f = 1; x > 1; f *= x, x--) /* пустое тело цикла */ ;

Return f;

}

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

В обработчиках исключений используется конструкция catch инструкции try/catch/finally. Если блок кода, в котором возникло исключение, не имеет соответствующей конструкции catch, интерпретатор анализирует следующий внешний блок кода и проверяет, связан ли с ним обработчик исключений. Это продолжается до тех пор, пока обработчик не будет найден. Если исключение генерируется в функции, не содержащей инструкции try/catch/finally, предназначенной для его обработки, то исключение распространяется на код, вызвавший функцию. Так исключения распространяются по лексической структуре методов JavaScript вверх по стеку вызовов. Если обработчик исключения так и не будет найден, исключение рассматривается как ошибка и о ней сообщается пользователю.

Инструкция throw стандартизована в ECMAScript v3 и реализована в JavaScript 1.4. Класс Error и его подклассы также являются частью стандарта ECMAScript v3, но они не были реализованы до JavaScript 1.5.

Инструкция try/catch/finally

Инструкция try/catch/finally реализует механизм обработки исключений в JavaScript. Конструкция try в этой инструкции просто определяет блок кода, в котором обрабатываются исключения.

За блоком try следует конструкция catch с блоком инструкций, вызываемых, когда где-либо в блоке try возникает исключение.

За конструкцией catch следует блок finally, содержащий код зачистки, который гарантированно выполняется независимо от того, что происходит в блоке try. И блок catch, и блок finally не являются обязательными, однако после блока try должен обязательно присутствовать хотя бы один из них. Блоки try, catch и finally начинаются и заканчиваются фигурными скобками. Это обязательная часть синтаксиса и она не может быть опущена, даже если между ними содержится только одна инструкция. Как и инструкция throw, инструкция try/catch/finally стандартизована в ECMAScript v3 и реализована в JavaScript 1.4.

Следующий фрагмент иллюстрирует синтаксис и суть инструкции try/catch/finally. Обратите внимание, в частности, на то, что за ключевым словом catch следует идентификатор в скобках. Этот идентификатор похож на аргумент функции. Он присваивает имя локальной переменной, существующей только в теле блока catch. JavaScript присваивает этой переменной объект исключения или значение, указанное при генерации исключения:

try {

// Обычно этот код без сбоев работает от начала до конца.

// Но в какой-то момент в нем может генерироваться исключение

// либо непосредственно с помощью инструкции throw, либо косвенно

// вызовом метода, генерирующего исключение.

}

catch (e) {

// Инструкции в этом блоке выполняются тогда и только тогда, когда

// в блоке try генерируется исключение. Эти инструкции могут

// использовать локальную переменную e, ссылающуюся на объект Error

// или на другое значение, указанное в инструкции throw. Этот блок может

// либо каким-то образом обработать исключение, либо проигнорировать

// его, делая что-то другое, либо заново сгенерировать исключение

// с помощью инструкции throw.

}

finally {

// Этот блок содержит инструкции, которые выполняются всегда, независимо

// от того, что произошло в блоке try. Они выполняются, если блок try прерван:

// 1) нормальным образом, достигнув конца блока

// 2) из-за инструкции break, continue или return

// 3) с исключением, обработанным приведенным ранее блоком catch

// 4) с неперехваченным исключением, которое продолжает свое

// распространение на более высокие уровни

}

Пример:

try {

// Просим пользователя ввести число

var n = prompt("Введите положительное число", "");

var f = factorial(n); // Вычисляем факториал числа,

//предполагая, что входные данные корректны

alert(n + "! = " + f); // Показываем результат

}

catch (ex) {// Если введенные данные некорректны, мы попадем сюда

alert(ex); // Сообщаем пользователю об ошибке

}

Это пример инструкции try/catch без конструкции finally. Хотя finally используется не так часто, как catch, тем не менее иногда эта конструкция оказывается полезной. Рассмотрим ее поведение подробнее.

Блок finally гарантированно исполняется, если исполнялась хотя бы какая-то часть блока try, независимо от того, каким образом завершился код в блоке try. Эта возможность обычно используется для очистки после выполнения кода в предложении try.

В обычной ситуации управление доходит до конца блока try, а затем переходит к блоку finally, который выполняет всю необходимую очистку. Если управление вышло из блока try из-за инструкций return, continue или break, перед передачей управления в другое место кода исполняется блок finally.

Если в блоке try возникает исключение и имеется соответствующий блок catch для его обработки, управление сначала передается в блок catch, а затем – в блок finally. Если отсутствует локальный блок catch, то управление сначала передается в блок finally, а затем переходит на ближайший внешний блок catch, который может обработать исключение.

Если сам блок finally передает управление с помощью инструкции return, continue, break или throw или путем вызова метода, генерирующего исключение, незаконченная команда на передачу управления отменяется и выполняется новая.

Например, если блок finally генерирует исключение, это исключение заменяет любое сгенерированное исключение. Если в блоке finally имеется инструкция return, происходит нормальный выход из метода, даже если генерировалось исключение, которое не было обработано.

Инструкции try и finally могут использоваться вместе без конструкции catch.

В этом случае блок finally – это просто код зачистки, который будет гарантированно исполнен независимо от наличия в блоке try инструкции break, continue или return. Например, в следующем коде используется инструкция try/finally, гарантирующая, что счетчик цикла будет инкрементирован в конце каждой итерации, даже если итерация внезапно прервется инструкцией continue:

var i = 0, total = 0;

while(i < a.length) {

try {

if ((typeof a[i] != "number") || isNaN(a[i]))// Если это не число,

continue;// переходим к следующей итерации цикла.

total += a[i];// В противном случае добавляем число к общей сумме.

}

finally {

i++;// Всегда увеличиваем i, даже если ранее была инструкция continue.

}

}

Инструкция with

Инструкция with используется для временного изменения цепочки областей видимости. Она имеет следующий синтаксис:

With (объект)

Инструкция

Эта инструкция добавляет объект в начало цепочки областей видимости, исполняет инструкцию, а затем восстанавливает цепочку в ее первоначальном состоянии.

На практике инструкция with помогает значительно сократить объем набираемого текста. В клиентском языке JavaScript часто работают с глубоко вложенными иерархиями объектов. Например, для доступа к элементам HTML-формы придется пользоваться, например, такими выражениями:

frames[1].document.forms[0].address.value

Если надо обратиться к этой форме несколько раз, можно воспользоваться инструкцией with для добавления формы в цепочку областей видимости:

with(frames[1].document.forms[0]) {

// Здесь обращаемся к элементам формы непосредственно, например:

name.value = "";

address.value = "";

email.value = "";

}

Это сокращает объем текста программы – больше не надо указывать фрагмент frames[1].document.forms[0] перед каждым именем свойства. Этот объект представляет собой временную часть цепочки областей видимости и автоматически участвует в поиске, когда JavaScript требуется разрешить такой идентификатор, как address.

Несмотря на удобство этой конструкции в некоторых случаях, ее использование не приветствуется. JavaScript-код с инструкцией with сложен в оптимизации и поэтому может работать медленнее, чем эквивалентный код, написанный без нее. Кроме того, определения функций и инициализация переменных в теле инструкции with могут приводить к странным и трудным для понимания результатам. По этим причинам использовать инструкцию with не рекомендуется.

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

var form = frames[1].document.forms[0];

form.name.value = "";

form.address.value = "";

form.email.value = "";

Пустая инструкция

И наконец, последняя из допустимых в JavaScript инструкций – пустая инструкция. Она выглядит следующим образом:

;

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

for(i=0; i < a.length; a[i++] = 0);// Инициализация массива a

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

if ((a == 0) || (b == 0));// Ой! Эта строка ничего не делает...

o = null;// а эта строка выполняется всегда.

Когда пустая инструкция применяется специально, код желательно снабжать исчерпывающими комментариями. Например:

for(i=0; i < a.length; a[i++] = 0) ;/* Пустое тело цикла */

Глава 3 Объекты

Объекты представляют собой программные единицы, обладающие некоторыми свойствами. Об объекте мы можем судить по значениям его свойств и описанию того, как он функционирует. Программный код встроенных в JavaScript объектов нам недоступен. Следует научиться пользоваться объектами. Так, например, управление веб-страницами с помощью сценариев, написанных на JavaScript, заключается в использовании и изменении свойств объектов HTML-документа и самого браузера.

Встроенные объекты имеют фиксированные названия и свойства. Все свойства этих объектов разделяют на два вида: просто свойства и методы. Свойства аналогичны обычным переменным. Они имеют имена и значения. Некоторые свойства объектов доступны только для чтения. Это означает, что их значения нельзя изменять. Другие свойства доступны и для записи — их значения можно изменять с помощью оператора присвоения. Методы аналогичны функциям, они могут иметь параметры или не иметь их.

Чтобы узнать значение свойства объекта, необходимо указать имя этого объекта и имя свойства, отделив их друг от друга точкой: имя_объекта.свойство. Заметим, что объект может и не иметь свойств.

Мы можем заставить объект выполнить тот или иной присущий ему метод. В этом случае также говорят о применении метода к объекту. Синтаксис соответствующего выражения такой: имя_объекта.метод(параметры). Заметим, что объект может не иметь методов.

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

В JavaScript математические вычисления, сложная обработка строк и дат, а также создание массивов производятся с помощью соответствующих встроенных объектов. Для разработчиков веб-сайтов особенно важны объекты String (обработка строк), Array (массивы), Math (математические формулы и константы) и Date (работа с датами).

Встроенные объекты, как уже отмечалось, имеют фиксированные названия. Объекты с именами, совпадающими с их фиксированными названиями, называются статическими. Однако вы можете создать экземпляры (копии) статических объектов, присвоив им свои собственные имена. Экземпляры статических объектов являются объектами в вашей программе, которые наследуют от первых все их свойства и методы. Экземпляры объектов — это некоторые частные воплощения в программе соответствующих статических объектов. Вместе с тем вы можете использовать и статические объекты в чистом виде, не создавая никаких их копий.

Например, для формульных вычислений используется статический объект Math, а в случае массивов создаются экземпляры статического объекта Array, содержащие конкретные данные, к которым применимы все общие методы и свойства статического объекта Array.

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

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

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

Создание объектов

Самый простой способ создания объектов заключается во включении в программу литерала объекта.

Литерал объекта – это заключенный в фигурные скобки список свойств (пар «имя–значение»), разделенных запятыми. Имя каждого свойства может быть JavaScript-идентификатором или строкой, а значением любого свойства может быть константа или JavaScript-выражение.

Вот несколько примеров создания объектов:

var empty = {}; // Объект без свойств

var point = { x:0, y:0 };

var circle = { x:point.x, y:point.y+1, radius:2 };

var homer = {"name": "Homer Simpson","age": 34,"married": true,

"occupation": "plant operator",'email': "homer@example.com"};

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

С помощью оператора new можно создать другую разновидность объектов. За этим оператором должно быть указано имя функции-конструктора, выполняющей инициализацию свойств объекта. Например:

var a = new Array();// Создать пустой массив

var d = new Date();// Создать объект с текущими временем и датой

var r = new RegExp("javascript", "i");

// Создать объект регулярного выражения

Продемонстрированные здесь функции Array(), Date() и RegExp() являются встроенными конструкторами базового языка JavaScript.

Конструктор Object() создает пустой объект, как если бы использовался литерал {}.

Свойства объектов

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

Свойства объекта работают как переменные: в них можно сохранять значения и считывать их. Например:

var book=new Object();// Создаем объект. Сохраняем ссылку на него в переменной.

book.title = "Программирование на JavaScript"

// Устанавливаем свойство в объекте.

book.chapter1 = new Object();// Устанавливаем другие свойства.

book.chapter1.title = "Введение в JavaScript";

book.chapter1.pages = 11;

book.chapter2 = { title: "Лексическая структура", pages: 6 };

alert("Заголовок: " + book.title + "\n\t" + "Глава 1 " + book.chapter1.title

+ "\n\t" + "Глава 2 " + book.chapter2.title);

// Читаем значения некоторых свойств из объекта.

Важно обратить внимание на один момент в этом примере – новое свойство объекта можно добавить, просто присвоив этому свойству значение. Если переменные должны объявляться с помощью ключевого слова var, то для свойств объекта такой необходимости (и возможности) нет. К тому же после создания свойства объекта (в результате присваивания) значение свойства можно будет изменить в любой момент простым присваиванием ему нового значения:

book.title = "JavaScript: настольная книга"

Для удаления свойства объекта предназначен оператор delete: