Если у вас возникли сложности с курсовой, контрольной, дипломной, рефератом, отчетом по практике, научно-исследовательской и любой другой работой - мы готовы помочь.
Предоплата всего
Подписываем
JavaScript — это объектно-ориентированный язык программирования, предназначенный для написания сценариев, работающих как на стороне клиента, так и на стороне сервера. Поэтому он не является "полноценным" языком программирования, а ориентирован на использование возможностей той среды, в которой сценарии исполняются.
Веб-обозреватель, работающий на компьютере-клиенте, обеспечивает среду, в которой JavaScript имеет доступ к объектам, которые представляют собой окна, меню, диалоги, текстовые области, фреймы, куки и ввод-вывод в Веб-страницу. Кроме того, обозреватель позволяет присоединить сценарии на языке JavaScript к таким событиям, как загрузка и выгрузка страниц и графических образов, нажатие клавиш и движение мыши, выбор текста и пересылка форм. При этом программный код сценариев только реагирует на события и поэтому не нуждается в главной программе. Набор объектов, предоставляемых обозревателем, известен под названием Document Object Model (DOM).
JavaScript — это язык программирования, основанный на объектах: и языковые средства, и возможности среды представляются объектами, а сценарий (программа) на JavaScript — это набор взаимодействующих объектов.
Язык JavaScript, в отличие от языков традиционных ЯП не содержит классов объектов в строгом смысле слова. Вместо этого он поддерживает конструкторы, которые создают объекты путем выделения для них памяти и инициализации всех или некоторых их свойств. Все конструкторы являются объектами, но не все объекты являются конструкторами. Каждый конструктор имеет свойство prototype, которое используется для реализации наследования, основанного на прототипах, и разделяемых свойств. Объекты создаются путем вызова конструктора в операции new;
например new String("Это строка") создает новый объект String.
Результат вызова конструктора без new зависит от конструктора. Так, String("Это строка") создает примитивную строку, а не объект.
В объектно-ориентированных языках, основанных на классах объектов, текущее состояние реализуется экземплярами классов, методы реализуются классами, а наследование — структурой и поведением. В JavaScript текущее состояние и методы реализуются объектами, а структура и поведение наследуются. Все объекты, которое явно содержат свойство, которое содержит их прототип, разделяют это свойство и его значение. В отличие от языков, основанных на классах, свойства могут динамически добавляться к объектам путем присвоения им значений. В частности, конструкторы не обязаны присваивать значения всем или некоторым свойствам создаваемого объекта.
Тип
Набор значений данных.
Примитивное значение
Элемент одного из типов Undefined, Null, Boolean, Number или String. Примитивные значения — это данные, которые представляются непосредственно и на самом нижнем уровне реализации языка.
Объект
Элемент типа Object; является неупорядоченным набором свойств, каждое из которых может быть примитивным значением, объектом или функцией. Свойство, являющееся функцией, называется методом.
Конструктор
Функция, которая создает и инициализирует объекты. Каждый конструктор имеет соответствующий прототип, который используется для наследования и разделения свойств.
Прототип
Объект, который используется в JavaScript для реализации наследования структуры, состояния и поведения. Когда конструктор создает объект, последний содержит неявную ссылку на прототип конструктора, позволяющий разрешать ссылки на свойства данного объекта. Свойства прототипа разделяются всеми объектами, созданными на его основе.
Строковое значение
Элемент типа String. Предсталяет собой строку символов, т . е. упорядоченный массив из нуля или более символов Unicode (т. е. 16-битовых целых чисел без знака).
Числовое значение
Элемент типа Number. Является непосредственным представлением числа.
Бесконечность
Примитивное значение Infinity, являющееся элементом типа Number.
NaN
Примитивное значение NaN (не число), являющееся элементом типа Number.
Как и во многих других языках программирования, программа (сценарий) на языке JavaScript — это текст, состоящий из операторов, блоков, т. е. взаимосвязанных наборов операторов, и комментариев. Операторы могут содержать переменные, константы и выражения. Следующий пример начинается с определения функции, которое состоит из блока, содержащего два оператора. За определением следуют два оператора, не образующих блока.
function convert(inches) {
cm = inches * 2.54; // Эти два оператора заключены в блок.
meters = inches / 39.37;
}
convert(inches); // Эти два оператора не образуют блока.
km = meters / 1000;
Как мы видим из этого примера, каждый оператор JavaScript начинается с новой строки (что не обязательно, но рекомендуется) и заканчивается точкой с запятой (что также не обязательно, если оператор является последним в строке). Блок — это набор операторов, заключенный в фигурные скобки {}.
Строка сценария, содержащая только точку с запятой, считается пустым оператором, т. е. оператором, не выполняющим никакого действия. Тем не менее, в некоторых случаях использование пустого оператора удобно, например:
while (i--) // Цикл состоит в уменьшении i до нуля,
; // поэтому его телом является пустой оператор.
Комментарии в JavaScript могут быть однострочными и многострочными. Однострочные комментарии начинаются с символов // и продолжаются до конца текущей строки, как показано в приведенном выше примере. Многострочные комментарии заключаются в маркеры /* и */, например:
/* Это пример комментария,
содержащего несколько строк. */
Многострочные комментарии не могут быть вложены друг в друга. Текст комментария полностью игнорируется при выполнении программы.
Следующие имена являются ключевыми словами языка JavaScript и не могут употребляться в качестве идентификаторов:
|
break |
delete |
function |
return |
typeof |
|
case |
do |
if |
switch |
var |
|
catch |
else |
in |
this |
void |
|
continue |
finally |
instanceof |
throw |
while |
|
default |
for |
new |
try |
with |
Следующие имена являются ключевыми словами в предлагаемых расширениях языка JavaScript и также не должны употребляться в качестве идентификаторов в целях совместимости с будущими версиями языка:
|
absract |
double |
implements |
private |
throws |
|
boolean |
enum |
import |
protected |
transient |
|
byte |
export |
int |
public |
volatile |
|
char |
extends |
interface |
short |
|
|
class |
final |
long |
static |
|
|
const |
float |
native |
super |
|
|
debugger |
goto |
package |
synchronized |
Идентификаторы используются в JavaScript в качестве имен переменных. Они могут начинаться с латинской буквы, символа "$" (знак доллара) или символа "_" (подчеркивание) и должны состоять из латинских букв, цифр и символов "$" и "_". Знак доллара рекомендуется использовать только в идентификаторах программ, которые автоматически генерируются другими программами. Идентификаторы не могут совпадать с зарезервированными словами. Два идентификатора считаются равными, если они текстуально совпадают; это означает, что JavaScript проводит различие между строчными и прописными буквами. Примеры синтаксически правильных идентификаторов:
MyIdentfier, another_identifier, $id, _function123
Переменные используются в качестве символических имен, принимающих различные значения. Имена переменных задаются идентификаторами. Переменная создается в момент ее декларации. JavaScript позволяет декларировать переменную двумя способами:
Если декларация переменной не содержит присваивания ей значения, то ее значением считается undefined. Мы можем проверять, определено ли значение переменной, и предпринимать соответствующие действия. Пример:
var text;
if (text == undefined)
document.write("Текст не задан");
else
document.write("Текст:" + text);
В этом примере значение переменной text не определено, поэтому будет выполнен первый оператор document.write.
В самом общем виде декларация переменных имеет вид:
var идентификатор[=инициализатор]?[,идентификатор[=инициализатор]?]?
Здесь инициализатор — это любое выражение, значение которого присваивается переменной при ее создании. Пример:
var a = 0, b, c = "текст", x, y = false;
Область действия переменных
Область действия переменной определяется положением ее декларации в тексте программы. Существуют три типа исполняемого кода JavaScript, называемых контекстом исполнения:
Иными словами, любая переменная, декларированная вне тела всех функций, является глобальной и доступна всюду в тексте данной программы. Переменная, декларированная в теле функции, является локальной и доступна только внутри тела этой функции.
Для декларации глобальных переменных ключевое слово var не обязательно. Однако, оно обязательно при декларации локальных переменных.
Константы используются для задания постоянных значений. В JavaScript имеется несколько типов констант, соответствующих его встроенным типам, а именно:
Тип Undefined (неопределенный)
Этот тип состоит из единственного значения undefined. Это значение, которое принимает переменная, которая объявлена в программе, но которой еще не присвоено никакого значения.
Тип Null (нулевой)
Этот тип состоит из единственного значения null. Это значение означает нулевую, пустую или несуществующую ссылку.
Тип Boolean (логический)
Этот тип состоит ровно из двух логических значений: true (истина) и false (ложь).
Тип String (строковый)
Этот тип состоит из всех возможных текстовых строк. Каждая строка представляет собой упорядоченный массив из нуля или более символов Unicode (т. е. 16-битовых целых чисел без знака), называемых элементами строки. Элементы строки нумеруются, начиная с нуля. Длина строки — это количество элементов в ней; пустая строка состоит из нуля элементов.
Тип Number (числовой)
Этот тип имеет ровно 18437736874454810627 (т. е. 264 - 253 + 3) значений, соответствующих 64-битовому формату плавающих чисел двойной точности.
Еще два специальных значения — это положительная бесконечность и отрицательная бесконечность, которым в JavaScript соответствуют выражения +Infinity (или просто Inifinity) и -Infinity. Отметим также, что в данном формате различаются положительный нуль (+0 или 0) и отрицательный нуль (-0).
Тип Object (объектный)
Значением этого типа являются объекты. Объект — это неупорядоченный набор свойств.
JavaScript — слаботипизированный язык. Это означает, что в декларации переменной мы не указываем ее тип и в дальнейшем можем присваивать ей значения любых типов. Исполняющая система JavaScript сама выполняет автоматическое преобразование типов данных по мере необходимости. Для явного преобразования типов используются методы Boolean, Number, Object и String.
Преобразования типов происходят по следующим правилам.
Преобразование к логическому типу
|
Исходный тип |
Результат |
|
Undefined |
false |
|
Null |
false |
|
Boolean |
без изменений |
|
Number |
false, если аргумент равен +0, -0 или NaN; true в остальных случаях |
|
String |
false, если аргумент — пустая строка; true в остальных случаях |
|
Object |
true |
Преобразование к числовому типу
|
Исходный тип |
Результат |
|
Undefined |
NaN |
|
Null |
+0 |
|
Boolean |
1, если аргумент равен true, и 0, если аргумент равен false |
|
Number |
без изменений |
|
String |
если строка содержит правильное число (возможно с пробелами перед и/или после него), то это число; NaN в противном случае |
|
Object |
результат преобразования значения объекта по умолчанию |
Преобразование к строковому типу
|
Исходный тип |
Результат |
|
Undefined |
"undefined" |
|
Null |
"null" |
|
Boolean |
"true", если аргумент равен true, и "false", если аргумент равен false |
|
Number |
текстовое представление числа (см. ниже) |
|
String |
без изменений |
|
Object |
результат преобразования значения объекта по умолчанию |
Преобразование числа n в строку происходит по следующим правилам:
Преобразование к объектному типу
|
Исходный тип |
Результат |
|
Undefined |
генерируется исключение TypeError |
|
Null |
генерируется исключение TypeError |
|
Boolean |
новый логический объект с данным значением по умолчанию |
|
Number |
новый числовой объект с данным значением по умолчанию |
|
String |
новый строковый объект с данным значением по умолчанию |
|
Object |
без изменений |
Примеры неявных преобразований
В выражениях, соединяющих числовые и строковые значения операцией +, JavaScript преобразует числа в строки, например:
x = "Ответ равен " + 21 // возвращает "Ответ равен 21"
y = 21 + " - вот ответ" // возвращает "21 - вот ответ"
В остальных случаях JavaScript пытается преобразовать строку в число, например:
a = "21" - 1 // возвращает 20
b = "21" + 1 // возвращает 211
Выражения в JavaScript, как и в других языках программирования, представляют собой комбинации переменных, констант и операций, дающие осмысленный результат. Этот результат может быть числом, текстовой строкой, логическим значением или объектом. Соответственно все выражения JavaScript подразделяются на арифметические, строковые, логические и объектные.
Операции сравнения сравнивают два операнда и возвращают логическое значение, означающее результат этого сравнения. Строки сравниваются в лексикографическом порядке в кодировке Unicode. Если типы операндов различны, то делается попытка преобразовать их к одному типу.
|
Операция |
Название |
Описание |
|
a < b |
Меньше |
Возвращает true, если левый операнд меньше, чем правый операнд. |
|
a > b |
Больше |
Возвращает true, если левый операнд больше, чем правый операнд. |
|
a <= b |
Не больше |
Возвращает true, если левый операнд меньше или равен правому операнду. |
|
a => b |
Не меньше |
Возвращает true, если левый операнд больше или равен правому операнду. |
|
a == b |
Равно |
Возвращает true, если левый операнд равен правому операнду. |
|
a != b |
Не равно |
Возвращает true, если левый операнд не равен правому операнду. |
|
a === b |
Тождественно |
Возвращает true, если левый операнд тождественно равен правому операнду. |
|
a !== b |
Не тождественно |
Возвращает true, если левый операнд тождественно не равен правому операнду. |
Примеры:
var x = "3";
a = x == 3; // a равно true
b = x === 3; // b равно false (разные типы)
Арифметические операции применяются к числовым операндам и возвращают числовое значение, означающее результат операции. Если типы операндов различны, то делается попытка преобразовать их к числовому типу. При этом:
|
Операция |
Название |
Описание |
|
a + b |
Сложение |
Возвращает сумму двух операндов. |
|
a - b |
Вычитание |
Возвращает разность от вычитания правого операнда из левого. |
|
a * b |
Умножение |
Возвращает произведение двух операндов. |
|
a / b |
Деление |
Возвращает частное от деления левого операнда на правый. |
|
a % b |
Остаток по модулю |
Возвращает целый остаток от деления левого операнда на правый. Плавающие числа перед операцией округляются до целых. |
|
++ |
Инкремент |
Унарная операция. Увеличивает значение переменной на 1. Если используется как префикс (++a), возвращает значение операнда после увеличения его на 1. Если используется как постфикс (a++), возвращает значение операнда перед увеличением его на 1. |
|
-- |
Декремент |
Унарная операция. Уменьшает значение переменной на 1. Если используется как префикс (--a), возвращает значение операнда после уменьшения его на 1. Если используется как постфикс (a--), возвращает значение операнда перед уменьшением его на 1. |
|
-a |
Смена знака |
Унарная операция. Возвращает арифметическое отрицание операнда. |
Примеры:
var i, j, k;
i = 19 % 6.8; // i равно 5
k = 2;
j = k++; // j равно 2, k равно 3
j = ++k; // j и k равны 4
Битовые операции применяются к числовым операндам, представленным как двоичные числа (т. е. как цепочки из 32 битов), и возвращают числовое значение, означающее результат операции. Перед выполнением операции операнды преобразуются в целые числа, а результат операции преобразуется в Number.
|
Операция |
Название |
Описание |
|
a & b |
Побитовое AND |
Возвращает в каждой битовой позиции 1, если соответствующие позиции обоих операндов равны 1. |
|
a | b |
Побитовое OR |
Возвращает в каждой битовой позиции 1, если соответствующая позиция хотя бы одного операнда равна 1. |
|
a ^ b |
Побитовое XOR |
Возвращает в каждой битовой позиции 1, если соответствующая позиция ровно одного операнда равна 1. |
|
~a |
Побитовое NOT |
Унарная операция. Инвертирует каждую битовую позицию операнда. |
|
a << b |
Сдвиг влево |
Сдвигает двоичное представление левого операнда влево на количество бит, заданное вторым операндом. Освобождающиеся справа биты заполняются нулями. |
|
a >> b |
Арифметический сдвиг вправо |
Сдвигает двоичное представление левого операнда вправо на количество бит, заданное вторым операндом. Освобождающиеся слева биты заполняются старшим (знаковым) битом. |
|
a >>> b |
Логический сдвиг вправо |
Сдвигает двоичное представление левого операнда вправо на количество бит, заданное вторым операндом. Освобождающиеся слева биты заполняются нулями. |
Примеры:
var i, j, k;
i = 15; j = 9;
k = i & j; // k равно 9 (1111 & 1001 = 1001)
k = i | j; // k равно 15 (1111 | 1001 = 1111)
k = i ^ j; // k равно 6 (1111 ^ 1001 = 0110)
i = -14; // двоичное значение 11111111 11111111 11111111 11110010
j = i >> 2; // j равно -4 (11111111 11111111 11111111 11111100)
k = i >>> 2; // k равно 1073741820 (00111111 11111111 11111111 11111100)
Логические операции применяются к логическим операндам и возвращают логическое значение, означающее результат операции. Если типы операндов различны, то делается попытка преобразовать их к логическому типу.
|
Операция |
Название |
Описание |
|
a && b |
Логическое AND |
Возвращает true, если оба операнда истинны. Если первый операнд ложен, то возвращает false, не вычисляя значение второго операнда. |
|
a || b |
Логическое OR |
Возвращает true, если хотя бы один операнд истинен. Если первый операнд истинен, то возвращает true, не вычисляя значение второго операнда. |
|
!a |
Логическое NOT |
Унарная операция. Возвращает true, если операнд ложен. |
Примеры:
var i, j, k;
i = 3; j = 5;
k = (i < 4) && (j > 4); // k равно true
k = (i < 4) || (j > 5); // k равно true
k = !k; // k равно false
На сегодняшний день JavaScript поддерживает единственную строковую операцию, а именно конкатенацию строк, которая обозначается символом "+". Если хотя бы один операнд является строкой, то результатом операции является слияние строк-операндов. Примеры:
k = "Моя " + "строка"; // k равно "Моя строка"
text = "Результат: " + 123; // text равно "Результат: 123"
Операции присваивания присваивают левому операнду результат операции, который определяется правым операндом и самой операцией. Базовая операция присваивания имеет вид a = b, что означает: присвоить переменной a значение операнда b. Все остальные операции присваивания являются сокращениями других операций, совмещенных с присваиванием, как показано в следующей таблице.
|
Операция |
Значение |
|
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 |
|
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 |
|
a ^= b |
a = a ^ b |
Операция присваивания возвращает значение, которое равно значению, присвоенному левому операнду. Пример:
i = j = k = 0; // все переменные получают значение 0
Условная операция
Условная операция — это единственная тернарная операция в JavaScript. Она имеет вид:
test ? value1 : value2
где test — любое логическое выражение, а value1 и value2 — любые выражения. Если test истинно, то операция возвращает значение value1, в противном случае она возвращает значение value2. Пример:
var status = (age >= 18) ? "взрослый" : "подросток";
Операция запятая
Операция запятая вызывает последовательное вычисление значений двух выражений и возвращает второе из них. Она имеет вид:
expr1,expr2
где expr1 и expr2 — любые выражения. Основное применение эта операция находит в операторе цикла for, поскольку последний допускает только одно выражение, которое исполняется в конце каждого цикла. Операция запятая позволяет объединить два выражения в одно и, тем самым, обойти это ограничение. Пример:
for (i = 0; i < 10; i++, j++) {
k = i + j;
}
Операция delete
Операция delete удаляет свойство объекта или элемент массива. Она имеет вид:
delete expr
где expr — любое выражение, значением которого является свойство объекта или элемент массива. Если удаление прошло успешно, то операция возвращает значение true; если нет (например, если свойство объекта не может быть удалено), то она возвращает значение false.
При удалении элемента массива длина массива и нумерация его элементов не изменяются, но удаленный элемент становится неопределенным.
Примеры:
mynumber = new Number(); // создает новый объект
mynumber.high = 100; // создает новое свойство объекта
delete mynumber.high; // удаляет свойство объекта
delete mynumber; // удаляет объект
langs = new Array("HTML", "CSS", "JavaScript", "Java");
delete langs[2]; // удаляет элемент массива
Операция in
Операция in возвращает true, если левый операнд является свойством правого операнда. Она имеет вид:
property in object
где property — строковое выражение, значением которого является имя свойства, или числовое выражение, задающее номер элемента массива, а object — любое объектное выражение. Примеры:
mynumber = new Number(); // новый объект
mynumber.high = 100; // новое свойство объекта
"high" in mynumber // возвращает true
langs = new Array("HTML", "CSS", "JavaScript", "Java");
0 in langs // возвращает true
4 in langs // возвращает false
Операция instanceof
Операция instanceof возвращает true, если данный объект относится к данному классу объектов. Она имеет вид:
object instanceof type
где object — любое объектное выражение, а type — имя класса объектов. Примеры:
myDay = new Date(1958,5,21); // новый объект
myDay instanceof Date // возвращает true
Операция new
Операция new создает новый объект путем вызова конструктора объектов. Она имеет вид:
new type(arguments)
где type — имя конструктора, а arguments — список параметров, разделенных запятыми, используемых для инициализации объекта. Если список параметров пуст, то круглые скобки можно опустить. Примеры:
myObject = new Object;
myArray = new Array();
myDate = new Date("May 21 1958");
myDay = new Date(1958,5,21);
Операция this
Операция this возвращает указатель на текущий объект. Она должна использоваться в выражениях вида:
this.property
где property — имя свойства объекта.
Операция typeof
Операция typeof возвращает строку, содержащую информацию о типе операнда. Она имеет вид:
typeof expr или typeof(expr)
где expr — любое выражение. Возвращаемое значение может быть одной из шести строк: "number" (число), "string" (строка), "boolean" (логическое значение), "object" (объект), "function" (функция) или "undefined" (неопределенное значение). Примеры:
var size = 1;
var shape = "круглый";
var today = new Date();
typeof(size); // возвращает "number"
typeof shape; // возвращает "string"
typeof today; // возвращает "object"
Операция void
Операция void вычисляет значение выражения и возвращает undefined. Она имеет вид:
void expr или void(expr)
где expr — любое выражение. Эта операция полезна в тех случаях, когда мы хотим вычислить значение выражения, но не хотим, чтобы оно передавалось последующей части сценария.
|
1 |
. [] () |
|
2 |
++ -- - ~ ! delete new typeof void |
|
3 |
* / % |
|
4 |
+ - |
|
5 |
<< >> >>> |
|
6 |
< <= > >= instanceof |
|
7 |
== != === !== |
|
8 |
& |
|
9 |
^ |
|
10 |
| |
|
11 |
&& |
|
12 |
|| |
|
13 |
?: |
|
14 |
= += -= *= /= %= <<= >>= >>>= &= ^= |= |
|
15 |
, |
Условный оператор if…else позволяет проверить определенное условие и, в зависимости от его истинности, выполнить ту или иную последовательность операторов. Он имеет две формы:
if (условие) оператор1
if (условие) оператор1 else оператор2
Оператор выбора switch выполняет ту или иную последовательность операторов в зависимости от значения определенного выражения. Он имеет вид:
switch (выражение) {
case значение:
операторы
break;
case значение:
операторы
break;
...
default:
операторы
}
for (инициализация; условие; изменение) оператор
Оператор for выполняется следующим образом:
Оператор цикла while
while (условие) оператор
Оператор цикла do…while
do оператор while (условие)
Оператор break
Оператор break прерывает выполнение текущего цикла, оператора switch или помеченный оператора и передает управление оператору, следующему за прерванным. Этот оператор может употребляться только внутри циклов while, do…while, for или for…in, а также внутри оператора switch.
Оператор continue
Оператор continue завершает текущую итерацию текущего цикла или цикла, помеченного соответствующей меткой, и начинает новую итерацию. Этот оператор может употребляться только внутри циклов while, do…while, for или for…in.
Оператор for…in выполняет заданные действия для каждого свойства объекта или для каждого элемента массива. Он имеет вид:
for (переменная in выражение) оператор
Следующий сценарий создает новый объект ob, а затем последовательно выводит все его свойства на экран обозревателя:
var ob = {"а" : "Архангельск", "б" : "Баку", "в" : "Воронеж"};
for (var key in ob)
document.write(key + ": " + ob[key] + "<BR>");
На экране появится текст
а: Архангельск
б: Баку
в: Воронеж
Оператор with задает имя объекта по умолчанию.
with (выражение) оператор
Здесь выражение — любое выражение, значением которого является объект, оператор — любая группа операторов JavaScript; если эти группа содержит более одного оператора, то она должны быть заключена в фигурные скобки {}.
x = Math.cos(Math.PI / 2) + Math.sin(Math.LN10);
y = Math.tan(2 * Math.E);
С помощью оператора with этот фрагмент сценария можно существенно укоротить:
with (Math) {
x = cos(PI / 2) + sin(LN10);
y = tan(2 * E);
}
Понятие исключения
В процессе исполнения сценария возможно возникновение неустранимых ошибок, называемых исключениями. Примерами исключений являются обращение к несуществующему объекту или невозможность преобразования значения к заданному типу.
Операторы, описанные в этом разделе, предназначены для обработки исключений, возникающих в ходе исполнения сценария, и генерации собственных исключений.
Оператор обработки исключений try…catch
Оператор try…catch используется в тех фрагментах сценария, где может возникнуть исключение, для его обработки. Он имеет вид:
try {
оператор1
}
catch (исключение) {
оператор2
}
Здесь исключение — любое имя переменной, а оператор1 и оператор2 — любые группы операторов JavaScript, заключенные в фигурные скобки {}.
Оператор1 содержит программный код, в котором возможно возникновение исключения. Если исключение не возникло, то после исполнения оператора1 управление передается обычным образом оператору, следующему за try…catch. Если же оно возникло, то информация об исключении заносится в локальную переменную исключение, и управление передается оператору2, который должен содержать код обработки этого исключения.
Если возникшее исключение не может быть здесь обработано, то оператор2 должен содержать оператор throw для передачи исключения обработчику исключений более высокого уровня.
Оператор throw
Оператор throw генерирует исключение, которое может быть обработано оператором try…catch. Он имеет вид:
throw исключение
где исключение — любое выражение.
Значение выражения исключение присваивается локальной переменной, указанной в операторе catch. Пример генерации исключения и его обработки:
function getMonthName(month) {
month = month - 1; // Переводим month в индекс массива (1=январь, 12=декабрь)
var months=new Array("январь","февраль","март","апрель","май","июнь","июль",
"август","сентябрь","октябрь","ноябрь","декабрь");
if (months[month] != null)
return months[month];
else
throw "Неверный месяц";
}
try {
monthName = getMonthName(myMonth); // возможно исключение
}
catch (e) {
monthName="неизвестно";
}
document.write(monthName);
Функции являются одним из основных механизмов языка JavaScript; они охватывают ту область, которая в других языках программирования реализуется подпрограммами, процедурами и функциями. Функция в JavaScript — это набор операторов, выполняющих определенную задачу.
Для того, чтобы пользоваться функцией, мы должны сначала ее определить. Декларация функции имеет вид:
function имя(аргументы?) {
операторы
}
Здесь имя — идентификатор, задающий имя функции, аргументы — необязательный список идентификаторов, разделенных запятыми, который содержит имена формальных аргументов функции, а операторы — любой набор операторов, который называется телом функции и исполняется при ее вызове.
Рассмотрим следующий пример:
function cube(number) {
return number * number * number;
}
Эта функция называется cube и имеет один формальный аргумент number. При вызове этой функции вместо формального аргумента подставляется его фактическое значение, функция выполняет возведение этого значения в куб и возвращает полученное число оператором return.
вызов функции
var x = cube(5);
В результате переменная x получит значение 125.
В JavaScript действуют следующие правила передачи аргументов функции:
Рекурсивные функции
Приведем пример функции, вычисляющей факториал числа (факториал числа n равен 1 * 2 * ... * n):
function factorial(n) {
if (n <= 1)
return 1;
else
return (n * factorial(n-1));
}
Неаккуратно написанная рекурсивная функция может войти в бесконечный цикл и никогда не вернуть результата. Например, попытка вычислить факториал отрицательного числа с помощью приведенной функции приведет именно к такому результату.
Оператор return
Возвращает значение:
return выражение
Объект arguments
При входе в тело функции создается локальный объект arguments, который имеет следующие свойства:
функция.arguments[i]
где функция — идентификатор, задающий имя текущей функции, а i — номер аргумента, начиная с нуля.
Этот объект полезен в тех случаях, когда мы заранее не знаем количества аргументов, которые будут переданы данной функции. В следующем примере функция initArray создает новый массив и копирует в него список своих фактических аргументов.
function initArray() {
this.length = initArray.arguments.length;
for (var i = 0; i < this.length; i++)
this[i] = initArray.arguments[i];
}
var myFriends = new initArray("Михаил", "Максим", "Сергей", "Леонид");
PAGE 16
Телекоммуникационные системы. Лекция №4