ASCII и latin

Стандарт ECMAScript v3 допускает наличие Unicodeсимволов в любом месте JavaScriptпрограммы. Однако версии 1 и 2 стандарта допускают использование Unicodeсимволов только в комментариях и строковых литералах, заключенных в кавычки, все остальные составляющие программы ограничены набором ASCIIсимволов.1 Версии JavaScript, предшествующие стандарту ECMAScript, обычно вообще не поддерживают Unicode.

Точка с запятой служит для отделения инструкций

друг от друга. Однако в JavaScript точку с запятой можно не ставить, если каж

дая инструкция помещается в отдельной строке. Например, следующий фраг

мент может быть записан без точек с запятой:

Return

true;

Синтаксический анализатор JavaScript предполагает, что программист имеет

в виду следующее:

return;

true;

Хотя на самом деле программист, видимо, хотел написать

return true;

2. 4.2. Объявление переменных

Прежде чем использовать переменную в JavaScript, ее необходимо объявить.

Переменные объявляются с помощью ключевого слова var следующим образом:

var i;

var sum;

Можно объявить несколько переменных:

var i, sum;

Кроме того, объявление переменной можно совмещать с ее инициализацией:

var message = "hello";

var i = 0, j = 0, k = 0;

Если начальное значение не задано в инструкции var, то переменная объявляет

ся, но ее начальное значение остается неопределенным (undefined), пока не будет

изменено программой.

Обратите внимание, что инструкция var также может включаться в циклы for

и for/in (о которых рассказывается в главе 6), что позволяет объявлять перемен

ную цикла непосредственно в самом цикле. Например:

for(var i = 0; i < 10; i++) document.write(i, "<br>");

for(var i = 0, j = 10; i < 10; i++, j) document.write(i*j, "<br>");

for(var i in o) document.write(i, "<br>");

Переменные, объявленные с помощью инструкции var, называются долговременными (permanent): попытка удалить их с помощью оператора delete приведет к ошибке

4.2.1. Повторные и опущенные объявления

С помощью инструкции var можно объявить одну и ту же переменную несколько

раз. Если повторное объявление содержит инициализатор, то оно действует как

обычная инструкция присваивания.

Если попытаться прочитать значение необъявленной переменной, JavaScript сгенерирует сообщение об ошибке. Если присвоить значение переменной, не объявленной с помощью инструкции var, JavaScript неявно объявит эту переменную за вас. Однако переменные, объявленные таким образом, всегда создаются как глобальные, даже если они работают только в теле функции. Чтобы не создавать глобальную переменную (или не использовать существующую), когда достаточно локальной переменной для отдельной функции, всегда помещайте инструкцию var в тело функции. Лучше всего объявлять с ключевым словом var все переменные – и глобальные, и локальные. (Различие между локальными и глобальными переменными подробнее рассматривается в следующем разделе.)

4.3. Область видимости переменной Область видимости (scope) переменной – это та часть программы, для которой эта переменная определена. Глобальная переменная имеет глобальную область видимости – она определена для всей JavaScriptпрограммы. Переменные, объявленные внутри функции, определены только в ее теле. Они называются локальными и имеют локальную область видимости. Параметры функций также считаются локальными переменными, определенными только в теле этой функции.Внутри тела функции локальная переменная имеет преимущество перед глобальной переменной с тем же именем. Если объявить локальную переменную или параметр функции с тем же именем, что у глобальной переменной, то фактически глобальная переменная будет скрыта. Так, следующий код печатает слово «локальная»:

var scope = "глобальная"; // Объявление глобальной переменной

function checkscope() {

var scope = "локальная"; // Объявление локальной переменной с тем же именем

document.write(scope); // Используется локальная переменная, а не глобальная

}

checkscope(); // Печатается слово "локальная"

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

scope = "глобальная"; // Объявление глобальной переменной, даже без var

function checkscope() {

scope = "локальная"; // Ой! Мы только что изменили глобальную переменную

document.write(scope); // Используется глобальная переменная

myscope = "локальная"; // Здесь мы неявно объявляем новую глобальную переменную

document.write(myscope); // Используется новая глобальная переменная

}

checkscope(); // Печатает "локальнаялокальная"

document.write(scope); // Печатает "локальная"

document.write(myscope); // Печатает "локальная"

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

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

var scope = "глобальная область видимости"; // Глобальная переменная

function checkscope() {

var scope = "локальная область видимости"; // Локальная переменная

function nested() {

var scope = "вложенная область видимости"; // Вложенная область видимости

// локальных переменных

document.write(scope); // Печатает "вложенная область видимости"

}

nested();

}

checkscope();

4.3.1. Отсутствие блочной области видимости

Обратите внимание: в отличие от C, C++ и Java, в JavaScript нет области видимости на уровне блоков. Все переменные, объявленные внутри функции, независимо от того, где именно это сделано, определены во всей функции. В следующем фрагменте переменные i, j и k имеют одинаковые области видимости: все три определены во всем теле функции. Это было бы не так, если бы код был написан на C, C++ или Java:

function test(o) {

var i = 0; // i определена во всей функции

if (typeof o == "object") {

var j = 0; // j определена везде, а не только в блоке

for(var k = 0; k < 10; k++) { // k определена везде, не только в цикле

document.write(k);

}

document.write(k); // k все еще определена: печатается 10

}

document.write(j); // j определена, но может быть не инициализирована

}

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

var scope = "глобальная";

function f() {

alert(scope); // Показывает "undefined", а не "глобальная".

var scope = "локальная"; // Переменная инициализируется здесь,

// но определена она везде в функции.

alert(scope); // Показывает "локальная"

}

f();

Ктото может подумать, что в результате первого вызова alert() будет напечатано слово «глобальная», т. к. инструкция var, объявляющая локальную переменную, еще не была выполнена. Однако согласно правилу определения областей видимости все происходит не так. Локальная переменная определена во всем теле функции, значит, глобальная переменная с тем же именем скрыта во всем теле функции. Хотя локальная переменная определена везде, до выполнения инструкции var она не инициализирована. Поэтому функция f в предыдущем примере эквивалентна следующему фрагменту:

function f() {

var scope; // Локальная переменная определяется в начале функции

alert(scope); // Здесь она существует, но имеет значение undefined

scope = "локальная"; // Здесь мы инициализируем переменную и присваиваем ей значение

alert(scope); // Здесь она уже имеет значение

}

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

4.3.2. Неопределенные и неинициализированные переменные

Примеры предыдущего раздела демонстрируют тонкий момент программирования на JavaScript: имеется два вида неопределенных переменных. Первый – переменная, которая нигде не объявлена. Попытка прочитать значение необъявленной переменной приведет к ошибке времени выполнения. Необъявленные переменные не определены, потому что они просто не существуют. Как уже было сказано, присваивание значения необъявленной переменной не приводит к ошибке –просто она при присваивании неявно объявляется как глобальная переменная.Второй вид неопределенных переменных – переменная, которая была объявлена,но значение ей нигде не присваивалось. Если прочитать значение одной из таких переменных, то будет получено ее значение по умолчанию – undefined. Такие переменные лучше называть неинициализированными (unassigned), чтобы отличить их от тех переменных, которые вообще не объявлялись и не существуют.В следующем фрагменте иллюстрируются некоторые различия между неопределенными и неинициализированными переменными:

var x; // Объявляем неинициализированную переменную. Значением ее является undefined.

alert(u); // Использование необъявленной переменной приведет к ошибке.

u = 3; // Присваивание значения необъявленной переменной создает эту переменную.