Asja_MiLaFka_original (CommandButton) все записи автора Фотографии CommandButton : ПРИКОЛИСЬ


Asja_MiLaFka_original

Asja_MiLaFka_original (CommandButton) все записи автора Фотографии CommandButton : ПРИКОЛИСЬ


Asja_MiLaFka_original

Asja_MiLaFka_original (CommandButton) все записи автора Фотографии CommandButton : ПРИКОЛИСЬ


Asja_MiLaFka_original

Asja_MiLaFka_original (CommandButton) все записи автора Фотографии CommandButton : ПРИКОЛИСЬ


Asja_MiLaFka_original

Asja_MiLaFka_original (CommandButton) все записи автора Фотографии CommandButton : ПРИКОЛИСЬ

=))о как
Asja_MiLaFka_original

Asja_MiLaFka_original (CommandButton) все записи автора Эдуард Асадов

Антология русской поэзии

СТУДЕНТЫ

Проехав все моря и континенты,
Пускай этнограф в книгу занесет,
Что есть такая нация - студенты,
Веселый и особенный народ!

Понять и изучить их очень сложно.
Ну что, к примеру, скажете, когда
Все то, что прочим людям невозможно,
Студенту - наплевать и ерунда!

Вот сколько в силах человек не спать?
Ну день, ну два... и кончено! Ломается!
Студент же может сессию сдавать,
Не спать неделю, шахмат не бросать
Да плюс еще влюбиться ухитряется.

А сколько спать способен человек?
Ну, пусть проспит он сутки на боку,
Потом, взглянув из-под опухших век,
Вздохнет и скажет:- Больше не могу!

А вот студента, если нет зачета,
В субботу положите на кровать,
И он проспит до следующей субботы,
А встав, еще и упрекнет кого-то:
- Ну что за черти! Не дали поспать!

А сколько может человек не есть?
Ну день, ну два... и тело ослабело...
И вот уже ни встать ему, ни сесть,
И он не вспомнит, сколько шестью шесть,
А вот студент - совсем другое дело.

Коли случилось \"на мели\" остаться,
Студент не поникает головой.
Он будет храбро воздухом питаться
И плюс водопроводною водой!

Что был хвостатым в прошлом человек -
Научный факт, а вовсе не поверье.
Но, хвост давно оставя на деревьях,
Живет он на земле за веком век.

И, гордо брея кожу на щеках,
Он пращура ни в чем не повторяет.
А вот студент, он и с хвостом бывает,
И даже есть при двух и трех хвостах!

Что значит дружба твердая, мужская?
На это мы ответим без труда:
Есть у студентов дружба и такая,
А есть еще иная иногда.

Все у ребят отлично разделяется,
И друга друг вовек не подведет.
Пока один с любимою встречается,
Другой идет сдавать его зачет...

Мечтая о туманностях галактик
И глядя в море сквозь прицелы призм,
Студент всегда отчаянный романтик!
Хоть может сдать на двойку романтизм.

Да, он живет задиристо и сложно,
Почти не унывая никогда.
И то, что прочим людям невозможно,
Студенту - наплевать и ерунда!

И, споря о стихах, о красоте,
Живет судьбой особенной своею.
Вот в горе лишь страдает, как и все,
А может, даже чуточку острее...

Так пусть же, обойдя все континенты,
Сухарь этнограф в труд свой занесет.
Что есть такая нация - студенты,
Живой и замечательный народ!

Asja_MiLaFka_original (CommandButton) все записи автора Справочное руководство по java Script:
Ввод и вывод данных
Типы данных
Преобразование типов данных
Служебные символы в строках
Переменные и оператор присваивания
Операторы
Функции
Встроенные объекты
Объект Array (Массив)
Методы Array
Объект Number (Число)
Объект Math (Математика)
Объект Date (Дата)
Объект Boolean (Логический)
Объект Object
Пользовательские объекты
Специальные операторы
Приоритеты операторов

Мониста (CommandButton) все записи автора

Мониста (CommandButton) все записи автора В этом разделе описываются операторы, которые при программировании на JavaScript используются относительно редко..
10.1. Побитовые операторы
Побитовые (поразрядные) операторы применяются к целочисленным значениям и возвращают целочисленные значения. При их выполнении операнды предварительно приводятся к двоичной форме представления, в которой число является последовательностью из нулей и единиц длиной 32. Эти нули и единицы называются двоичными разрядами или битами. Далее производится некоторое действие над битами, в результате которого получается новая последовательность битов. В конце концов эта последовательность битов преобразуется к обычному целому числу — результату побитового оператора. В следующей таблице приведен список побитовых операторов.

Побитовые операторы

Оператор Название Левый операнд Правый операнд
& побитовое и целое число целое число
| побитовое или целое число целое число
^ побитовое исключающее или целое число целое число
~ побитовое не — целое число
<< смещение влево целое число количество битов,
на которое производится смещение
>> смещение вправо целое число количество битов,
на которое производится смещение
>>> заполнение нулями при смещении целое число количество битов,
вправо на которое производится смещение


Операторы &, |, ^ и ~ напоминают логические операторы, но их область действия — биты, а не логические значения. Оператор ~ изменяет значение бита на противоположное: 0 на 1, а 1 — на 0. В следующей таблице поясняется, как работают операторы &, |, ^.

Работа операторов &, |, ^

X Y X&Y X | Y X^Y
1 1 1 1 0
1 0 0 1 1
0 1 0 1 1
0 0 0 0 0

Например, 2&3 равно 2, а 2|3 равно 3. Действительно, в двоичном представлении 2 есть 10, а 3 — 11. Применение побитовых операторов даст в случае оператора & двоичное число 10, то есть десятичное число 2, а в случае оператора | — двоичное число 11, то есть десятичное 3.
У операторов смещения один операнд и один параметр, указывающий, на какое количество бит следует произвести смещение. Например, 3<<2 равно 12, потому что смещение влево на два бита двоичного числа 11 (десятичное 3) дает 1100, что в десятичной форме есть 12. Результатом вычисления выражения 6>>2 — 1. Действительно, число 6 в двоичной форме это 110; смещение его вправо на два бита дает 1 как в двоичной, так и в десятичной форме.
10.2. Объектные операторы
Оператор удаления свойств объекта (delete)

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

ВНИМАНИЕ
При удалении элемента массива удаляется и его индекс, но оставшиеся элементы сохраняют свои прежние индексы, а длина массива не изменяется. Использование оператора delete не приводит к немедленному освобождению памяти. Решение об освобождении памяти принимается так называемым ядром JavaScript, а пользовательская программа лишь создает к этому предпосылки, но не может контролировать этот процесс абсолютно.

Оператор проверки наличия свойств (in)

Этот оператор позволяет проверить, имеется ли некоторое свойство или метод у того или иного объекта. Левый операнд представляет собой ссылку в виде строки на интересующее нас свойство или метод, а правый операнд — объект. Ссылка на метод содержит лишь его название без круглых скобок. Если свойство или метод содержится в объекте, то возвращается true, иначе — false. Отсюда следует, что оператор in можно применять в условных выражениях (в операторах if, switch, for, while, do-while).

Примеры:
Например, объект document, представляющий загруженный в браузер HTML-документ, имеет метод write(). Чтобы убедиться в этом, следует написать выражение: "write" in document // значение равно true

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

function Сотрудник(Имя, Отдел, Телефон, Зарплата) {
this.Имя = Имя
this.Отдел = Отдел
this.Телефон = Телефон
this.Зарплата = Зарплата
}
agent007 = new Сотрудник("Джеймс Бонд", 5, "223-332")
"Телефон" in agent007 // true
"Ученая степень" in agent007 // false

Оператор in поддерживается браузерами IE5.5+, NN6+.

Оператор проверки принадлежности объекта модели (instanceof)
Этот оператор позволяет проверить, принадлежит ли некоторый объект объектной модели JavaScript. Левый операнд представляет проверяемое значение, а правый ссылку на корневой объект, такой как Array, String, Date и т. п. Выражение с оператором instanceof возвращает true или false и, таким образом может использоваться в условных выражениях (в операторах if, switch, for, while, do while).

Пример:
Созданный массив является экземпляром объекта Array, а последний сам является экземпляром корневого объекта Object.

myarray = new Array()
myarray instanceof Array // true
Array instance Object // true
Myarray instanceof String // false

Оператор in поддерживается браузерами IE5.5+, NN6+.
10.3. Комплексные операторы
Оператор условия (?:)

Этот оператор является сокращенной формой оператора условного перехода if … else… Его так и называют: оператор условия. Обычно он используется вместе с оператором присваивания одного из двух возможных значений, в зависимости от значения условного выражения. Синтаксис оператора условия следующий:
условие ? выражение1 : выражение2
С оператором присваивания оператор условия имеет такой вид:
переменная = условие ? выражение1 : выражение2
Оператор условия возвращает значение выражения выражение1, если условие истинно, в противном случае — значение выражения выражение2.

Пример:

d = new Date()
x = d.getDate()
typedate = (x%2 == 0)&&(x > 1) ? "четное" : "нечетное"

Оператор определения типа (tipeof)

Этот оператор используется для проверки, относится ли значение к одному из следующих типов: string, number, boolean, object, function или undefined. Значение, возвращаемое оператором typeof, является строковым. Оно содержит одно из перечисленных выше названий типа. Единственный операнд пишется справа от ключевого слова typeof.

Мониста (CommandButton) все записи автора В предыдущем разделе мы рассмотрели встроенные объекты, то есть заранее предопределенные в JavaScript и часто используемые в программах. С помощью выражений с ключевым словом new вы можете создавать экземпляры этих объектов, то есть их конкретные воплощения. Более того, благодаря свойству prototype имеется возможность добавлять к объектам новые свойства и методы, придуманные пользователем и отсутствовавшие в исходных встроенных объектах. В большинстве случаев, в частности при создании сценариев для Web-страниц, всего этого более чем достаточно. Однако нельзя обойти вниманием возможность создания собственных объектов. Зачем нужны собственные объекты? Они не являются необходимыми для решения практических задач. С точки зрения программиста, объект представляет собой просто удобное средство организации данных и функций их обработки. Чтобы как-то организовать данные и функции в программе, далеко не всегда необходимо прибегать к такой конструкции, как объект. Ведь даже при внушительном количестве данных программист не всегда организует их в виде массива (объекта Array): бывает достаточным ограничиться простыми переменными.
9.1. Создание объекта
Объекты в JavaScript можно создать несколькими способами. Мы рассмотрим три таких способа.

Первый способ основан на функции, в теле которой описываются все свойства и методы создаваемого объекта. Поскольку эта функция играет определяющую роль в создании объекта, ее называют функцией-конструктором или просто конструктором объекта. Что, собственно, должен делать конструктор? Очевидно, он должен ввести имя создаваемого объекта, а также его свойства и методы. Кроме того, он должен допускать возможность присваивания начальных значений свойствам. Имя функции-конструктора объекта является одновременно и именем создаваемого объекта. Свойства и методы создаваемого объекта задаются в теле функции-конструктора с помощью операторов присваивания. При этом имена переменных-свойств записываются с ключевым словом this (этот): this.переменная. Рассмотрим в качестве примера функцию-конструктор, определяющую объект car (автомобиль) со свойствами name (название), model (модель) и color (цвет):

function car(name, model, color) {
this.name = name
this.model = model
this.color = color
}

Эта функция определяет объект car. Чтобы создать конкретный экземпляр объекта car, следует выполнить выражение с вызовом этой функции, которой можно передать значения параметров. Мы уже знаем, что экземпляр объекта создается с помощью оператора присваивания с ключевым словом new:
mycar = new car("Лада", "ВАЗ21099","green")

Итак, мы создали объект mycar, являющийся экземпляром объекта car. Таких экземпляров с различными именами можно создать несколько. Значения свойств объекта mycar можно изменять в программе:

mycar.model // значение равно "ВАЗ21099"
mycar.name // значение равно "Лада"
mycar.model = "ВАЗ2110" // значение равно "ВАЗ2110"

Как видите, объект это просто особый способ группировки данных и их использования (составное имя переменной: объект.свойство).

Объекты можно создавать и с помощью конструктора new Object():

mycar = new Object()
mycar.name = "Лада"
mycar.model = "ВАЗ21099"
mycar.color = "green"

В этом способе отчетливо видно, создаваемый объект является экземпляром объекта Object подобно тому как, например, создаваемый массив является экземпляром объекта Array.
Допускается также и следующая компактная запись определения объекта:
mycar = {name:"Лада", model:"ВАЗ21099", color:"green"}
Здесь все определение свойств заключается в фигурные скобки. Пары свойство-значение разделяются запятыми, а имя свойства отделяется от значения двоеточием.

При создании объекта мы можем задать значения свойств по умолчанию, то есть значения, которые будут иметь свойства, если при создании экземпляра этого объекта значения его свойств не указаны явным образом (то есть имеют значения null, 0 или ""). Это делается с помощью логического оператора ИЛИ (обозначаемого ||) в конструкторе объекта в виде функции:

function car(name, model, color) { // конструктор объекта car
this.name = name || "неизвестно"
this.model = model || "неизвестно"
this.color = color || "black"
}
mycar = new car("Жигули","") // создание экземпляра mycar объекта car
mycar.name // "Жигули"
mycar.model // "неизвестно"
mycar.color // "black"

9.2. Добавление свойств
Если возникает необходимость добавить новое свойство к существующему объекту, а также ко всем его экземплярам, то это можно сделать с помощью свойства prototype. В приведенном ниже примере мы создаем объект car (автомобиль), затем его экземпляр mycar, а затем добавляем к свойству prototype свойство owner (владелец) с конкретным значением:

function car(name, model, color) { // конструктор объекта car
this.name = name || "неизвестно"
this.model = model || "неизвестно"
this.color = color || "black"
}

mycar = new car("Жигули","") /* создание экземпляра mycar объекта car */
mycar.name // "Жигули"
mycar.model // "неизвестно"
mycar.color // "black"
car.prototype.owner = "Иванов" // добавляем новое свойство
mycar.owner // "Иванов"

Если нужно добавить новое свойство только к конкретному объекту (к данному экземпляру объекта), то это можно сделать просто с помощью оператора присваивания:
имяОбъекта.новое_свойство = значение

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

function car(){}
mycar1 = new car()
mycar2 = new car()
mycar1.name = "Жигули"
mycar2.model = "ВАЗ2106"

mycar1.name // "Жигули"
mycar1.model // undefined (не определено)
mycar2.name // undefined (не определено)
mycar2.model // "ВАЗ2106"

9.3. Связанные объекты
В объекте в виде свойства может содержаться ссылка на другой объект. В этом случае оба объекта оказываются связанными: один из них оказывается подобъектом или, другими словами, свойством другого. Например, мы можем создать объект photo, содержащий в качестве своих свойств название автомобиля и URL-адрес файла с его изображением. Такой объект можно связать с объектом car, содержащим основную информацию об автомобилях, добавив к нему свойство, значением которого является ссылка на объект photo.

Ниже приведены конструкторы объектов car и photo. Чтобы добавить объект photo в объект car, мы добавили в объект car свойство, значением которого является ссылка на объект photo.

function car(name, model, color, photo) { /* конструктор объекта car */
this.name = name
this.model = model
this.color = color
this.photo = photo // ссылка на объект photo
}

function photo (name, url) { // конструктор объекта photo
this.name = name
this.url = url
}
Cоздадим пару конкретных объектов, являющихся экземплярами объекта photo:
photo1=new photo("Лада","/images/lada1.jpg")
photo2 =new photo("Лада ","/images/lada2.gif")
Теперь создадим экземпляры объекта car:

mycar = new car("Лада", "ВАЗ21099","white", photo1)
mycar.photo.url // "/images/lada1.jpg"
mycar.model // "ВАЗ21099"

mycar = new car("Ока", "ВАЗ21099","white", photo2)
mycar.photo.url // "/images/lada2.gif"
mycar.model // "ВАЗ21099"

Обратите внимание, чтобы узнать значение URL-адреса расположения файла с картинкой, относящейся к объекту mycar, мы обращаемся к свойству url объекта photo, который сам является свойством объекта mycar или, другими словами, подобъектом объекта mycar.

Мониста (CommandButton) все записи автора Object является корневым объектом, на котором базируются все остальные объекты JavaScript, такие как String, Array, Date и т. д. В программах можно создавать свои собственные объекты. Это можно сделать различными способами:

function имя_конструктора([пар1,…[, парN]){
код
}
имяОбъекта = new имя_конструктора(["пар1",…[, "парN"])
имяОбъекта = new Object()
имяОбъекта.свойство = значение
имяОбъекта = {свойство1: значение1 [, свойство2: значение2 [,…,N]}

Для обращения к свойствам и методам объекта используется следующий синтаксис:
ссылка_на_объект.свойство
ссылка_на_объект.метод([параметры])

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

function Сотрудник(Имя, Отдел, Телефон, Зарплата) {
this.Имя = Имя
this.Отдел = Отдел
this.Телефон = Телефон
this.Зарплата = Зарплата
}

Как видите, конструктор объекта может быть представлен в виде определения функции. Ключевое свойство this представляет ссылку на текущий, то есть определяемый конструктором объект. Все операторы присваивания с this, расположенные в теле функции-конструктора, определяют свойства объекта. В круглых скобках у имени объекта могут перечисляться параметры, чтобы иметь возможность создать конкретный объект, являющийся экземпляром обезличенного объекта Сотрудник, и присвоить его свойствам конкретные значения. Например, создадим конкретного сотрудника — agent007:
agent007 = new Сотрудник("Джеймс Бонд", 5, "223-332", 3600.50)

Доступ к свойствам этого объекта производится обычным способом:
agent007.Имя // "Джеймс Бонд"
agent007.Зарплата // 3600.5

Информация о новом сотруднике добавляется аналогичным образом:
Shtirlitz = new Сотрудник("Максимов", 4, "123-4567",4500.50)

Мониста (CommandButton) все записи автора Объект Boolean создается с помощью выражения вида:
переменная = new Boolean(логическое_значение)
Он имеет свойство prototype и методы toString() и значue Of(), которые имеют также объекты String и Number. Смысл свойства prototype мы уже рассматривали применительно к объектам String и Array. Объект Boolean может понадобиться в том случае, кода всем логическим объектам, создаваемым с помощью выражения с ключевыми словами new Boolean нужно добавить новые свойства или методы с помощью прототипа (свойства prototype).
8.7. Объект Function (Функция)
Создание объекта Function Выше мы уже рассматривали стандартный способ определения функции:

function имя_функции(параметры) {
код
}

Существует и другой способ, основанный на выражении с ключевыми словами new Function. Согласно этому способу функция создается как экземпляр объекта Function:
имя_функции = new Function(["пар1", [,"парN"], "оператор1; [; операторN]")

Названия всех параметров являются строковыми значениями. Они разделяются запятыми. Заключительная строка содержит операторы кода тела функции, разделенные точкой с запятой. Вызов функции, определенной как экземпляр объекта Function, можно выполнить обычным способом: имя_функции(параметры).

При любом задании функции, стандартном или с помощью ключевого слова new, автоматически создается экземпляр объекта Function, который обладает своими свойствами и методами.

Свойства Function

arguments — массив значений параметров, переданных функции.
Индексация элементов массива производится с 0. Поскольку это массив, он имеет свойства и методы объекта Array (в частности, свойство length —длина массива).
Свойство arguments применяется в теле определения функции, когда требуется проанализировать параметры, переданные ей при вызове. Например, можно узнать, сколько в действительности было передано параметров, не являются ли их значения пустыми ("", 0, null) и т. п. Это свойство особенно полезно при разработке универсальных библиотечных функций.
Синтаксис выражения следующий: имя_функции.arguments.

length — количество параметров, указанных в определении функции.
Синтаксис: имя_функции.length
В отличие от свойства arguments, количество параметров функции можно определить в программе за пределами тела этой функции.
Пример:

function myfunc(a, b, c, d){
return myfunc.arguments.length
}
myfunc(a,b) // 2
myfunc.length // 4

caller — содержит ссылку на функцию, из которой была вызвана данная функция; если функция не вызывалась из другой функции, то значение этого свойства равно null.
Совместимость: IE4+, NN4
Синтаксис: имя_функции.caller
В свойстве имя_функции.caller содержится все определение функции, из которой была вызвана функция имя_функции.

Методы Function

toString() — возвращает определение функции в виде строки.
Синтаксис: имя_функции.toString()

apply( [текущий_объект [, массив_параметров]])

call( [текущий_объект [,пар1[,пар2[,…, парN]]]])

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

Мониста (CommandButton) все записи автора 8.5. Объект Date (Дата)
Во многих приложениях приходится отображать дату и время, подсчитывать количество дней, оставшихся до заданной даты и т. п. Некоторые программы даже управляются посредством значений дат и времени. В основе всех операций, связанных с датами и временем, лежат текущие системные дата и время, установленные на вашем компьютере. Со временем дела обстоят не так просто, как кажется на первый взгляд. Вспомните, что существуют временные зоны (часовые пояса), а также сезонные поправки времени. Так например, текущее время в Санкт-Петербурге отличается от времени в Иркутске на 5 часов. Если в Иркутске уже полночь, то в Петербурге еще только 19 часов. Чтобы иметь возможность координировать деятельность во времени организаций и физических лиц в различных точках нашей планеты, была введена система отсчета времени. Она связана с меридианом, проходящим через астрономическую обсерваторию в городе Гринвич в Великобритании. Эту временную зону называют cредним временем по Гринвичу (Greenwich Mean Time — GMT). Недавно кроме аббревиатуры GMT стали использовать еще одну — UTC (Coordinated Universal Time — Всеобщее Скоординированное Время).

Если системные часы вашего компьютера установлены правильно, то отсчет времени производится в системе GMT. Однако на Панели управления обычно устанавливается локальное время, соответствующее вашему часовому поясу. При создании и изменении файлов на вашем компьютере фиксируется именно локальное время. Вместе с тем операционная система знает разницу между локальным временем и GMT. При перемещении компьютера из одного часового пояса в другой, необходимо изменить установки именно часового пояса, а не текущего системного времени (показания системных часов). Даты и время, генерируемые в сценариях, сохраняются в памяти в системе GMT, но пользователю выводятся, как правило, в локальном виде. В программе на JavaScript нельзя просто написать 30.10.2002, чтобы получить значение даты, с которым в дальнейшем можно производить некие операции. Значения даты и времени создаются как экземпляры специального объекта Date. При этом объект сам будет «знать», что не бывает 31 июня и 30 февраля, а в високосных годах 366 дней.

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

Объект даты создается с помощью выражения вида:
имяОбъектаДаты = new Date([параметры])
Параметры не обязательны, на что указывают квадратные скобки. Обратите внимание, что имяОбъектаДаты является объектом даты, а не значением какого-нибудь другого типа (например, строкой или числом). Для манипуляций с объектом даты применяется множество методов объекта Date. При этом используется такой синтаксис:
переменная = имяОбъектаДаты.метод()
Если, например, объекту даты требуется присвоить новое значение, то для этого используется соответствующий метод:
переменная = имяОбъектаДаты.метод(новое_значение)

Рассмотрим в качестве примера изменение значения года текущей системной даты:

xdate = new Date() /* создание объекта, содержащего текущую дату и время */
Year = xdate.getYear() /* в переменной Year содержится значение текущего года */
Year = Year + 3 /* в переменной Year содержится значение,
большее, чем текущий год на 3 */
xdate.setYear(Year) /* в объекте устанавливается новое
значение года */

При создании объекта даты с помощью выражения new Date(), можно указать в качестве параметров, какую дату и время следует установить в этом объекте. Это можно сделать пятью способами:

new Date("Месяц дд, гггг чч:мм:сс")
new Date("Месяц дд, гггг")
new Date(гг, мм, дд, чч, мм, сс)
new Date(гг, мм, дд)
new Date(милисекунды)

В первых двух способах параметры задаются в виде строки, в которой указаны компоненты даты и времени. Буквенные обозначения определяют шаблон параметров. Обратите внимание на разделители — запятые и двоеточия. Время указывать не обязательно. Если компоненты времени опущены, то устанавливается значение 0 (полночь). Компоненты даты обязательно должны быть указаны. Месяц указывается как полное его английское название (аббревиатуры не допускаются). Остальные компоненты указываются в виде чисел. Если число меньше 10, то можно писать одну цифру, не записывая ведущий 0 (например, 3:05:32). В третьем и четвертом способах компоненты даты и времени представляются целыми числами, разделенными запятыми. В последнем способе дата и время задаются целым числом, которое представляет количество миллисекунд, прошедших с начала 1 января 1970 года (то есть с момента 00:00:00). Количество миллисекунд, отсчитанное от указанной стартовой даты, позволяет вычислить все компоненты и даты, и времени.

Методы объекта Date

Для чтения и изменения информации о дате и времени, хранящейся в объекте даты, служат методы объекта Date (см. таблицу). Напомним, что объект даты создается с помощью выражения:
имяОбъектаДаты = new Date([параметры])
Затем, чтобы применить метод метод() к объекту даты имяОбъектаДаты, следует написать: имяОбъектаДаты.метод([параметры]). Довольно большое множество всех методов можно разделить на две категории: методы получения значений (их названия имеют префикс get) и методы установки новых значений (их названия имеют префикс set). В каждой категории выделяются две группы методов — для локального формата и формата UTC. Методы позволяют работать с отдельными компонентами даты и времени (годом, месяцем, числом, днем недели, часами, минутами, секундами и милисекундами).

Методы объекта Date

Метод Диапазон значений Описание
getFullYear( ) 1970–... год
getYear( ) 70–... год
getMonth( ) 0–11 месяц (январь = 0)
getDate( ) 1–31 число
getDay( ) 0–6 день недели (воскресенье = 0)
getHours( ) 0–23 часы в 24-часовом формате
getMinutes( ) 0–59 минуты
getSeconds( ) 0–59 секунды
getTime( ) 0–… миллисекунды с 1.1.70 00:00:00 GMT
getMilliseconds( ) 0–… миллисекунды с 1.1.70 00:00:00 GMT
getUTCFullYear( ) 1970-... год UTC
getUTCMonth( ) 0–11 месяц UTC (январь = 0)
getUTCDate( ) 1–31 число UTC
getUTCDay( ) 0–6 день недели UTC (воскресенье = 0)
getUTCHours( ) 0–23 часы UTC в 24-часовом формате
getUTCMinutes( ) 0–59 минуты UTC
getUTCSeconds() 0–59 секунды UTC
getUTCMilliseconds( ) 0–.... миллисекунды UTC с 1.1.70 00:00:00 GMT
setYear(знач) 1970–... установка года (четырехзначного)
SetFullYear(знач) 1970–… установка года
setMonth(знач) 0–11 установка месяца (январь = 0)
setDate(знач) 1–31 установка числа
setDay(знач) 0–6 установка дня недели (воскресенье = 0)
setHours(знач) 0–23 установка часов в 24-часовом формате
setMinutes(знач) 0–59 установка минут
setSeconds(знач) 0–59 установка секунд
setMilliseconds(знач) 0–… установка миллисекунд с 1.1.70 00:00:00 GMT
setTime(знач) 0–… установка миллисекунд с 1.1.70 00:00:00 GMT
setUTCFullYear(знач) 1970–… установка года UTC
setUTCMonth(знач) 0–11 установка месяца UTC (Январь = 0)
setUTCDate(знач) 1–31 установка числа UTC
setUTCDay(знач) 0–6 установка дня недели UTC (воскресенье = 0 )
setUTCHours(знач) 0–23 установка часов UTC в 24-часовом формате
setUTCMinutes(знач) 0–59 установка минут UTC
setUTCSeconds(знач) 0–59 установка секунд UTC
setUTCMilliseconds(знач)0–… установка миллисекунд UTC с 1.1.70 00:00:00 GMT
getTimezoneOffset ( ) 0–… разница в минутах по отношению к GMT/UTC
toDateString( ) строка с датой (без времени) в формате браузера (IE5.5)
toGMTString( ) строка с датой и временем в глобальном формате
toLocaleDateString( ) строка с датой без времени в локализованном формате системы (NN6, IE5.5)
toLocaleString( ) строка с датой и временем в локализованном формате системы
toLocaleTimeString( ) строка с временем без даты и в локализованном формате системы (NN6, IE5.5)
toString( ) строка с датой и временем в формате броузера
toTimeString( ) строка с временем без даты в формате броузера (IE5.5)
toUTCString() строка с датой и временем в глобальном формате
Date.parse("dateString") преобразование строки с датой в число миллисекунд
Date.UTC(знач) преобразование строки с датой GMT в число

Вычислять разность двух дат или создавать счетчик времени, оставшегося до некоторого заданного срока, можно с помощью методов как для локального формата, так и UTC. Не следует применять выражения, использующими различные форматы времени, поскольку результаты могут оказаться неправильными. Формат UTC обычно применяется в расчетах, учитывающих часовой пояс. Следует также учитывать, что нумерация месяцев, дней недели, часов, минут и секунд начинается с 0. Для компонент времени это естественно. Однако при такой нумерации декабрь оказывается 11-м месяцем в году, а не 12-м, как это принято повсеместно. Воскресенье (Sunday) является 0-м днем недели, а не 7-м. Значение года XX века представляется в двухзначном формате как разность между этим годом и 1900. Например, 1996 год представляется как 96. Годы до 1900 и после 1999 обозначаются в четырехзначном формате. Например, 2005 год нужно так и писать — 2005, поскольку 05 это 1905 год. Метод getFullYear() возвращает четырехзначное значение года.

Изменение любой компоненты даты производится с помощью соответствующего метода, название которого начинается с приставки set. При этом значения других компонент пересчитываются автоматически.

В следующем примере мы создаем объект даты, содержащий некоторую конкретную дату. Затем мы устанавливаем новое значение года. При этом в объекте даты изменяется и число. При попытке отобразить значение объекта даты оно автоматически преобразуется в строку методом toString(). Формат этой строки зависит от операционной системы и браузера. Например, для Windows 98 и Internet Explorer 5.5+ строка, содержащая информацию объекта даты, имеет следующий вид: Thu Oct 31 13:16:23 UTC+0300 2002, то есть четверг, октябрь, 31, 13 часов 16 минут 23 секунды Всеобщего времени, скорректированного на 3 часа, 2002 год
Если коррекцию времени с учетом часового пояса производить не требуется, то для строкового представления даты и времени можно воспользоваться методом toLocaleString():

mydate = new Date()
mydate.toLocaleString() // "1 декабря 2004 г. 14:13:36"

В браузерах IE5.5+ и NN6+ работают еще два метода представления отдельно даты и времени в виде строки:

mydate = new Date()
mydate.toLocaleDateString() // "1 декабря 2004 г."
mydate.toLocaleTimeString() // "14:13:36"

Заметим, что формат представления даты и времени, обеспечиваемый методами toLocalDateString() и toLocalTimeString(), зависит от настроек операционной системы и браузера. Если вы будете использовать эти методы для вывода даты и времени на Web-страницу, то они будут выглядеть так, как пользователь привык их видеть на своем компьютере. С датой иногда приходится выполнять различные вычисления, такие, как определение даты через заданное количество дней от текущей, или количество дней между двумя датами. Вот здесь как раз и требуется предварительный подсчет миллисекунд, содержащихся в минуте, часе, сутках и т. д.

Примеры:
Определим дату, которая наступит через неделю относительно текущей:

week = 1000*60*60*24*7 /* количество миллисекунд в неделе — 604800000 */
mydate = new Date() // объект даты с текущей датой
mydate_ms = mydate.getTime() /* текущая дата, представленная количеством миллисекунд от 1.01.1970 00:00:00 */
mydate_ms += week // maydate_ms = mydate_ms + week
mydate.setTime(mydate_ms) /* установка новой даты в объекте mydate */
newdate = mydate.toLocaleString() /* новая дата в виде строки */

Определим количество дней между двумя датами, например, 10 февраля 2004 и 5 марта 2004. Для этого создадим сначала два соответствующих объекта даты:
date1 = new Date(2004,01,10)
date2 = new Date(2004,02,5)

Переменные date1 и date2 содержат длинные строки, содержащие даты (например, Mon Feb 10 00:00:00 UTC+0300 2003). Чтобы перевести их в количества миллисекунд, воспользуемся методом parse() объекта Date. Затем вычислим разность Date.parse(date2) и Date.parse(date1) и разделим ее на количество миллисекунд в одних сутках:
days = (Date.parse(date2) - Date.parse(date1))/1000/60/60/24 // результат: 24

Мониста (CommandButton) все записи автора Объект Math (Математика)
Объект Math предназначен для хранения некоторых математических констант (например, число π) и выполнения преобразований чисел с помощью типичных математических функций. Доступ к свойствам и методам объекта Math обеспечивается следующими выражениями:
Math.свойство
Math.метод(параметры)

Свойства Math

Свойства объекта Math имеют в качестве своих значений математические константы.

Е постоянная эйлера
LN10 значение натурального логарифма числа 10
LN2 значение натурального логарифма числа 2
LOG10E значение десятичного логарифма экспоненты (числа e)
LOG2E значение двоичного логарифма экспоненты
PI значение постоянной p
SQRT1_2 значение квадратного корня из 1/2
SORT значение квадратного корня из 2

Методы Math

abs(число) — возвращает модуль (абсолютное значение) числа acos(число) — возвращает арккосинус числа asin(число) — возвращает арксинус числа atan(число) — возвращает арктангенс числа atan2(x, у) — возвращает угол в полярных координатах точки сеil(число) — округляет число вверх до ближайшего целого соs(число) — возвращает косинус числа еxp(число) — возвращает число е в степени число floor(число) — округляет число вниз до ближайшего целого log(число) — возвращает натуральный логарифм числа max(число1,число2) — возвращает большее из чисел число1, число2 min(число1,число2) — возвращает меньшее из чисел число1, число2 pow(число1,число2) — возвращает число1 в степени число2 random() — возвращает случайное число между 0 и 1 round(число) — округляет число до ближайшего целого sin(число) — возвращает синус числа sqrt(число) — возвращает квадратный корень из числа tan(число) — возвращает тангенс числа

Мониста (CommandButton) все записи автора 8.3. Объект Number (Число)
При разработке Web-страниц математические операции используются не столь часто, в отличии от строковых. Обычно они связаны с изменением координат элементов страницы (свойства top, left, width, height каскадной таблицы стилей). Однако встречаются и более сложные случаи. Например, может потребоваться вычислить статистические характеристики данных, содержащихся в некоторой таблице. Так или иначе, в этих задачах необходимо иметь дело с числами. О числах мы уже говорили в разделе, посвященном типам данных. Теперь рассмотрим их более подробно.

Числа в JavaScript

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

2 + 3 // 7 — целое число
2 + 3.6 // 5.6 — число с плавающей точкой
2.4 + 3.6 // 6 — целое число
6.00 // число с плавающей точкой

Числа можно представлять и в так называемой экспоненциальной форме, то есть в формате:
число1eчисло2 или число1Eчисло2. Такая запись числа означает число110число2 . Например:

1e5 // 100 000
2e6 // 2 000 000
1.5e3 // 1500
+1.5e3 // 1500
-1.5e3 // -1500
3e-4 // 0.0003

Числа в JavaScript можно представлять в различных системах счисления, то есть в системах с различными основаниями: 10 (десятичной), 16(шестнадцатеричной) и 8 (восьмеричной). К десятичной форме представления чисел мы привыкли, однако следует помнить, что числа в этой форме не должны начинаться с 0, потому что так записываются числа в 8-й системе. Запись числа в 16-й форме начинается с префикса 0x (или 0X), где первый символ ноль, а не буква О, затем следуют символы шестнадцатеричных цифр: 0, 1, 2,…,9,a,b,c,d,e,f (буквы могут быть в любом регистре). Например, шестнадцатеричное число 0x4af в десятичном представлении есть 1199). Запись числа в 8-й форме начинается с нуля, за которым следуют цифры от 0 до 7. Например, 027 (в десятичном представлении — 23).
В арифметических выражениях числа могут быть представлены в любой из перечисленных выше систем счисления, однако результат всегда приводится к десятичной форме.

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

Числа можно создавать обычным образом с помощью переменных и оператора присваивания, не прибегая к объекту Number. Однако этот объект обладает некоторыми полезными свойствами и методами, которые иногда могут пригодиться.
Объект Number создается с помощью выражения вида:
переменная = new Number(число)
Доступ к свойствам и методам строкового объекта обеспечивается такими выражениями:
число.свойство
Number.свойство

число.метод([параметры])
Number.метод([параметры])

Свойства Number


MAX_VALUE — константа, значение которой равно наибольшему допустимому в JavaScript значению числа (1.7976931348623157e+308).
MIN_VALUE — константа, значение которой равно наименьшему допустимому в JavaScript значению числа (5e-324).
NEGATIVE_INFINITY — число, меньшее, чем Number.MIN_VALUE
POSITIVE_INFINITY — число, большее, чем Number.MAX_VALUE
NaN — константа, имеющая значение NaN, посредством которой JavaScript сообщает, что данные (параметр, возвращаемое значение) не является числом (Not a Number).
prototype — свойство (прототип), играющее такую же роль, что и в случае объекта String (см. выше).

Методы Number

Объект Number имеет несколько методов, из которых мы рассмотрим только четыре, предназначенные для представления чисел в виде строки в том или ином формате.

toExponential(количество) — представляет число в экспоненциальной форме.
Синтаксис: число. toExponential(количество)
Возвращает строку. Совместимость: IE5.5+, NN6+.
Параметр представляет собой целое число, определяющее, сколько цифр после точки следует указывать.

toFixed(количество) — представляет число в форме с фиксированным количеством цифр после точки.
Синтаксис: число. toFixed(количество)
Возвращает строку. Совместимость: IE5.5+, NN6+.
Параметр представляет собой целое число, определяющее, сколько цифр после точки следует указывать.

toPrecision(точность) — представляет число с заданным общим количеством значащих цифр.
Синтаксис: число. toPrecision (точность)
Возвращает строку. Совместимость: IE5.5+, NN6+.
Параметр представляет собой целое число, определяющее, сколько всего цифр, до и после точки, следует указывать.

toString([основание]) — возвращает строковое представление числа в системе счисления с указанным основанием.
Синтаксис: число. toString([основание])
Возвращает строку. Если параметр не указан, имеется в виду десятичная система счисления.
Вы можете указать 2 для двоичной системы, или 16 — для шестнадцатеричной. Заметим, что этот метод имеют все объекты.

Мониста (CommandButton) все записи автора Методы Array

Методы объекта Array предназначены для управления данными, сохраненными в структуре массива.

сoncat(массив) — конкатенация массивов, объединяет два массива в третий массив.
Синтаксис: имя_массива1.concat(массив2)
Возвращает массив. Данный метод не изменяет исходные массивы.

join(разделитель) — создает строку из элементов массива с указанным разделителем между ними; является строкой символов (возможно, пустой)
Синтаксис: имя_массива.join(строка)
Возвращает строку символов.

pop() — удаляет последний элемент массива и возвращает его значение.
Синтаксис: имя_массива.pop()
Возвращает значение удаленного элемента массива. Совместимость: IE5.5+
Данный метод изменяет исходный массив.

push(значение|объект) — добавляет к массиву указанное значение в качестве последнего элемента и возвращает новую длину массива.
Синтаксис: имя_массива1.push(значение|объект)
Возвращает число.
Совместимость: IE5.5+
Данный метод изменяет исходный массив.

shift() — удаляет первый элемент массива и возвращает его значение.
Синтаксис: имя_массива.shift()
Возвращает значение удаленного элемента массива. Совместимость: IE5.5+, NN4+.
Данный метод изменяет исходный массив.

unshift(значение|объект) — добавляет к массиву указанное значение в качестве первого элемента.
Синтаксис: имя_массива.unshift(значение|объект)
Возвращает: ничего.
Совместимость: IE5.5+
Данный метод изменяет исходный массив.

reverse() — изменяет порядок следования элементов массива на противоположный.
Синтаксис: имя_массива.reverse()
Возвращает массив.
Данный метод изменяет исходный массив.

slise(индекс1 [, индекс2]) — создает массив из элементов исходного массива с индексами указанного диапазона.
Синтаксис: имя_массива. slise(индекс1 [, индекс2])
Возвращает массив. Данный метод не изменяет исходный массив.
Второй параметр (конечный индекс) не является обязательным, о чем свидетельствуют квадратные скобки в описании синтаксиса. Если он не указан, то создаваемый массив содержит элементы исходного массива, начиная с индекса индекс1 и до конца. В противном случае создаваемый массив содержит элементы исходного массива, начиная с индекса индекс1 и до индекса индекс2, за исключением последнего. При этом исходный массив остается без изменений.

sort([функция_сортировки]) — сортирует (упорядочивает) элементы массива с помощью функции сравнения.
Синтаксис: имя_массива. sort([функция_сравнения])
Возвращает массив. Данный метод изменяет исходный массив.
Параметр не обязателен, о чем свидетельствуют квадратные скобки.
Если параметр не указан, то сортировка производится на основе сравнения ASCII-кодов символов значений. Это удобно для сравнения символьных строк, но не совсем подходит для сравнения чисел. Так, число 357 при сортировке считается меньшим, чем 85, поскольку сначала сравниваются первые символы и только в случае их равенства сравниваются следующие, и т. д. Таким образом, метод sort() без параметра подходит для простой сортировки массива со строковыми элементами. Можно создать свою собственную функцию для сравнения элементов массива, с помощью которой метод sort() отсортирует весь массив. Имя этой функции (без кавычек и круглых скобок) передается методу в качестве параметра. При работе метода функции передаются два элемента массива, а ее код возвращает методу значение, указывающее, кокой из элементов должен следовать за другим. Допустим, сравниваются два элемента, x и y. Тогда в зависимости от числового значения (отрицательного, 0 или положительного), возвращаемого функцией сравнения, методом sort принимается одно из трех возможных решений:


Значение, возвращаемое функцией сравнения Результат сравнения x и y
<0 y следует за x
0 Порядок следования x и y не изменяется
>0 x следует за y

Итак, по какому критерию сортировать элементы массива, определяется кодом функции сравнения. Если элемент массива имеет значение null, то в Internet Explorer он размещается в начале массива.

splice(индекс, количество [, элем1 [, элем2 [, …элемN]]]) — удаляет из массива несколько элементов и возвращает массив из удаленных элементов, или заменяет значения элементов.
Синтаксис: имя_массива splice(индекс, количество [, элем1 [, элем2 [, …элемN]]])
Возвращает массив. Совместимость: IE5.5+. Данный метод изменяет исходный массив.
Первые два параметра обязательны, а следующие — нет. Первый параметр является индексом первого удаляемого элемента, а второй — количеством удаляемых элементов.
Метод splice() позволяет также заменить значения элементов исходного массива, если указаны третий и, возможно, последующие параметры. Эти параметры представляют значения, которыми следует заменить исходные значения элементов массива. При таком использовании метода splice() важен первый параметр (индекс), а второй (количество) может быть равным нулю. В любом случае, если количество элементов замены больше значения второго параметра, то часть элементов исходного массива будет заменена, а часть элементов будет просто вставлена в него. При этом метод splice() возвращает другой массив, состоящий из элементов исходного, индексы которых соответствуют первому и второму параметрам. Но это справедливо, если второй параметр не равен 0.

toLocaleString(), toString() — преобразуют содержимое массива в символьную строку.
Метод toLocaleString() поддерживается браузерами IE5.5+ и NN3+, а метод toString() — и более ранними версиями. Алгоритм преобразования по методу toLocaleString() зависит от версии браузера.
Для преобразования содержимого массива в строку рекомендую использовать метод join().

Мониста (CommandButton) все записи автора 8.2. Объект Array (Массив)
Массив представляет собой упорядоченный набор данных. Его удобно представить себе в виде одностолбцовой таблицы, содержащей некоторое количество строк. В ячейках такой таблицы могут находиться данные любого типа, в том числе и массивы. В последнем случае можно говорить о многомерных массивах (то есть о массивах массивов). Количество элементов в массиве (строк в таблице) называется длиной массива. К элементам массива можно обращаться в программе по их порядковому номеру (индексу). Нумерация элементов массива начинается с нуля, так что первый элемент имеет индекс 0, а последний — на единицу меньший, чем длина массива.
Массивы применяются во многих более или менее сложных программах обработки данных, а в некоторых случаях без них просто не обойтись. Если среди используемых данных есть группы таких, которые обрабатываются одинаковым образом, то, возможно, лучше организовать их в виде массива.

Создание массива

Существует несколько способов создания массива. В любом случае прежде всего создается новый объект массива с использованием ключевого слова new:
имя_массива = new Array([длина_массива])
Здесь длина_массива является необязательным числовым параметром, о чем говорят квадратные скобки. Если длина массива не указана, то создается пустой массив, не содержащий ни одного элемента. В противном случае создается массив с указанным количеством элементов, однако все они имеют значение null (то есть не имеют значений). Вы можете сначала создать пустой массив, а затем добавить к нему нужное количество элементов с помощью оператора присваивания. Заметим, что выражение с ключевыми словами new Array создает экземпляр (копию) объекта Array. У объекта Array имеется свойство length, значением которого является длина массива. Чтобы получить значение этого свойства, необходимо использовать выражение имя_массива.length. Создав массив, можно присвоить значения его элементам, используя для этого оператор присваивания. В левой части оператора присваивания указывается имя массива, а рядом с ним в квадратных скобках индекс элемента. Мы уже говорили, что к элементам массива обращаются по индексу: имя_массива[индекс]. Здесь квадратные скобки обязательны.

Рассмотрим создание массива earth, содержащего в качестве элементов некоторые характеристики нашей планеты. Обратите внимание, что элементы в этом массиве различных типов (строковые и числовые).

earth = new Array(4) // массив из 4-х элементов
earth[0] = "Планета"
earth[1] = "24 часа"
earth[2] = 6378
earth[3] = 365.25

earth.length // значение равно 4

Если нам потребуется значение, например, третьего элемента массива, то достаточно использовать выражение earth[2].

Другой способ создания массива заключается в непосредственном определении элементов в круглых скобках за ключевым словом Array. Например,
earth = new Array("Планета", "24 часа", 6378, 365.25)

JavaScript автоматически создает индексы для элементов массива, так что к элементам массива, созданного таким способом, также можно обращаться по индексам.

Третий способ создания массива — присвоить имя каждому элементу, подобно имени свойства объекта. Например,

earth = new Array() // пустой массив
earth.xtype = "Планета"
earth.xday = "24 часа"
earth.radius = 6378
earth.period = 365.25

В этом случае обращение к элементу происходит как к свойству объекта, например, earth.radius. Возможен и такой вариант: earth["radius"]. Однако по индексу к элементам в таком массиве обращаться нельзя.

Многомерные массивы

Массивы, рассмотренные выше, являются одномерными. Их можно представить себе в виде таблицы из одного столбца. Однако элементы массива могут содержать данные различных типов, в том числе и объекты, а значит и массивы. Если в качестве элементов некоторого одномерного массива создать массивы, то получится двумерный массив. Обращение к элементам такого массива происходит в соответствии со следующим синтаксисом:
имя_массива[индекс_уровня1] [индекс_уровня2]

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

Типичным примером двумерного массива является массив опций меню. У такого меню есть горизонтальная панель с опциями, называемая главным меню. Некоторым опциям главного меню соответствуют раскрывающиеся вертикальные подменю со своими опциями. Мы создаем массив, длина которого равна количеству опций главного меню. Элементы этого массива определяем как массивы названий опций соответствующих подменю. Чтобы была ясна структура нашей конструкции, мы выбрали названия опций надлежащим образом. Например, "Меню 2.1" — название 1-й опции подменю, соответствующего 2-й опции главного меню.

menu = new Array()
menu[0] = new array("Меню 1.1", "Меню 1.2", ", "Меню 1.3")
menu[1] = new array("Меню 2.1", "Меню 2.2")
menu[2] = new array("Меню 3.1", "Меню 3.2" , "Меню 3.3", "Меню 3.4")

Чтобы обратиться ко 2-й опции 3-го подменю, следует написать:
menu[2][1] // значение равно "Меню 3.2"

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

menu = new Array()
/* Массив опций главного меню: */
menu[0] = new Array("Меню1", "Меню2", "Меню3")
menu[1] = new Array()
menu[1][0] = new Array("Меню 1.1", "Меню 1.2", "Меню 1.3")
menu[1][1] = new Array("Меню 2.1", "Меню 2.2")
menu[1][2] = new Array("Меню 3.1", "Меню 3.2" , "Меню3.3", "Меню 3.4")

menu[0][1] // значение равно "Меню 2"
menu[0][2] // значение равно "Меню 3"
menu[1][1][0] // значение равно "Меню 2.1"
menu[1][2][3] // значение равно "Меню 3.2"

Копирование массива

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

Пример:

a = new Array(5, 2, 4, 3)
x = a // ссылка на массив a
a[2] = 25 // изменение значение элемента с индексом 2
x[2] // значение равно 25, то есть новому значению a[2]

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

a = new Array(5, 2, 4, 3)
x = new Array() // ссылка на массив a
for(i=0; i< a.length; i++) // копирование значений массива a в элементы массива x
{x[i] = a [i]}

Свойства Array

length — длина или, иными словами, количество элементов в массиве; целое число.
Синтаксис: имя_массива.length
Поскольку индексация элементов массива начинается с нуля, индекс последнего элемента на единицу меньше длины массива. Это обстоятельство удобно использовать при добавлении к массиву нового элемента: myarray[mayarray.length] = значение.

prototype — свойство (прототип), позволяющее добавить новые свойства и методы ко всем созданным массивам. Например, следующее выражение добавляет свойство author ко всем уже созданным массивам:
Array.prototype.author = "Иванов"
Если теперь вместо Array.prototype написать имя существующего массива, то можно изменить значение свойства author только для этого массива:
myarray = new Array() // создание массива myarray
xarray = new Array() // создание массива xarray
Array.prototype.author = "Иванов" /* добавление прототипа ко всем массивам */
myarray.author = "Иванов младший" /* изменение свойства author для myarray */
xarray.author = "Сидоров" /* изменение свойства author для xarray */
Прототипу можно присвоить функции. При этом они пополнят множество методов объекта Array.

Мониста (CommandButton) все записи автора 8. Встроенные объекты
Объекты представляют собой программные единицы, обладающие некоторыми свойствами. Об объекте мы можем судить по значениям его свойств и описанию того, как он функционирует. Программный код встроенных в JavaScript объектов нам не доступен. Встроенные объекты имеют фиксированные названия и свойства. Все свойства этих объектов разделяют на два вида: просто свойства и методы. Свойства аналогичны обычным переменным. Они имеют имена и значения. Некоторые свойства объектов доступны только для чтения. Это означает, что их значения нельзя изменять. Другие свойства доступны и для записи — их значения можно изменять с помощью оператора присваивания. Методы аналогичны функциям, они могут иметь или не иметь параметры. Чтобы узнать значение свойства объекта, необходимо указать имя этого объекта и имя свойства, отделив их друг от друга точкой: имя_объекта.свойство. Заметим, что объект может и не иметь свойств. Мы можем заставить объект выполнить тот или иной присущий ему метод. В этом случае также говорят о применении метода к объекту. Синтаксис соответствующего выражения такой: имя_объекта.метод(параметры). Заметим, что объект может не иметь методов. Итак, по синтаксису свойства отличаются от обычных переменных тем, что имеют составные имена, а также тем, что значения некоторых свойств нельзя измененить. Методы отличаются с точки зрения синтаксиса от обычных функций только тем, что имеют составные имена.
В свете изложенного выше, объект можно понимать как некоторый контейнер, содержащий переменные-свойства и функции-методы. Разумеется, в этом контейнере есть еще что-то, но оно скрыто от нас. Мы можем воздействовать на объект только с помощью свойств и методов. Встроенные объекты, как уже отмечалось, имеют фиксированные названия. Объекты с именами, совпадающими с их фиксированными названиями, называются статическими. Однако вы можете создать экземпляры (копии) статических объектов, присвоив им свои собственные имена. Экземпляры статических объектов являются объектами в вашей программе, которые наследуют от первых все их свойства и методы. Экземпляры объектов это некоторые частные воплощения в программе соответствующих статических объектов. Вместе с тем, вы можете использовать и статические объекты в чистом виде, не создавая никаких их копий. Например, для формульных вычислений используется статический объект Math, а в случае массивов создаются экземпляры статического объекта Array, содержащие конкретные данные, к которым применимы все общие методы и свойства статического объекта Array. Встроенные объекты имеют, среди прочих, свойство prototype (прототип), с помощью которого можно добавлять новые свойства и методы к уже существующим экземплярам объектов. Эти новые свойства и методы, разумеется, вы должны предварительно сами продумать и воплотить в виде программных кодов.
8.1. Объект String (Строка)
Объект String представляет интерес главным образом благодаря методам обработки строк. Он незаменим, когда требуется, например, найти позицию вхождения одной строки в другую, вырезать из строки некоторую ее часть, разбить строку на отдельные элементы и создать из них массив, и т. д.
С помощью объекта String можно создать строку как строковый объект. Однако в подавляющем большинстве случаев для этого достаточно использовать обычную переменную и оператор присваивания строкового значения. В этом случае интерпретатор все равно создает экземпляр (копию) строкового объекта, свойства и методы которого доступны из программного кода.

Создание строкового объекта
Для создания строкового объекта используется выражение следующего вида:

имя_переменной = new String("строковое_значение")

Здесь имя_переменной выполняет роль ссылки на строковый объект. Например, выражение mystring = new String("Привет!") создает строковый объект mystring со значением "Привет!" Однако можно создать строковый объект и с помощью обычного оператора присваивания:

имя_переменной = "строковое_значение"

или

var имя_переменной = "строковое_значение"

Доступ к свойствам и методам строкового объекта обеспечивается такими выражениями:

строка.свойство
String.свойство

строка.метод([параметры])
String.метод([параметры])

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

Пример:

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

mystring = "Однажды в студеную зимнюю пору"
mystring.length //значение равно 30
"Однажды в студеную зимнюю пору".length //значение равно 30

function fstring(){return "abcde"} //функция, возвращающая строку "abcde"
fstring().length //значение равно 5

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

Свойства String

length — длина или, иными словами, количество символов (включая пробелы) в строке; целое число.
Пример:

"Иван".length // значение равно 4
"Привет\nвсем".length /* значение равно 11 (\n — один символ перевода строки) */
x = "" // пустая строка
x.length // значение равно 0 (пустая строка имеет длину 0)

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

В приведенном ниже примере мы создаем новый метод для всех строковых объектов. Содержание этого метода определяется пользовательской функцией.

function myFunc() { // функция для нового метода
return "Вадим"
}
// Добавление нового метода myName к прототипу:
String.prototype.myName() = myFunc
mystring = "Автор этой книги — " + "Дунаев ".myName()
// значение mystring равно "Автор этой книги — Дунаев Вадим"

Методы String обработки строк

charAt(индекс) — возвращает символ, занимающий в строке указанную позицию.
Синтаксис: строка.charAt(индекс)
Возвращает односимвольную или пустую строку.
Параметр (индекс) является числом, индекс первого символа равен 0.

charCodeAt([индекс]) — преобразует символ в указанной позиции строки в его числовой эквивалент ( код).
Синтаксис: строка. charCodeAt([индекс])
Возвращает число.
IE4+ и NN6 поддерживают систему кодов Unicode , NN4 — ISO-Latin1.

fromСharCode(номер1 [, номер2 [, … номерN]]) — возвращает строку символов, числовые коды которой указаны в качестве параметров.
Синтаксис: String.fromСharCode(номер1 [, номер2 [, … номерN]])
Возвращает строку.
IE4+ и NN6 поддерживают систему кодов Unicode , NN4 — ISO-Latin1.

сoncat(строка) — конкатенация (склейка) строк.
Синтаксис: строка1.concat(строка2)
Возвращает строку.
Этот метод действует так же, как и оператор «+» сложения для строк: к строке строка1 приписывается справа строка строка2.

indexOf(строка_поиска [, индекс]) — производит поиск строки, указанной параметром, и возвращает индекс ее первого вхождения.
Синтаксис: строка.indexOf(строка_поиска [,индекс])
Возвращает число.
Метод производит поиск позиции первого вхождения строка_поиска в строку строка. Возвращаемое число (индекс вхождения) отсчитывается от 0. Если поиск не удачен, то возвращается –1. Поиск в пустой строке всегда возвращает –1. Поиск пустой строки всегда возвращает 0. Второй параметр, не являющийся обязательным, указывает индекс, с которого следует начать поиск. Этот метод хорошо использовать вместе с методом выделения подстроки substr() (см. ниже), когда требуется сначала определить позиции начала и конца выделяемой подстроки. Рассматриваемый здесь метод подходит для определения начальной позиции.

lastIndexOf( строка_поиска [, индекс]) — производит поиск строки, указанной параметром, и возвращает индекс ее первого вхождения; при этом поиск начинается с конца исходной строки, но возвращаемый индекс отсчитывается от ее начала, то есть от 0.
Синтаксис: строка.lastIndexOf(строка_поиска [,индекс])
Возвращает число.
Метод аналогичен рассмотренному выше indexOf()и отличается лишь направлением поиска.

localeCompare(строка) — позволяет сравнивать строки в кодировке Unicode, то есть с учетом используемого браузером языка общения с пользователем.
Синтаксис: строка1. localeCompare (строка2)
Возвращает число.
Совместимость: IE5.5+, NN6+
Если сравниваемые строки одинаковы, метод возвращает 0. Если строка1 меньше, чем строка2, то возвращается отрицательное число, в противном случае — положительное. Сравнение строк происходит путем сравнения сумм кодов их символов. Абсолютное значение возвращаемого числа зависит от браузера. Так, IE5.5 и IE6.0 возвращают 1 или –1, а NN6 — разность сумм кодов в кодировке Unicode.

slice( индекс1 [, индекс2]) — возвращает подстроку исходной строки, начальный и конечный индексы которой указываются параметрами, за исключением последнего символа.
Синтаксис: строка.slice(индекс1 [, индекс2])
Возвращает строку.
Данный метод не изменяет исходную строку.
Если второй параметр не указан, то возвращается подстрока с начальной позицией индекс1 и до конца строки. Отсчет позиций начинается с начала строки. Первый символ строки имеет индекс 0. Если второй параметр указан, то возвращается подстрока исходной строки, начиная с позиции индекс1 и до позиции индекс2, исключая последний символ. Если второй параметр отрицателен, то отсчет конечного индекса производится от конца строки. В этом заключается основное отличие метода slice() от substr(). Сравните также этот метод с методом substring().

split( разделитель [, ограничитель]) — возвращает массив элементов, полученных из исходной строки.
Синтаксис: строка.split(разделитель [, ограничитель])
Возвращает массив.
Первый параметр является строкой символов, используемой в качестве разделителя строки на элементы. Второй необязательный параметр — число, указывающее, сколько элементов строки, полученной при разделелении, следует включить в возвращаемый массив. Если разделитель — пустая строка, то возвращается массив символов строки.

substr(индекс [, длина]) — возвращает подстроку исходной строки, начальный индекс и длина которой указываются параметрами.
Синтаксис: строка.substr(индекс [, длина])
Возвращает строку.
Данный метод не изменяет исходную строку.
Если второй параметр не указан, то возвращается подстрока с начальной позицией индекс1 и до конца строки. Отсчет позиций начинается с начала строки. Первый символ строки имеет индекс 0. Если второй параметр указан, то возвращается подстрока исходной строки, начиная с позиции индекс1 и c общим количеством символов, равным длина. Сравните этот метод с методами slice() и substring().

substring(индекс1 , индекс2) — возвращает подстроку исходной строки, начальный и конечный индексы которой указываются параметрами.
Синтаксис: строка.substring(индекс1 , индекс2)
Возвращает строку.
Данный метод не изменяет исходную строку.
Порядок индексов не важен: наименьший из них считается начальным. Отсчет позиций начинается с начала строки. Первый символ строки имеет индекс 0. Символ, соответствующий конечному индексу, не включается в возвращаемую строку. Сравните этот метод с методами substr() и slice().

toLocaleLowerCase(), toLowerCase() — переводят строку в нижний регистр.
Синтаксис: строка.toLocaleLowerCase(), строка.toLowerCase()
Возвращают строку. Первый метод работает в IE5.5+, NN6, учитывает определенные языковые системы.
Приведение строк к одному и тому же регистру требуется, например, при сравнении содержимого строк без учета регистра. Кроме того, многие серверы чувствительны к регистру, в котором определены имена файлов и папки (обычно требуется, чтобы они были определены в нижнем регистре).

toLocaleUpperCase(), toUpperCase() — переводят строку в верхний регистр.
Синтаксис: строка.toLocaleUpperCase(), строка.toUpperCase()
Возвращают строку.
Первый метод работает в IE5.5+, NN6, учитывает определенные языковые системы.
Приведение строк к одному и тому же регистру требуется, например, при сравнении содержимого строк без учета регистра. Кроме того, многие серверы чувствительны к регистру, в котором определены имена файлов и папки.

Методы String форматирования строк

Как известно, тексты на Web-страницах обычно создаются и форматируются с помощью тэгов HTML. Однако тексты можно создавать на Web-страницах и с помощью сценариев. Например, чтобы вывести на Web-страницу строку "Привет всем!" полужирным шрифтом, в HTML-коде следует написать следующую инструкцию: < B>Привет всем!< /B>
Чтобы подготовить эту же строку в таком же формате средствами JavaScript, в сценарии следует написать такое выражение: "Привет всем!".bold()
Здесь использован метод bold() строкового объекта для форматирования строк. Выполнение этого выражения лишь создает отформатированную строку, но не выводит ее в окно браузера. Чтобы сделать это, следует еще выполнить метод write() объекта document для записи этой строки в HTML-документ. Методы форматирования строк носят названия, соответствующие тэгам HTML. Их особенность в том, что в отличие от тэгов, их следует записывать только в нижнем регистре (строчными буквами). Синтаксис такой же, как и у ранее рассмотренных методов: строка.метод(параметр)

Большинство методов форматирования не имеют параметров. Ниже приведен их список:

anchor("anchor_имя") link(расположение или URL)
blink() big()
bold() small()
fixed() strike()
fontcolor(значение_цвета) sub()
fontsize(число от 1 до 7) sup()
italics()

Мониста (CommandButton) все записи автора 7. Функции
Функция представляет собой подпрограмму, которую можно вызвать для выполнения, обратившись к ней по имени. Взаимодействие функции с внешней программой, из которой она была вызвана, происходит путем передачи функции параметров и приема от нее результата вычислений. Впрочем, функция в JavaScript может и не требовать параметров, а также ничего не возвращать. В JavaScript есть встроенные функции, которые можно использовать в программах, но код которых нельзя редактировать или посмотреть. Все, что мы можем узнать о них, это — описание их действия, параметров и возвращаемого значения. Кроме использования встроенных функций, вы можете создать свои собственные, так называемые пользовательские функции. Часто используемые фрагменты программного кода целесообразно оформлять в виде функций. Такой фрагмент кода заключаются в фигурные скобки, а перед ним пишется ключевое слово function, за которым следуют круглые скобки, обрамляющие список параметров. Чтобы вызвать функцию в программе, следует написать выражение в следующем формате: имя_функции (параметры) Если требуются параметры, то они указываются в круглых скобках через запятую. Функция может и не иметь параметров. В этом случае в круглых скобках ничего не указывается. Подробности использования функций изложены далее в этом разделе.
7.1. Встроенные функции
В JavaScript имеются следующие встроенные функции, некоторые из которых мы уже рассматривали выше. Хотя для иллюстрации работы этих функций приводится множество примеров, желательно выполнить их самому, а также придумать свои примеры, обращая внимание на крайние (даже абсурдные) случаи.

parseInt(строка, основание) — преобразует указанную строку в целое число; второй параметр указывает основание системы счисления (8, 10 или 16), в которой представлено число в строке; если основание не указано, то предполагается 10, то есть десятичная система счисления.

parseFloat(строка, основание) — преобразует указанную строку в число с плавающей разделительной (десятичной) точкой; второй параметр указывает основание системы счисления (8, 10 или 16), в которой представлено число в строке; если основание не указано, то предполагается 10, то есть десятичная система счисления.

isNaN (значение) — возвращает true, если указанное в параметре значение не является числом, иначе — false.

eval(строка) — вычисляет выражение в указанной строке; выражение должно быть написано на языке JavaScript (не содержит тэгов HTML).

еscape(строка) — возвращает строку в виде %XX, где XX — ASCII-код указанного символа; такую строку еще называют escape-последовательностью.

unescape(строка) — осуществляет обратное преобразование

При взаимодействии браузеров и серверов протоколы передачи данных позволяют передавать не все символы в их естественном виде. Для передачи остальных символов используются их шестнадцатеричные ASCII-коды, перед которыми указывается символ «%». Например, пробел представляется в escape-последовательности как %20.

typeOf(объект) — возвращает тип указанного объекта в виде символьной строки; например, "boolean", "function" и т. п.
7.2. Пользовательские функции
Пользовательские функции это функции, которые вы можете создать сами, по своему усмотрению, для решения своих задач. Функция задается своим определением (описанием ), которое начинается ключевым словом function. Точнее, описание функции имеет следующий синтаксис:

function имя_функции(параметры)
{
код
}
Часто определение функции записывают и в таких формах:

function имя_функции(параметры) {
код
}

function имя_функции(параметры) { код }

Имя функции выбирается так же, как и имя переменной. Не допустимо использовать в качестве имени ключевые слова языка JavaScript. За именем функции обязательно стоит пара круглых скобок. Программный код (тело) функции заключается в фигурные скобки. Они определяют группу выражений, которые относятся к коду именно этой функции. Если функция принимает параметры, то список их имен (идентификаторов) указывается в круглых скобках около имени функции. Имена параметров выбираются согласно тем же требованиям, что и имена обычных переменных. Если параметров несколько, то в списке они разделяются запятыми. Если параметры для данной функции не предусмотрены, то в круглых скобках около имени функции ничего не пишут. Когда создается определение функции, список ее параметров (если он необходим) содержит просто формальные идентификаторы (имена) этих параметров, понимаемые как переменные. В определении функции в списке параметров, заключенном в круглые скобки сразу же за именем функции после ключевого слова function, нельзя использовать конкретные значения и выражения. В этом смысле определение функции задает код, оперирующий формальными параметрами, которые конкретизируются лишь при вызове функции из внешней программы. Если требуется, чтобы функция возвращала некоторое значение, то в ее теле используется оператор возврата return с указанием справа от него того, что следует возвратить. В качестве возвращаемой величины может выступать любое выражение: простое значение, имя переменной или вычисляемое выражение. Оператор return может встречаться в коде функции несколько раз. Впрочем, возвращаемую величину, а также сам оператор return можно и не указывать. В этом случае функция ничего не будет возвращать.

ВНИМАНИЕ
Не путайте определение функции с ее вызовом, хотя и то, и другое могут находиться в одной и той же программе.

В JavaScript можно не поддерживать равенство между количествами параметров в определении функции и в ее вызове. Если в функции определены, например, три параметра, а в вызове указаны только два, то последнему параметру будет автоматически присвоено значение null. Наоборот, лишние параметры в вызове функции будут просто проигнорированы.

Мониста (CommandButton) все записи автора 6. Операторы
6.1. Комментарии
В JavaScript допустимы два вида оператора комментария:
// — одна строка символов, расположенная справа от этого оператора, считается комментарием;
/* …*/ — все, что заключено между /* и */ считается комментарием; с помощью этого оператора можно выделить несколько строк в качестве комментария.
6.2. Арифметические операторы
Арифметические операторы, такие как сложение, умножение и т. д., в JavaScript могут применяться к данным любых типов. Что из этого получается, мы рассмотрим немного позже. А сейчас просто перечислим их .

Арифметические операторы
Оператор Название Пример
+ Сложение X + Y
- Вычитание X - Y
* Умножение X * Y
/ Деление X / Y
% Деление по модулю X % Y
++ Увеличение на 1 X++
-- Уменьшение на 1 Y--

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


Оператор Пример Эквивалентное выражение
+= X+=Y X = X + Y
-= X-=Y X = X - Y
*= X*=Y X = X * Y
/= X/=Y X = X / Y
%= X%=Y X = X % Y

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

Оператор Название Пример
= = Равно X = =Y
!= Не равно X != Y
> Больше, чем X * Y
>= Больше или равно (не меньше) X >= Y
< Меньше, чем X < Y
<= Меньше или равно (не больше) X <= Y

ВНИМАНИЕ
Оператор «равно» записывается с помощью двух символов «=» без пробелов между ними.
6.5. Логические операторы
Логические данные, обычно получаемые с помощью элементарных выражений, содержащих операторы сравнения, можно объединять в более сложные выражения. Для этого используются логические (булевские) операторы —логические союзы И и ИЛИ, а также оператор отрицания НЕ. Например, нам может потребоваться сформировать сложное логическое условие следующего вида: «возраст не более 30 и опыт работы больше 10, или юрист». В этом примере есть и операторы сравнения, и логические операторы. Выражения с логическими операторами возвращают значение true или false.


Оператор Название Пример
! Отрицание (НЕ) !X
&& И X&&Y
|| ИЛИ X ||Y

Оператор отрицания «!» применяется к одному операнду, изменяя его значение на противоположное: если X имеет значение true, то !X возвращает значение false и наоборот, если X имеет значение false, то !X возвращает значение true. Ниже в таблице указано, какие значения возвращают операторы И и ИЛИ при различных логических значениях двух операндов.


X Y X&&Y X ||Y
true true true true
true false false true
false true false true
false false false false

Операторы «&&» и «||» еще называют логическим умножением и логическим сложением соответственно. Если вспомнить, что значению true можно сопоставить 1, а значению false — 0, то нетрудно понять, как вычисляются значения элементарных выражений с логическими операторами. Нужно только учесть, что в алгебре логики 1 + 1 = 1 (а не 2). Аналогично, оператору отрицания соответствует вычитание из единицы числового эквивалента логического значения операнда. В математике логические операции И и ИЛИ называют соответственно конъюнкцией и дизъюнкцией. Сложные логические выражения, состоящие из нескольких более простых, соединенных операторами И и ИЛИ, выполняются по так называемому принципу короткой обработки. Дело в том, что значение всего выражения бывает можно определить, вычислив лишь одно или несколько более простых выражений, не вычисляя остальные. Например, выражение x&&y вычисляется слева направо; если значение x оказалось равным false, то значение y не вычисляется, поскольку и так известно, что значение всего выражения равно false. Аналогично, если в выражении x || y значение x равно true, то значение y не вычисляется, поскольку уже ясно, что все выражение равно true. Данное обстоятельство требует особого внимания при тестировании сложных логических выражений. Так, если какая-нибудь составная часть выражения содержит ошибку, то она может остаться невыявленной, поскольку эта часть выражения просто не выполнялась при тестировании.
6.6. Операторы условного перехода
Вычислительный процесс можно направить по тому или другому пути в зависимости от того, выполняется ли некоторое условие, или нет. Этой цели служит операторы условного перехода if и switch. Оператор if Оператор условного перехода if позволяет реализовать структуру условного выражения если …, то …, иначе … Синтаксис оператора if перехода следующий:

if (условие)
{ код, который выполняется, если условие выполнено}
else
{ код, который выполняется, если условие не выполнено}

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

if (условие)
{ код, который работает, если условие выполнено}

Конструкция оператора условного перехода допускает вложение других операторов условного перехода. Условие обычно представляет собой выражение логического типа, то есть выражение, значение которого есть true или false. Обычно это элементарные выражения с операторами сравнения. Оператор switch Для организации проверки большого количества условий вполне достаточно использовать рассмотренный выше оператор if. Однако в случае нескольких условий более удобным и наглядным оказывается оператор switch (переключатель). Он особенно удобен, если требуется проверить несколько условий, которые не являются взаимоисключающими. Синтаксис оператора switch выглядит следующим образом:

switch (выражение) {
case вариант1:
код
[break]
case вариант2:
код
[break]
…
[default:
код]
}

Параметр выражение оператора switch может принимать строковые, числовые и логические значения. Разумеется, в случае логического выражения возможны только два варианта. Ключевые слова (операторы) break и default не являются обязательными, что отражено с помощью прямоугольных скобок. Здесь они являются элементами описания синтаксиса, и при написании операторов их указывать не нужно. Если оператор break указан, то проверка остальных условий не производится. Если указан оператор default, то следующий за ним код выполняется, если значение выражения выражение не соответствует ни одному из вариантов. Если все варианты возможных значений предусмотрены в операторе switch, то оператор default можно не использовать. Оператор switch работает следующим образом. Сначала вычисляется выражение, указанное в круглых скобках сразу за ключевым словом switch. Полученное значение сравнивается с тем, которое указано в первом варианте. Если они не совпадают, то код этого варианта не выполняется и происходит переход к следующему варианту. Если же значения совпали, то выполняется код, соответствующий этому варианту. При этом, если не указан оператор break, то выполняются коды и остальных вариантов, пока не встретится оператор break. Это же правило действует и для остальных вариантов.
6.7. Операторы цикла
Оператор цикла обеспечивает многократное выполнение блока программного кода до тех пор, пока не выполнится некоторое условие. В JavaScript предусмотрены три оператора цикла: for, while и do-while. Вообще говоря, при создании программ вполне можно обойтись одним из них, for или while. Мне, например, больше нравится while. Однако возникают ситуации, в которых один из операторов более удобен или естественен, чем другой.

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

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

Здесь квадратные скобки лишь указывают на то, что заключенные в них параметры не являются обязательными.
Все, что находится в круглых скобках справа от ключевого слова for, называется заголовком оператора цикла, а содержимое фигурных скобок — его телом. В заголовке оператора цикла начальное выражение выполняется только один раз в начале выполнения оператора. Второй параметр представляет собой условие продолжения работы оператора цикла. Он аналогичен условию в операторе условного перехода if. Третий параметр содержит выражение, которое выполняется после выполнения всех выражений кода, заключенного в фигурные скобки. Оператор цикла работает следующим образом. Сначала выполняется начальное выражение. Затем проверяется условие. Если оно выполнено, то оператор цикла прекращает работу (при этом код не выполняется). В противном случае выполняется код, расположенный в теле оператора for, то есть между фигурными скобками. После этого выполняется выражение обновления (третий параметр оператора for). Так заканчивается первый цикл или, как еще говорят, первая итерация цикла. Далее, снова проверяется условие и все повторяется описанным выше способом.

Оператор while
Оператор цикла while (до тех пор, пока) имеет структуру, более простую, чем оператор for, и работает несколько иначе. Синтаксис этого оператора следующий:

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

При выполнении этого оператора сначала производится проверка условия, указанного в заголовке, то есть в круглых скобках справа от ключевого слова while. Если оно выполняется, то выполняется код в теле оператора цикла, заключенного в фигурные скобки. В противном случае код не выполняется. При выполнении кода (завершении первой итерации) вычислительный процесс возвращается к заголовку, где снова проверяется условие, и т. д. Если сравнивать оператор while c оператором for, то особенность первого заключается в том, что выражение обновления записывается в теле оператора, а не в заголовке. Часто забывают указать это выражение, и в результате цикл не завершается (программа «зависает»).

Оператор do-while
Оператор do-while (делай до тех пор, пока) представляет собой конструкцию из двух операторов, используемых совместно. Синтаксис этой конструкции следующий:

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

В отличие от оператора while в операторе do-while код выполняется хотя бы один раз, независимо от условия. Условие проверяется после выполнения кода. Если оно истинно, то снова выполняется код в теле оператора do. В противном случае работа оператора do-while завершается. В операторе while условие проверяется в первую очередь, до выполнения кода в теле. Если при первом обращении к оператору while условие не выполняется, то код не будет выполнен никогда.