Изображение: Блок-схема документа

Стр 1 из 5Следующая ⇒

Nbsp; СОДЕРЖАНИЕ Стр. Введение - цель, место, дата начала и продолжительность учебной практики (практика по получению первичных профессиональных умений и навыков, в том числе первичных умений и навыков научно-исследовательской деятельности) 3 - перечень работ, выполненных в процессе учебной практики (практика по получению первичных профессиональных умений и навыков, в том числе первичных умений и навыков научно-исследовательской деятельности) 3 1. Теоретическая часть 4 1.1. Язык сценариев JavaScript. 1.2. Операторы и функции. 1.3. Формы и циклы. 1.4. Функции и концепция объектов. 1.5. Строки, числа и массивы. 1.6. Объектная модель документа. 1.7. Объект документа и объект окна. 1.8. Основы объектно-ориентированного программирования. 1.9. Наследование и замыкание. 1.10. Основы приложений AJAX. 1.11. Обработка ошибок в JavaScript. 1.12. Рекурсия. 4 6 10 15 19 25 31 37 42 46 52 58 2. Практическая часть 62 2.1. Решение задач по примерам готовых скриптов вариант №5 62 2.1.1. Задача №2 62 2.1.2. Задача №8 63 2.1.3. Задача №17 65 2.1.4. Задача №20 68 Выводы 70 - навыки, приобретенные в процессе учебной практики (практика по получению первичных профессиональных умений и навыков, в том числе первичных умений и навыков научно-исследовательской деятельности) Список использованной литературы 71 Приложение №1. Задание на учебную практику Приложение №2. Дневник учебной практики Приложение №3. Отзыв руководителя о прохождении учебной практики Приложение №4. CD-диск с электронным отчетом по рассредоточенной учебной практике

Введение

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

Место прохождения рассредоточенной учебной практики: кафедра «Информатика и технология программирования» Волжского политехнического института (филиал) ВолгГТУ.

Дата начала прохождения рассредоточенной учебной практики: 09 января 2018 г.,

Продолжительность прохождения рассредоточенной учебной практики: 216 часов.

Перечень работ, выполненных в процессе рассредоточенной учебной практики:

1) Сбор и изучение научно-технической информации, отечественного и зарубежного опыта в области программирования на JavaScript;

2) Решение задач по примерам готовых скриптов;

3) Разработка и отладка программы, реализующей заданный алгоритм.

Теоретическая часть

1.1. Язык сценариев JavaScript.

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

Так как JavaScript является в настоящее время единственным языком сценариев, который поддерживают все основные браузеры Web ( Internet Explorer, Firefox, Netscape, Safari, Opera, Camino и т.д.), то он используется очень широко.

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

При создании кода JavaScript требуется фактически только текстовый редактор и Web-браузер. Знание HTML и CSS будет играть определенно положительную роль, и если вы захотите использовать навыки JavaScript на Web-сайте, то понадобится также Web-сайт. Если у вас уже есть Web-сайт, то отлично! Если нет, то существует множество бесплатных серверов, которые можно использовать для размещения своих страниц.

Что касается текстового редактора, то в Windows имеется редактор NotePad. Хотя этого будет достаточно для редактирования JavaScript, HTML и CSS, более мощный редактор, такой, например, как EditPlus или другой, может оказаться более удобным.

Ну, а теперь можно перейти к созданию сценария JavaScript!

Прежде всего, необходимо узнать, как добавить сценарий JavaScript на страницу HTML. Это можно сделать одним из двух способов: поместить теги Script на Web-странице и расположить код JavaScript внутри этих тегов, или поместить весь код JavaScript в отдельный файл и связаться с ним с помощью тега Script.

Любой из этих методов вполне допустим, но они имеют разное назначение. Если имеется небольшой код, который будет использоваться только на одной странице, то размещение его между тегами Script будет хорошим решением. Если, однако, имеется большой фрагмент кода, который будет использоваться на нескольких страницах, то, наверно, лучше поместить этот код JavaScript в отдельный файл и соединиться с ним. Это делается для того, чтобы не нужно было загружать этот код всякий раз при посещении различных страниц. Код загружается один раз, и браузер сохраняет его для последующего использования. Это похоже на то, как используются каскадные таблицы стилей ( CSS ).

Ниже приведены примеры двух способов подключения кода JavaScript:

В первом примере, код JavaScript помещается между символами > и <, прямо перед </script>. Если вы совершенно не знаете, как работает Web-страница, то вот пример того, как устроена страница HTML:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

<HTML>

<HEAD>

<TITLE> Здесь располагается заголовок страницы </TITLE>

</SCRIPT>

</HEAD>

<BODY>

Здесь располагается основная содержательная часть Web-страницы (тело).

</BODY>

</HTML>

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

Почти любой язык программирования в мире имеет дело с объектами, называемыми "переменными", и JavaScript не является исключением. Переменная является просто элементом данных с присоединенным к нему именем. Она может содержать число, слово или предложение (называемые строками - String ) или объект ( Object ), о которых будет рассказано позже. Если коду необходимо сообщить, что имеется 5 яблок, то можно создать переменную с именем apples и задать ей значение 5. Давайте сейчас это сделаем. В JavaScript для определения переменной используется ключевое слово var. Отметим, что JavaScript различает регистр символов, поэтому var означает не то же самое, что VAR или Var.

var apples = 5;

Необходимо сделать два важных замечания в отношении этого небольшого фрагмента кода. Первое: требуется помнить о том, что JavaScript является "слабо типизированным" языком. Это означает, что при определении переменных не требуется указывать, какого они типа: будут ли они числами, строками, объектами, и т.д. Во многих других языках необходимо делать это различие.

Второе: обратите внимание на точку с запятой ( ; ) в конце строки. Это говорит интерпретатору JavaScript, что вы закончили делать то, что делали в данный момент, - в нашем случае это задание значения 5 переменной apples. Хотя точка с запятой не является обязательной в JavaScript, лучше привыкнуть ее использовать.

Итак, мы определили в коде, что имеется 5 яблок. Что дальше? Информация о яблоках имеется в коде, но никто об этом не знает. Надо сообщить о яблоках! Одним из наиболее распространенных методов вывода простого сообщения пользователю является отправка уведомления ( alert ):

var apples = 5;

alert('Имеется ' + apples + ' яблок!');

Если протестировать этот сценарий, то на экране появится окно с сообщением " Имеется 5 яблок!" Сейчас подходящее время, чтобы ввести строки ( String ) и так называемую конкатенацию или соединение строк. Строка является просто небольшим фрагментом текста и может содержать любой текст. В JavaScript мы сообщаем коду, что имеется строка, заключая ее в одиночные или двойные кавычки ( " или ' ). Можно использовать любой тип кавычек. Знаки плюс ( + ) в примере выше сообщают коду, что мы соединяем строку с предыдущей строкой.

Итак мы имеем строку " Имеется " за которой следует переменная apples (равная 5 ), за которой следует еще одна строка " яблок!". Соединим их вместе и получим " Имеется 5 яблок!". Команда alert получает то, что ей передается (то, что находится между скобок) и открывает окно с текстом.

Что если мы хотим предложить пользователю съесть яблоко? Можно, например, спросить, сколько яблок он хотел бы съесть:

var apples = 5;

alert('Имеется ' + apples + ' яблок!');

var eat = prompt('Сколько яблок вы хотите съесть?', '1');

prompt является другой встроенной функцией, аналогичной alert. Однако вместо простого вывода информации она также получает ввод от пользователя. В данном случае мы спрашиваем у пользователя, сколько яблок он хотел бы съесть. '1' в коде сообщает функции prompt, что значением по умолчанию для количества яблок будет 1, так как люди обычно едят только одно яблоко за раз. Однако пользовательможет изменить это значение на любое другое. Когда пользователь щелкнет на кнопке OK, переменной eat будет задано значение этого ввода. Поэтому если пользователь введет 2, то eat будет равно 2.

Поэтому, если пользователь съел 2 яблока, то останется 3, так? Поэтому выполним несколько простых математических операций и покажем результат.

var apples = 5;

alert('Имеется ' + apples + ' яблок!');

var eat = prompt('Сколько яблок вы хотите съесть?', '1');

apples -= parseInt(eat);

alert('А теперь имеется только ' + apples + ' яблок!');

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

Затем, оператор -=, который означает вычитание из левой части оператора значения правой части. Поэтому значение переменной eatвычитается из переменной apples. Можно также записать эту строку следующим образом:

apples = apples - parseInt(eat);

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

Существуют другие операторы, подобные -=, которые делают похожие вещи. Всего имеется 8 обычных арифметических операторов:

1.2. Операторы и функции.

При тестировании сценария, написанного в "предыдущей лекции" , можно заметить, что результат, получаемый из prompt, требует некоторой проверки. Когда сценарий спрашивает, сколько яблок желает съесть пользователь, то пользователь может ввести число больше 5, меньше 0или что-то, что вообще не является числом. В каждом из таких случаев желательно информировать пользователей, что введено недопустимое значение

Так как в этом сценарии имеется только 5 яблок, то это максимальное количество яблок, которое может получить пользователь. Поэтому начнем с проверки, что введенное число не больше 5.

var apples = 5;

alert('Имеется ' + apples + ' яблок!');

var eat = prompt('Сколько яблок вы хотите съесть?', '1');

var eaten = parseInt(eat);

if(eaten > 5){

alert('Простите, но имеется только 5 яблок.' + 'Вы не можете съесть ' + eaten + ' яблок!');

} else {

apples -= eaten;

alert('А теперь имеется только ' + apples + ' яблок!');

}

Основными новыми понятиями здесь являются операторы if и else. Операторы if и else достаточно легко понять. Приведенный выше код дает возможность сказать: "Если пользователь выбрал для еды более 5 яблок, то сообщите ему, что такого количества яблок нет. Иначе позвольте ему съесть столько яблок, сколько он попросит.".

Основной синтаксис оператора if / else следующий:

if(условие){

// код, который выполняется, когда справедливо условие if

} else {

// код, который выполняется, когда условие if ложно

}

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

Две косые черты // в приведенном примере говорят коду, что здесь находится комментарий. Комментарий является частью кода, который не выполняется. Они обычно используются для описания функций реального кода, чтобы не требовалось изучать код для выяснения, что он делает. Если, например, имеется очень длинный фрагмент кода, который проверяет входящие данные формы, то будет вполне разумно вставить комментарий, говорящий что-нибудь вроде " Следующий код проверяет ввод пользователя в форму ". В этом случае любой, кто будет просматривать код, или сам автор кода несколько месяцев спустя после написания, сразу поймет, что этот код делает.

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

// это однострочный комментарий

если требуется более длинный комментарий, то

лучше использовать "блочный комментарий".

Этот комментарий является блочным комментарием,

и полностью игнорируется при выполнении кода

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

Вернемся к нашему оператору if,

if(eaten > 5){

alert('Простите, но имеется только 5 яблок.

Вы не можете съесть ' + eaten + ' яблок!');

} else {

apples -= eaten;

alert('А теперь имеется только ' + apples + ' яблок!');

}

Можно видеть, что условием является eaten > 5. Знак > означает " больше чем ", так что это условие означает " если eaten больше 5". Аналогично, < означает " меньше чем ".

Существует два других аналогичных знака >= и <=, которые означают " больше чем или равно " и " меньше чем или равно " соответственно.

В приведенном выше коде мы сообщаем пользователю о том, что он ввел значение больше 5 яблок. Только если он выбрал не более 5яблок, это число вычитается из текущего количества яблок и затем пользователю сообщается, сколько яблок осталось. Однако существует еще два возможных случая. Что, если пользователь введет число меньше 0? Что, если он введет значение, которое не является числом? Первый случай читатель может теперь обработать самостоятельно. Второй случай требует использования другой встроенной функции, isNaN. При попытке преобразовать что-нибудь в число с помощью функции parseInt, возвращается значение NaN, если функция не может выполнить операцию. NaN означает Not a Number (Не число). Если вызвать функцию parseInt, например, со значением apple, то будет получено значение NaN, так как слово apple не является числом.

var apples = 5;

alert('Имеется ' + apples + ' яблок!');

var eat = prompt('Сколько яблок вы хотите съесть?', '1');

var eaten = parseInt(eat);

if(isNaN(eaten)){

alert('Вы должны ввести допустимое число яблок!');

} else if(eaten > apples){

alert('Простите, но имеется только ' + apples + ' яблок.

Вы не можете съесть ' + eaten +

' яблок!');

} else if(eaten < 0){

alert('Простите, но вы не можете съесть

отрицательное количество яблок!');

} else {

apples -= eaten;

alert('А теперь имеется только ' + apples + ' яблок!');

}

Теперь все это должно быть понятно читателю. Прежде всего проверяется, что введено допустимое значение. Если значение недопустимо, выводится соответствующее сообщение. Затем проверяется, что введенное число не превышает количество существующих яблок, а затем - что это число не является отрицательным. Если все эти проверки проходят успешно, пользователь сможет съесть столько яблок, сколько захочет. В коде сделано еще одно изменение, вместо if(eaten > 5) используется if(eaten > apples). Если в последующем количество имеющихся яблок var apples = 5; изменится, то это изменение пришлось бы делать только в одном месте. Старайтесь всегда использовать в коде переменные. Если значения "жестко закодированы", как было сделано ранее в коде if(eaten > 5), то очень часто при внесении изменений придется подолгу искать эти жестко закодированные значения, чтобы убедиться, что внесены все необходимые изменения.

Если пользователь ввел каким-либо образом недопустимое значение, то можно попросить его повторно ввести количество яблок, которое он хочет съесть. Одним из способов сделать это было бы копирование всего кода несколько раз. Однако обычно это не самое лучшее решение. Что, если пользователь вводит недопустимое значение снова и снова? Можно продолжить копирование кода, но легко видеть, что это крайне неэффективно и очень трудно поддерживать код в рабочем состоянии.

В этом случае лучшим решением будет использование так называемой функции. Функция содержит код, который выполняет определенную задачу. Мы уже видели использование функций alert, prompt, parseInt и isNaN, которые встроены в язык JavaScript. Преимущество использования функций состоит в том, что можно выполнять один и тот же блок кода снова и снова, не копируя этот код, Для выполнения функции необходимо написать ее имя, за которым следуют скобки (), а все значения, передаваемые в функцию, записываются между скобками.

Здесь весь наш код записан в виде функции с именем eatApples. Можно видеть, что каждый раз, когда пользователь вводит неверное значение, снова вызывается функция eatApples();, чтобы пользователь мог ввести новое значение. Когда пользователь вводит допустимое значение, то он либо может еще есть яблоки, либо, если все яблоки закончились, он получит соответствующее сообщение. Здесь используется также одна новая функция, confirm. Функция confirm просто выводит пользователю приглашение OK or Cancel ("Да или Отмена"). Если пользователь нажмет кнопку " OK ", то функция возвращает значение true (да). Если пользователь нажмет кнопку Cancel или просто закроет окно, то функция confirm возвращает значение false (нет). Поэтому в нашем примере функция eatApples вызывается снова только в том случае, когда пользователь щелкнет на кнопке OK.

В конце этой лекции будет рассмотрена область действия переменной. Как можно видеть, в последнем примере переменная apples находится вне функции eatApples. Это делает переменную apples "глобальной переменной", т.е. она будет доступна из любой функции. Переменнаяeat, с другой стороны, является локальной переменной и существует только внутри функции eatApples. Кроме того, каждый раз при вызове функции eatApples переменная eat не будет существовать, пока не будет снова определена функцией prompt.

Чтобы увидеть эту концепцию в действии, напишем две простые функции счета:

function counting1(){ var count = 0; count++; alert(count);} var count = 0;function counting2(){ count++; alert(count);}

Если запустить этот пример в браузере и щелкнуть на каждой кнопке несколько раз, то можно заметить, что counting1 всегда выдает одно и то же значение, 1. counting2, с другой стороны, выдает увеличивающееся число. Почему это происходит? Посмотрим просто сначала на counting1. Можно видеть, что каждый раз при выполнении counting1 прежде всего создается переменная count и ее значение задается равным 0. В следующей строке переменная count увеличивается на 1.

Оператор ++ пока еще не встречался. count++ просто увеличивает count на 1. Другими словами, это в точности то же самое, что написать count += 1 или count = count + 1. Поскольку увеличение на 1 является в программировании очень распространенным действием, то для него существует специальный оператор. Аналогично оператор -- вычитает 1 из переменной: count--.

Каждый раз, когда функция counting1 выполняет alert(count), она сообщает значение новой переменной count, которое только что было определено как 0+1.

Теперь посмотрим на counting2. Можно видеть, что переменная count в этом случае находится вне функции. Даже до вызова этой функции значение count задано как 0. При вызове counting2 прежде всего происходит увеличение переменной count на 1. Так как мы не восстанавливаем значение count в 0, как в случае counting1, то переменная count продолжает сохранять свое значение, и все происходит, как и предполагалось.

1.3. Формы и циклы.

Мы знаем теперь, как проверять данные, но при создании кода JavaScript обычно требуется проверять не оставшееся количество воображаемых яблок. Одной из наиболее общих областей применения JavaScript являются поля формы. Предположим, например, что имеется простая контактная форма. Иногда требуется убедиться, что пользователь ввел в форму свое имя или что он выбрал как минимум одну радио-кнопку для вопроса. Вот пример такой формы:

Имя: Ваш любимый цвет: Синий Желтый

Красный Черный

Зеленый Другой

Фамилия:

Адрес Email:

Отправить форму Очистить форму Зафиксировать форму на месте

Ниже представлен код этой формы. Он приведен только для иллюстрации.

<form name="tutform" onsubmit="return noform();" class="codesnip"

style="background-color:#FFF;z-index:10;">

<table

<tr>

<td>Ваш любимый цвет:</td>

<td rowspan="3"

<input type="radio" name="color" value="blue">Синий<br />

<input type="radio" name="color" value="red">Красный<br />

<input type="radio" name="color" value="green">Зеленый

</td>

<td rowspan="3"

<input type="radio" name="color" value="yellow">Желтый<br />

<input type="radio" name="color" value="black">Черный<br />

<input type="radio" name="color" value="other">Другой

</td>

</tr>

<tr>

<td>Фамилия:</td>

</tr>

<tr>

<td>Адрес Email:</td>

</tr>

<tr>

<td colspan="3" align="right"><button id="lockbutton"

onclick="swapLock();return false;">Зафиксировать форму на месте</button></td>

</tr>

</table>

</form>

Прежде всего необходимо узнать, как создать объект JavaScript, который ссылается на форму. Любую форму на странице можно указать с помощью конструкции document.forms. Если имеется форма с именем tutform, то к ней можно обратиться следующим образом: document.forms.tutform.

На любые элементы внутри формы (поля ввода, поля выбора, флажки и т.д) можно ссылаться с помощью конструкции elements: document.forms.ИмяФормы.elements. Если на форме имеется поле ввода с именем firstname, то значение этого поля можно вывести следующим образом:

alert('Имя: ' + document.forms.tutform.elements.firstname.value);

Если щелкнуть на этой кнопке, а затем отправить учебную форму, то появится уведомление с тем значением, которое было введено в полеИмя. Как это происходит? Когда форма посылается на сервер, Web-браузер ищет код onsubmit. Если этот код существует, то форма выполняет его перед отправкой:

function validateForm(){

// код проверки формы находится здесь

}

</SCRIPT>

</FORM>

Теперь, зная, как получить доступ к форме и элементам на этой форме, выполним некоторые основные проверки. Распространенной задачей является проверка, что именно пользователь ввел в поле ввода. Например, надо проверить, что пользователь ввел свое имя.

Как видно из предыдущего фрагмента кода, свойство " .value " объекта формы можно использовать для получения его значения. Это работает для объектов формы любого типа. Попробуем теперь проверить, что пользователь ввел на форме свои имя и фамилию:

function validateForm(){

var form_object = document.forms.tutform;

if(form_object.elements.firstname.value == ''){

alert('Вы должны ввести свое имя!');

return false;

} else if(form_object.elements.lastname.value == ''){

alert('Вы должны ввести свою фамилию!');

return false;

}

return true;

}

Важными моментами, которые необходимо отметить в этой функции, являются строки return false ; и return true ;. Если функцияпроверки возвращает значение true, то форма будет отправлена как обычно. Если, однако, функция вернет значение false, то форма отправлена не будет. Необходимо сообщить пользователю, почему форма не была отправлена, поэтому в функцию вставлены уведомления ( alert ).

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

Радио-кнопки и флажки на форме представляют специальную ситуацию. Часто имеется несколько радио-кнопок с одним и тем же именем, что почти всегда исключено для полей ввода, полей выбора и т.д.:

<input type="radio" name="color" value="blue">Синий

<input type="radio" name="color" value="red">Красный

<input type="radio" name="color" value="green">Зеленый

В связи с этим существует способ доступа ко всем радио-кнопкам с одним именем. Значениеdocument.forms.имяФормы.elements.имяРадиокнопок будет содержать список со всеми радио-кнопками. Так как необходимо проверить, что хотя бы одна радио-кнопка отмечена, то потребуется просмотреть все эти радио-кнопки. Если хотя бы одна из них отмечена, функция проверки должна вернуть true. Поэтому функция выглядит теперь следующим образом:

function validateForm(){

var radios = document.forms.tutform.elements.color;

for(var i=0; i<radios.length; i++){

if(radios[i].checked) return true;

}

alert('Вы должны выбрать цвет!');

return false;

}

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

for(var i=0; i<radios.length; i++)

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

var i=0

i<radios.length

i++

Первое значение является просто заданием значения переменной. Это должно быть теперь понятно без проблем. Второе значение является условием проверки. Цикл for будет выполняться, пока это условие проверки возвращет true. Как только оно вернет false, цикл forостановится и выполнение кода продолжится со следующей строки. Поэтому условие i<radios.length говорит, что цикл for должен выполняться, пока переменная i меньше числа имеющихся радио-кнопок.

" length " в данном случае является свойством массива. Мы пока еще не встречались с массивами, но, упрощая, можно сказать, что radios.length возвращает просто число элементов в radios, которое в данном случае равно 6, так как имеется только 6 радио-кнопок. Последнее выражение цикла for, i++, является кодом, который должен выполняться после каждого шага цикла.

Говоря более простым языком, цикл for делает следующее:

1. задает i равным 0 ;

2. проверяет, что i меньше radios.length, которое равно 6 ;

3. если это справедливо ( true ), выполняет код в цикле for ;

4. после выполнения кода в цикле for добавляет 1 к переменной i ;

5. переходит к шагу 2, пока выполняется условие i<radios.length. Это условие не выполнится после шестого выполнения цикла, когда i=6.

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

var i=0;

while(i<radios.length){

if(radios[i].checked) return true;

i++;

}

alert('Вы должны выбрать цвет!');

return false;

Можно видеть, что здесь в цикле while присутствуют точно те же 3 фрагмента кода, которые имелись в цикле for: " var i=0 ", " i<radios.length " и " i++ ". Единственное отличие состоит в их размещении. В цикле while только проверка

i<radios.length

чем-то отличается от того, что было написано раньше. Эта проверка происходит в скобках сразу после while. Переменные инициализируются перед циклом while, а увеличение i, i++, происходит внутри цикла.

В этих циклах осталось объяснить еще одну вещь: if(radios[i].checked). Переменная radios содержит массив радио-кнопок с именем color. Массивы будут рассмотрены в " следующей лекции" , а здесь дадим упрощенное объяснение: radios[0] возвращает первую радио-кнопку, radios[1] возвращает вторую, radios[2] - третью, и т.д. до radios[5], который возвращает шестую кнопку. Если кнопок будет больше, например, 100, то radios[99] будет обращаться к 100 -ой радио-кнопке.

Все эти числа могут показаться странными. Почему radios[5] обращается к шестой радио-кнопке? В JavaScript, как и во многих других языках программирования, многие вещи начинаются с числа 0, а не с 1. Это просто один из таких случаев, но это встретится еще не раз. Поэтому 0 является в действительности первым элементом, 1 - вторым, и т.д.

В форме осталось проверить еще ввод адреса e-mail. Это в действительности достаточно сложное для проверки поле, и правильная ее реализация выходит за рамки того, что изучается в этой лекции, но можно выполнить некоторую базовую проверку. Что нужно сделать? Мы знаем, что любой адрес e-mail должен содержать один и только один символ @. Он должен также содержать по крайней мере одну точку после символа @ (точка отделяет имя домена от домена верхнего уровня, например, " intuit.ru ").

function validateForm(){

var email = document.forms.tutform.elements.email.value;

if(email.indexOf('@')<0){

alert('В адресе e-mail должен присутствовать символ @');

return false;

} else if(email.indexOf('@') != email.lastIndexOf('@')){

alert('В адресе e-mail не может быть больше одного символа @');

return false;

} else if(email.indexOf('.')<0){

alert('В адресе e-mail должна присутствовать хотя бы одна точка.');

return false;

} else if(email.lastIndexOf('.')<email.indexOf('@')){

alert('В адресе e-mail должна присутствовать хотя бы одна точка после символа @');

return false;

}

return true;

}

Здесь имеются две новые сходные функции, которые требуют пояснения. Функция indexOf возвращает число, определяющее позицию одной строки в другой строке. 'abcdef'.indexOf('a') вернет 0 (здесь 0 снова означает первую позицию). 'abcdef'.indexOf('cdef') вернет 2, а 'abcdef'.indexOf('aaa') вернет -1. -1 означает, что строка не найдена. Во многих случаях возвращается -1, когда функция не может получить результат.

Аналогично, функция lastIndexOf возвращает позицию последнего вхождения одной строки в другую. 'abcba'.lastIndexOf('a') вернет 4, в то время как 'abcba'.indexOf('a') вернет 0.

Поэтому в нашем коде первый оператор if проверяет, что в адресе e-mail имеется хотя бы один символ '@'. Если такого символа нет, то email.indexOf('@') вернет -1 и оператор if вернет false.

Следующий оператор соединяет indexOf и lastIndexOf. Если в адресе e-mail имеется более одного символа @, то две эти функции вернут различные значения, как в приведенном выше примере с 'abcba'. Если имеется только один символ @, то эти функции вернут одно и то же значение. Поэтому мы проверяем эти значения на неравенство.

Третий оператор по сути идентичен первому, только он проверяет '.', а не '@'.

Наконец, четвертый оператор if проверяет, что в адресе e-mail имеется как минимум одна точка после символа @.

Недостаток этого метода состоит в том, что простая строка " @." пройдет проверку. Должно быть очевидно, что она не является допустимым адресом e-mail. Существует другой метод для проверки адреса e-mail и для проверки множества других вещей. Это делается с помощью так называемых "регулярных выражений". Хотя регулярные выражения здесь рассматриваться не будут, ниже приведен пример проверки адреса e-mail, который остается читателю для анализа в качестве упражнения.

function validateForm(){ var email = document.forms.tutform.elements.email.value; if(!(/^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\. [a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/.test(email))){ alert('Пожалуйста, введите допустимый адрес e-mail'); return false; } return true;}

Как можно видеть, использование регулярного выражения приводит к более короткому (и более надежному) коду проверки, но он является и существенно более сложным!

С помощью примеров этой лекции теперь можно создать одну функцию для проверки всей формы:

1.4. Функции и концепция объектов.

Как мы уже знаем, функции в JavaScript используются для многократного выполнения одной и той же задачи. До сих пор функции всегда вызывались вручную с помощью скобок: myFunction(). Что, если потребуется вызвать функцию, когда пользователь выполняет определенную задачу? В JavaScript можно соединить функцию практически с любым событием, которое может порождать пользователь. Давайте посмотрим это в действии и напишем функцию, которая подсчитывает, сколько раз пользователь щелкнул на странице.

Вы щелкнули на этой странице раз.

В "предыдущей лекции" оператор ++ был применен только после переменной, как в случае clickCount++. Однако в данном примере оператор ++ используется перед переменной. В первом примере clickCount++, единица добавляется к переменной clickCount после чтения ее значения. В случае ++clickCount единица добавляется к переменной clickCount перед чтением ее значения. Так как в этом примере переменной clickCount в начале присваивается значение 0, то единицу к ней необходимо добавлять до задания значения поля ввода, поэтому использована запись ++clickCount.

Предыдущий пример может показаться достаточно знакомым. Так же, как и раньше, определяется переменная и функция. Изменение состоит в том, что вместо вызова функции documentClick() код содержит указание, что функция должна выполняться всякий раз, когда пользовательщелкает на документе. document.onclick связывает функцию с событием документа onclick ("при щелчке").

Существует множество событий подобных onclick. Мы познакомимся с некоторыми из них, но наиболее распространенными являются: onclick, onload, onblur, onfocus, onchange, onmouseover, onmouseout и onmousemove. Функцию можно связать с событиями любого объекта, такого, как изображение или поле ввода, а не только документа. Например, события onmouseover и onmouseoutиспользуются обычно с изображениями для создания эффекта изменения.

Можно также заметить, что ссылка на поле ввода делается другим образом. Ранее говорилось, что для указания поля необходимо использовать document.forms.имяФормы.elements.имяПоляВвода. Хотя этот способ прекрасно работает, это не всегда необходимо. В данном примере поле ввода действует просто как счетчик. Оно не находится внутри формы, и нам это и не нужно. Поэтому мы задаем для поля некоторый ID(идентификатор): id="clicked". ID можно использовать для ссылки на любой объект на странице. ID должен быть уникальным на странице, поэтому если имеется 5 полей ввода с ID, то все ID должны быть различны, даже если они только имеют вид "input1"-->"input5".

Поскольку это поле ввода используется как счетчик, то нежелательно, чтобы пользователи щелкали на нем и изменяли его значение. Здесь на помощь приходит другое связывание, onfocus, которое срабатывает, когда курсор перемещается на объект. Поэтому при щелчке на поле ввода или при перемещении на поле ввода с помощью клавиши Tab вызывается onfocus.

Событие onfocus имеет очень короткий код, но он также очень важен. В нем появляется ключевое слово this, которое важно понимать в JavaScript. Ключевое слово this указывает на тот объект, на котором выполняется код. В данном примере this указывает на поле ввода. Выражение this.blur() "размывает" поле ввода, другими словами, заставляет его терять фокус ввода. Так как это происходит, как только пользователь активизирует поле ввода, то это делает "невозможным" изменение данных.

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

Давайте посмотрим на другой пример:

Можно видеть, что событие onclick для каждой из этих радио-кнопок одинаково. Однако, если щелкнуть на каждой из них, то будут получены разные сообщения. Это связано с использованием this. Так как this указывает на каждую отдельную радио-кнопку, то каждая радио-кнопка передается в функцию showValue по отдельности.

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

function myFunction(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10){ // здесь располагается код }

Во многих случаях может понадобиться функция, которой требуется определенное количество аргументов, но не всегда необходимы все. В JavaScript не нужно передавать все 10 аргументов в функцию, которая объявлена с 10 аргументами. Если передать только первые 3, то функция будет иметь только 3 определенных аргумента. Это необходимо учитывать при написании функций. Например, можно написать функцию, которой всегда требуются 3 первых аргумента, но следующие 7 являются необязательными:

function myFunction(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10){ // код с arg1 // код с arg2 // код с arg3 if(arg4){ // код с arg4 } if(arg5 && arg6 && arg7){ // код с arg5, arg6 и arg7 if(arg8){ // код с arg8 } } if(arg9 || arg10){ // код с arg9 или arg10 }}

Можно видеть, что в коде выполняется простая проверка if(arg). Если аргумент не передается в функцию, то при попытке использовать этот аргумент будет получено значение undefined. При использовании undefined в качестве логического (булевого) значения ( true / false ), как в операторах if, оно воспринимается как false.

Поэтому, если arg4 не был передан в приведенном выше примере, то он является undefined и тело оператора if не выполняется.

Как быть, когда трудно определить, сколько потребуется аргументов? Можно иметь функцию, которая получает от 1 до n аргументов и выполняет с каждым из них одну и ту же задачу. На этот случай JavaScript имеет в каждой функции объект arguments. Объектarguments содержит все аргументы функции:

function myFunction(){ for(var i=0; i<arguments.length; i++){ alert(arguments[i].value); }}

Этот код сообщит значение всех переданных ему объектов. Если передать 100 объектов, то будет получено 100 сообщений. Более полезной функцией было бы, возможно, скрытие/вывод всех переданных функции объектов.

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

В этом небольшом фрагменте кода происходит очень многое. Вначале просто определяют две функции: multiply и add. Функцияmultiply просто перемножает все переданные ей числа. Аналогично, функция add складывает все переданные ей числа. Тонкости начинаются при использовании действий onclick двух созданных кнопок. Можно видеть, что при щелчке на любой из двух кнопок в функцию doAction передается объект. Ранее мы всегда передавали переменные или объекты HTML (такие, как поля ввода в предыдущем примере). В этом примере передаются функции. Функции можно передавать таким же способом, как и любой другой объект, и когда они передаются, их можно вызывать таким же способом, как и любую другую функцию. Изменяется только ее имя.

Таким образом функция doAction получает другую функцию в качестве аргумента! Если передается функция multiply, то функцияdoAction передает ей значения от 1 до 5, и мы получаем в результате 120. Если в doAction передается функция add, то ей также передаются значения от 1 до 5, и в результате мы получаем значение 15.

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

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

Кроме вложения функций, важно отметить, что имеется несколько различных способов объявления функций:

В этом примере функции nestedFunction1, nestedFunction2 и nestedFunction3 являются одинаковыми по своим возможностям. Единственное различие состоит в том, как они определяются. nestedFunction1 объявлена, как это делалось раньше. Синтаксис для nestedFunction2 немного отличается. Мы задаем для функции переменную this.nestedFunction2. Синтаксис этого объявления будет следующий имяПеременной= function(аргументы){. Аналогично для функции nestedFunction3 задается переменная для новой функции. Однако это объявление существенно отличается, так как мы определяем функцию с помощью строк. Третий вариант используется редко, но является очень полезным, когда используется. Он позволяет создать строку, содержащую код выполняемой функции, а затем определить функцию с помощью этой строки.

1.5. Строки, числа и массивы.

Строки

В JavaScript строка является любым фрагментом текста. Как и многие другие объекты в JavaScript, строки можно определять несколькими различными способами:

var myString = 'Hello, World!';var myString = new String('Hello, World!');

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

var n = 5;var s = new String(n*20);

В этом примере s будет строкой " 100 ". Если просто задать s как n*20, то s будет содержать число 100. Однако поскольку JavaScript является слабо типизированным языком, то эти различия не будут существенно влиять на то, что вы делаете.

Строковые объекты ( var n = new String('Hello World') ) технически являются в Internet Explorer более медленными при некоторых операциях, чем строковые литералы ( var n = 'Hello World' ). Однако это поведение совершенно противоположно в других браузерах. В любом браузере различие редко бывает настолько заметно, чтобы об этом беспокоиться.

Единственное важное различие состоит в том, что eval() не работает со строковыми объектами.

Что, если в строке имеется апостроф? Следующий код работать не будет:

var n = 'The dog took it's bone outside';

Легко видеть, что апостроф в " it's " заканчивает строку. Поэтому мы получаем строку " The dog took it ", за которой следует " s boneoutside'". Это продолжение само по себе не является допустимым кодом JavaScript (или правильным грамматически, если на то пошло), поэтому будет получена ошибка.

Здесь можно сделать две вещи. Так как строка определяется с помощью одиночных или двойных кавычек, то можно задать строку с помощью двойных кавычек. Другая возможность состоит в экранировании апострофа. Чтобы экранировать символ, необходимо просто подставить перед ним символ \. Символ \ в этом контексте сообщает JavaScript, что следующий символ необходимо воспринимать в точности так, как он есть, в номинальном значении, а не как специальный символ.

var n = "The dog took it's bone outside";var n = 'The dog took it\'s bone outside';

Если в строке должен присутствовать символ \, то он экранируется таким же образом: '\\'.

В "предыдущей лекции" мы встречались с функциями indexOf и lastIndexOf. Напомним, что они делают. Функция indexOf возвращает число, определяющее первую позицию одной строки в другой. Если разыскиваемая строка не существует, то indexOf возвращает -1. Функция lastIndexOf идентична indexOf, но возвращает не первую позицию вхождения строки, а последнюю.

Тот факт, что функции indexOf и lastIndexOf возвращают -1, если строка не существует, является очень полезным и позволяет использовать эти функции для достаточно распространенной задачи - проверки того, что одна строка существует внутри другой.

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

· charAt() сообщает, какой символ находится в определенной позиции строки. Поэтому 'Test'.charAt(1) = 'e'.

· length сообщает длину строки . 'Test'.length = 4.

· substring() выдает строку между двумя индексами. 'Test'.substring(1, 2) = 'e'.

· substr() аналогична substring(), только второе число является не индексом, а длиной возвращаемой строки. Если это число указывает на позицию за пределами строки, то substr() вернет существующую часть строки. 'Test'.substr(1, 2) = 'es' ;

· toLowerCase() и toUpperCase() делают то, что обозначают: преобразуют строку в нижний или верхний регистр символов соответственно. 'Test'.toUpperCase() = 'TEST' ;

Примеры всех приведенных выше функций:

alert('This is a Test'.indexOf('T')); // 0alert('This is a Test'.lastIndexOf('T')); // 10alert('This is a Test'.charAt(5)); // ialert('This is a Test'.length); // 14alert('This is a Test'.substring(5, 9)); // is aalert('This is a Test'.substr(5, 9)); // is a Testalert('This is a Test'.toUpperCase()); // THIS IS A TESTalert('This is a Test'.toLowerCase()); // this is a test

Последней строковой функцией, которая будет рассмотрена, является eval(). eval() получает строку и выполняет строку, как если бы это был код JavaScript.

eval("alert('Hello, World!')");

В этом примере будет выведено сообщение "Hello, World!", как если бы функция alert была написана обычным образом. Это может быть очень полезно, так как позволяет создать содержащую код строку, а затем ее выполнить.

Числа

Работа с числами в JavaScript происходит достаточно просто. В лекциях " 1" и " 2" было показано, как выполняются базовые арифметические операции, операторы ++, --, а также *=, +=, /= и -=. Мы узнали, что NaN означает "Не число" и что делает функция isNaN(). Осталось рассмотреть еще только несколько вещей.

Объект Math в JavaScript содержит функции, позволяющие сделать почти все, что можно сделать с числами помимо обычной арифметики. Math.PI, например, содержит просто число 3.141592653589793. В нем содержатся тригонометрические функции ( sin, cos, tan, и т.д.), функции для округления чисел ( Math.floor возвращает число, округленное с недостатком, Math.ceil возвращает число, округленное с избытком, а Math.round округляет число "нормально") и многие другие. Существует очень много функций, объяснять которые здесь не имеет смысла. Их всегда можно найти в подходящем справочнике.

Двумя наиболее распространенными задачами, связанными с числами, являются преобразование числа в строку и строки в число. Как уже говорилось, JavaScript является слабо типизированным языком, а это означает, что типы данных не имеют большого значения, но существуют некоторые случаи, когда надо быть уверенным, что имеется число или строка. Если надо сложить, например, 5 и число, которое вводит пользователь, то надо быть уверенным, что введено число, а не слово " Привет ".

var n = parseInt("3.14"); // 3var n = parseFloat("3.14") // 3.14

Функция parseInt возвращает целое значение своего аргумента. Аргументы " 3.14 ", " 3 ", " 3.00001 " и " 3.9999 " превратятся в значение 3. Функция parseFloat, с другой стороны, возвращает также любое десятичное значение. Обе эти функции пытаются "очистить" данные перед возвращением числа. Например, parseInt ("3a") вернет значение 3.

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

var n = 5; var m = n.toString();var m = n+'';var m = new String(n);

Как говорилось ранее, последний метод может быть немного непривычным, поэтому предполагается, что пользователь будет держаться от него в стороне, если только не понадобится использовать объект String для специальных целей. Предпочтительным методом является n.toString(), но необходимо отметить, что часто используется второй метод. Например, если имеется уведомление alert('Имеется ' + apples + ' яблок'), то число apples автоматически преобразуется в строку.

Если необходимо выполнить строковую операцию с переменной, то необходимо быть уверенным, что имеется строка. Если, например, имеется запись года из 4 цифр и ее надо преобразовать в 2 цифры:

var year = 2000; var sYear = year.toString();var year2 = sYear.substr(sYear.length-2);

Можно было бы также легко вычесть 2000 из этой даты, но что, если датой является 1995? или 1800? или 2700 или просто 5? В результате могли бы получиться совершенно неправильные даты, если вычесть 2000 из каждой такой даты. Используемый метод всегда даст правильные две цифры года.

Массивы

Массив является по сути списком элементов. Каждый элемент массива может быть чем угодно, но обычно они связаны друг с другом. Если, например, необходимо отследить 30 студентов класса, то можно создать массив студентов:

var students = new Array();students[0] = 'Sam';students[1] = 'Joe';students[2] = 'Sue';students[3] = 'Beth';

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

var students = ['Sam', 'Joe', 'Sue', 'Beth'];

Этот код создает точно такой же массив, что и предыдущий пример, но, как можно видеть, он значительно более компактный и ничуть не сложнее для понимания. Скобки ( [ и ] ) в этом примере сообщают коду, что будет создан массив. Простая запись var students = [];является тем же самым, что и запись var students = new Array();. Правда, некоторые люди считают, что использование слова Arrayболее наглядно, чем запись [], поэтому можно использовать любой метод записи.

Что можно теперь сделать с этим массивом студентов? Чтобы обратиться к любому элементу массива, необходимо знать его индекс. В первом примере можно видеть, что в скобках находятся числа (0-3). Это индексы. Если требуется узнать имя третьего студента, то надо будет написать alert(students[2]);. Почему 2, а не 3? Массивы в JavaScript начинают индексацию с 0, а не с 1. Поэтому первым элементом в нашем массиве будет students[0], вторым - students[1], сотым - students[99], и т.д. Для этого не существует никакой реальной причины, просто так устроен JavaScript и многие другие языки программирования. Некоторые другие языки используют в качестве первого индекса 1.

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

var students = ['Sam', 'Joe', 'Sue', 'Beth'];var suffixes = ['1st', '2nd', '3rd', '4th']; for(var i=0; i<students.length; i++){ alert(suffixes[i]+' студент -- '+students[i]);}

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

var spreadsheet = [ ['A1', 'B1', 'C1', 'D1'], ['A2', 'B2', 'C2', 'D2'], ['A3', 'B3', 'C3', 'D3'], ['A4', 'B4', 'C4', 'D4']];

Переносы строк в JavaScript обычно не имеют значения. В этом примере переносы строк используются для придания коду большей наглядности и не влияют на код никаким образом.

Можно видеть, что здесь имеется 5 массивов. Четыре внутренних массива (или вложенных массива) содержатся в одном большом массиве, spreadsheet. Если потребуется узнать значение на пересечении третьего столбца и второй строки, то можно написать:

var col2 = spreadsheet[1];alert(col2[2]); // или alert(spreadsheet[1][2]);

Оба фрагмента кода делают одно и то же, выводят значение " C2 ".

Существует несколько распространенных операций, которые выполняются с массивами. Первой является добавление элемента в конец массива. Вернемся к массиву students, который содержит в данный момент 4 элемента. Чтобы добавить новый элемент, надо просто задать значение для 5-го элемента:

var students = ['Sam', 'Joe', 'Sue', 'Beth']; students[4] = 'Mike';students[students.length] = 'Sarah';students.push('Steve'); // теперь массив содержит 7 элементов: ['Sam', 'Joe', 'Sue', 'Beth', 'Mike', 'Sarah', 'Steve']

Здесь также существует несколько способов для выполнения этой задачи. Первый метод, students[4], используется редко, так как обычно неизвестно заранее в точности, сколько будет элементов. Поэтому применяется один из двух оставшихся методов. push является функцией, которая просто добавляет то, что получает, в конец массива, как и предыдущий метод, использующий свойство .length.

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

var students = ['Sam', 'Joe', 'Sue', 'Beth', 'Mike', 'Sarah', 'Steve'];students.splice(4, 1);

Splice в этом примере получает два аргумента: начальный индекс и число элементов для удаления. Так как Mike является пятым студентом, то его индекс будет 4. Будет удален только 1 студент, поэтому здесь используется 1. В результате имеем массив с удаленным Mike:

['Sam', 'Joe', 'Sue', 'Beth', 'Sarah', 'Steve'];

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

Единственным новым моментом здесь является слово break. break останавливает выполнение кода любого цикла, в котором находится: цикла for, цикла do или switch. Поэтому в данном случае, когда удаляемый студент найден, мы прерываем цикл for, так как выполнили свою задачу.

Часто бывает необходимо преобразовать массив в строку или строку в массив. Имеется две функции, которые могут легко это сделать: join и split. Функция join получает массив и преобразует его в строку с помощью разделителя, заданного в join. Функция split действует в обратном направлении и делает массив из строки, определяя новый элемент c помощью разделителя, заданного в split:

var myString = 'apples are good for your health';var myArray = myString.split('a'); // строка myString разбивается на элементы на каждом найденном символе 'a'.alert(myArray.join(', ')); // преобразуем myArray снова в строку с помощью запятой, // так что можно видеть каждый элемент alert(myArray.join('a')); // теперь преобразуем myArray снова в строку с помощью символа 'a', // так что снова получается исходная строка

Еще две полезные функции для работы с массивами - pop и shift. Функция pop удаляет последний элемент из массива и возвращает его. Функция shift удаляет первый элемент из массива и возвращает его.

var students = ['Sam', 'Joe', 'Sue', 'Beth']; while(students.length>0){ alert(students.pop());}

К сожалению, при этом массив был уничтожен: он теперь пуст. Иногда именно это и надо сделать. Если требуется просто очистить массив, то проще всего задать его длину ( length ) равной 0:

students.length = 0

Теперь массив пуст. Даже если снова задать длину массива больше 0, все данные в массиве уже будут уничтожены.

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

var grades = [];grades['Sam'] = 90;grades['Joe'] = 85;grades['Sue'] = 94;grades['Beth'] = 82;

Ассоциативные массивы действуют немного иначе, чем индексные. Прежде всего, длина массива в этом примере будет равна 0. Как же узнать, какие элементы находятся в массиве? Единственный способ сделать это - использовать цикл " for-in ":

for(student in grades){ alert("Оценка " + student + "будет: " + grades[student]);}

Синтаксис цикла for-in следующий: " for(item in object){ ". Цикл пройдет через все элементы в объекте, и элемент будет именем элемента. В данном случае элементом является " Sam ", затем " Joe ", " Sue " и " Beth ".

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

var students = ['Sam', 'Joe', 'Sue', 'Beth']; students['Sam'] = 90;students['Joe'] = 85;students['Sue'] = 94;students['Beth'] = 82; alert('Всего имеется '+(students.length)+' студентов: '+students.join(', '));for(var i=0; i<students.length; i++){ alert("Оценка " +students[i]+"будет: "+students[students[i]]);}

1.6. Объектная модель документа.

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

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

XML

Те, кто знает, что такое документ XML, могут пропустить этот раздел. Остальным необходимо его прочитать.

Будем надеяться, что читатель в какой-то степени знаком с HTML. Это то, из чего состоит (почти) каждая Web-страница. Каждое изображение, ссылка, таблица, поле формы и т.д. имеют свой собственный тег. Ниже приведен пример простой страницы HTML:

<HTML><BODY><table border="0" cellspacing="2" cellpadding="5"> <tr> <td colspan="2"><img src="Greetings.jpg" id="greetingImg" /></td> </tr> <tr> <td> Добро пожаловать на мою страницу HTML! <br /> <a href="somelink.html" id="myLink" >Щелкните здесь!</a> </td> <td><img src="hello.jpg" id="helloImg" /></td> </tr></table></BODY></HTML>

Это просто обычная страница HTML. Возможно, вы не знаете о том, что это также пример документа XML. Здесь нас интересует то, что каждый элемент является потомком и/или предком другого элемента. Первое изображение находится внутри тега TD, который находится внутри тегов TR, TABLE, BODY и HTML. Двигаясь в другом направлении, можно видеть, что тег BODY имеет одного "потомка" - тегTABLE. Этот тег TABLE имеет в качестве потомков два тега TR и т.д. По сути именно так мы перемещаемся в документе XML или HTMLDOM - двигаясь от потомка к предку или от предка к потомку.

Изображение: Блок-схема документа

Изображение может помочь лучше понять отношения предок-потомок в этом коде.

Блок-схема документа

Необходимо также отметить атрибуты в некоторых из этих тегов. Например, тег TABLE ( <table border="0" cellspacing="2" cellpadding="5"> ) имеет 3 заданных атрибута: border, cellspacing и cellpadding. При изменении DOM часто бывает необходимо изменить эти атрибуты. Можно, например, изменить атрибут SRC тега IMG, чтобы изменить выводимое изображение. Это часто делают, например, для создания эффекта изменения изображения, на которое направлен указатель ( rollover ).

Дата добавления: 2018-08-06; просмотров: 210; Мы поможем в написании вашей работы!

Поделиться с друзьями:

12 3 4 5 Следующая ⇒

Мы поможем в написании ваших работ!