Создание динамического наполнения страницы. Основы JavaScript

12.1.5.4. Другие типы

JavaScript различает специальный тип и одноименное примитивное значение null – явное (программно-установленное) пустое значения, и значение undefined типа "undefined", которое говорит о том, что значение еще не было назначено:

typeof null //результат – "object"
typeof undefined //результат – "undefined"

В JavaScript можно объявить переменную не инициализируя ее. В этом случае значение переменной будет равно undefined.

В JavaScript есть логический тип с возможными значениями true и false (оба являются ключевыми словами в JavaScript ). Любое значение может быть преобразовано к логическому в согласии со следующими правилами:

Преобразование можно провести в явном виде с использованием функции Boolean():

Boolean("") //результат – "false"
Boolean(234) //результат – "true"

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

Поддерживаются стандартные логические операторы ! (логическое не ).

12.1.5.5. Переменные

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

var a;
var name = "Иван";

12.1.5.6. Операторы

В JavaScript есть стандартные математические операторы +, -, *, / и % (остаток от деления). Значения присваиваются оператором =, также есть операторы составного присваивания += и -=. Они позволяют записать короче часто встречающиеся выражения типа: x = x operator y:

x += 5
x = x + 5

Можно использовать ++ и -- для увеличения или уменьшения значения переменной на единицу. Помещать этот оператор можно как за символом переменной ( i++ ) так и перед или ( ++i ).

Оператор " + " применяется еще и для конкатенации строк:

"Привет, " + "мир!" //результат – "Привет, мир!"

При добавлении строки к числу последнее автоматически конвертируется в строку:

"3" + 4 + 5 //результат – "345"
3 + 4 + "5" //результат – "75"

Добавление пустой строки к чему-либо можно использовать, как преобразование к строке.

В JavaScript Comparisons есть следующие операторы сравнения: <, >, <= и >=. Их можно использовать и со строками и с числами. Сравнение значений уже несколько сложнее. Оператор двойного равенства производит преобразование типов, что может привести к несколько неожиданным результатам:

"Привет" == "Привет" //результат – "true"
1 == true //результат – "true"

Чтобы этого избежать следует использовать оператор тройного равенства, который учитывает типы:

1 === true //результат – "false"
true === true //результат – "true"

Есть также обратные операторы != и !== для двойного и тройного равенства соответственно.

12.1.5.7. Управляющие структуры

JavaScript имеет Си-подобные управляющие структуры. Условные операторы: if и else, из которых можно делать цепочки:

var name = "Котенок";
if (name == "Щенок") {
    name += "!";
} else if (name == "Котенок") {
    name += "!!";
} else {
    name = "!" + name;
}
name == Котенок!!"

В JavaScript есть циклы while и do-while. Первый можно использовать для бесконечного цикла; второй в том случае если вы хотите, чтобы тело цикла выполнилось как минимум один раз:

while (true) {
    // Бесконечный цикл!
}

do {
    var input = get_input();
} 
while (inputIsNotValid(input))

В JavaScript for такой же, как в C, C# и Java:

for (var i = 0; i < 5; i++) {
    // будет выполнен 5 раз
}

Операторы и || "закорачиваются", т.е. будет ли выполнен или нет второй операнд, зависит от значения первого. Это можно использовать для проверки значения объекта на null перед тем как пытаться прочитать его свойства:

var name = o  o.getName();

Или для установки значений по умолчанию:

var name = otherName || "default";

В JavaScript есть также тернарный оператор:

var allowed = (age > 18) ? "Да" : "Нет";

Конструкция switch может быть использована для разветвления на основании числового или строчного значения:

switch (action) {
    case 'Рисовать':
        drawit();
        break;
    case 'Есть':
        eatit();
        break;
    default:
        donothing();
}

Если забыть написать break, то выполнение "провалится" в следующий case:

switch (a) {
    case 1: // проваливаемся
    case 2:
        eatit();
        break;
    default:
        donothing();
}

Выражение default необязательно, его можно опустить.

Можно использовать "выражения" как в switch, так и в case ; сравнение будет проводиться с использованием оператора тройного равенства ===:

switch(1 + 3):
    case 2 + 2:
        yay();
        break;
    default:
        neverhappens();
}

12.1.5.8. Объекты

В JavaScript объекты это просто коллекции пар "ключ-значение". Таким образом, они несколько похожи на:

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

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

Есть два способа создать объект:

var obj = new Object();

или

var obj = {};

Эти два способа абсолютно идентичны. Второй способ называется объектный литерал.

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

obj.name = "Иван"
var name = obj.name;

или

obj["name"] = "Иван";
var name = obj["name"];

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

obj.for = "Иван"; // Синтаксическая ошибка, т.к. 'for' является зарезервированным словом
obj["for"] = "Иван"; // Нет ошибки

Объектно-литеральный синтаксис может быть использован для определения свойств объекта в момент его создания:

var obj = {
    name: "Петров",
    "for": "Иван",
    details: {
        color: "orange",
        size: 12
    }
}

Доступ к свойствам можно выстраивать в цепь (т.е. вызывать свойства свойств и т.д.):

obj.details.color //результат – "orange"
obj["details"]["size"] //результат – "12"

12.1.5.9. Массивы

Массивы в JavaScript это специальный тип объектов. Они представляют собой почти рядовые объекты (числовые свойства доступны только через [] синтаксис), но имеют свойство "length", значение которого всегда больше на единицу наибольшего индекса в массиве.

Старый способ создания массивов:

var a = new Array();
a[0] = "собака";
a[1] = "кошка";
a[2] = "мышь";

a.length //результат – "3"

Более удобен "массивно-литеральный" синтаксис:

var a = ["собака", "кошка", "мышь"];

a.length //результат – "3"

Необходимо помнить, что array.length не всегда число элементов массива:

var a = ["собака", "кошка", "мышь"];
a[100] = "лиса";

a.length //результат – "101"

Длина массива это просто число на единицу большее наибольшего индекса.

Если запросить элемент с несуществующим индексом, то будет возвращено undefined:

typeof (a[90]) //результат – "undefined"

Обойти массив можно вот так:

for (var i = 0; i < a.length; i++) {
    // работаем с a[i]
}

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

Безопасный способ добавления элемента к концу массива:

a[a.length] = item; //тоже что и a.push(item);

Поскольку a.length на единицу больше наибольшего индекса, вы можно быть уверенным, что добавлен элемент в пустую позицию в конец массива.

Массивы имеют набор встроенных методов:

12.1.5.10. Функции

Вместе с объектами функции играют ключевую роль в JavaScript. Вот объявление самой простой функции:

function add(x, y) {
    var total = x + y;
    return total;
}

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

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

add() //результат – "NaN", т.к. undefined нельзя складывать

Также можно передать аргументов больше, чем ожидает функция:

add(2, 3, 4) //результат – "5", т.к. складывает первые два параметра, а 4 игнорируется

Внутри тела функции доступна дополнительная переменная "arguments". Это "массиво-подобный" объект, в котором хранятся все переменные, переданные в функцию. Перепишем предыдущую функцию, чтобы она суммировала все параметры, которые ей передают:

function add() {
    var sum = 0;
    for (var i = 0, j = arguments.length; i < j; i++) {
        sum += arguments[i];
    }
    return sum;
}

И вызовем ее:

add(2, 3, 4, 5) //результат – "14"

Напишем функцию для подсчета среднего арифметического:

function avg() {
    var sum = 0;
    for (var i = 0, j = arguments.length; i < j; i++) {
        sum += arguments[i];
    }
    return sum / arguments.length;
}

И вызовем ее:

avg(2, 3, 4, 5) //результат – "3.5"

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

Первый это классический func(). Любую функцию можно вызвать также с помощью встроенного в Function метода apply(), который вызовет функцию с параметрами, переданными в виде массива в apply() вторым параметром:

avg.apply(null, [2, 3, 4, 5]) //результат – "3.5"

JavaScript позволяет создавать анонимные функции:

var avg = function() {
    var sum = 0;
    for (var i = 0, j = arguments.length; i < j; i++) {
        sum += arguments[i];
    }
    return sum / arguments.length;
}

JavaScript позволяет функциям делать рекурсивные вызовы (т.е. вызывать самих себя). Это очень полезно, когда имеешь дело с древовидными структурами, например, такими как DOM:

function countChars(elm) {
    if (elm.nodeType == 3) { 
        return elm.nodeValue.length;
    }
    var count = 0;
    for (var i = 0, child; child = elm.childNodes[i]; i++) {
        count += countChars(child);
    }
    return count;
}

12.1.5.11. Пользовательские объекты

В классических объектно-ориентированных языках объект – это коллекция данных и методов, оперирующих этими данными [5].

Рассмотрим объект person с полями first и last name (имя и фамилия). Предположим, надо иметь два метода для различных отображений полного имени: как "first last" или как "last, first". Это можно сделать с использованием объекта и функций следующим образом:

function makePerson(first, last) {
    return {
        first: first,
        last: last
    }
}
function personFullName(person) {
    return person.first + ' ' + person.last;
}
function personFullNameReversed(person) {
    return person.last + ', ' + person.first
}

Тогда при вызове этих функций:

s = makePerson("Иван", "Петров");
personFullName(s) //результат – "Иван Петров"
personFullNameReversed(s) //результат – "Петров, Иван"

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

function makePerson(first, last) {
    return {
        first: first,
        last: last,
        fullName: function() {
            return this.first + ' ' + this.last;
        },
        fullNameReversed: function() {
            return this.last + ', ' + this.first;
        }
    }
}

Тогда при вызове этих функций:

s = makePerson("Иван", "Петров")
s.fullName()//результат – "Иван Петров"
s.fullNameReversed()//результат – "Петров, Иван"

Здесь встречается ключевое словом "this". При использовании внутри функции "this" ссылается на текущий объект. Чему будет равно "this" на самом деле зависит от того как была вызвана функция. Если функция будет вызвана через точечную нотацию или квадратные скобки, тогда "this" указывает на этот объект. Если просто вызвать функцию, то "this" будет указывать на глобальный объект. Непонимание этого может привести к неприятным последствиям:

s = makePerson("Иван", "Петров")
var fullName = s.fullName;
fullName()//результат – "undefined undefined"

Когда вызывается fullName(), в роли "this" выступает глобальный объект. И поскольку не определены глобальные переменные first и last, для каждой из них будет получено undefined.

Можно использовать "this" для усовершенствования нашей функции makePerson:

function Person(first, last) {
    this.first = first;
    this.last = last;
    this.fullName = function() {
        return this.first + ' ' + this.last;
    }
    this.fullNameReversed = function() {
        return this.last + ', ' + this.first;
    }
}
var s = new Person("Иван", "Петров");

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

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

function personFullName() {
    return this.first + ' ' + this.last;
}
function personFullNameReversed() {
    return this.last + ', ' + this.first;
}
function Person(first, last) {
    this.first = first;
    this.last = last;
    this.fullName = personFullName;
    this.fullNameReversed = personFullNameReversed;
}

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

function Person(first, last) {
    this.first = first;
    this.last = last;
}
Person.prototype.fullName = function() {
    return this.first + ' ' + this.last;
}
Person.prototype.fullNameReversed = function() {
    return this.last + ', ' + this.first;
}

Person.prototype это объект общий для всех объектов, созданных с помощью Person. Он входит в "prototype chain" (цепочку поиска): каждый раз, когда происходит попытка получить свойство объекта Person, которое у него отсутствует, JavaScript проверяет, нет ли такого свойства у Person.prototype. Таким образом, все, что будет присвоено Person.prototype становится доступно всем объектам порожденным конструктором Person, в том числе и через объект this.

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

s = new Person("Иван", "Петров");

s.firstNameCaps(); //результат – "TypeError on line 1: s.firstNameCaps is not a function"

Person.prototype.firstNameCaps = function() {
    return this.first.toUpperCase()
}

s.firstNameCaps() //результат – "ИВАН"

Как уже упоминалось, прототип является частью цепочки, в конце которой находится Object.prototype, у которого есть метод toString() – он вызывается, когда объект приводится к строке. И его можно переопределить для отладки:

var s = new Person("Иван", "Петров");

s //результат – "[object Object]"

Person.prototype.toString = function() {
    return '<ФИО: ' + this.fullName() + '>';
}
s //результат – "<ФИО: Иван Петров>"

Теперь вернемся к рассмотрению первого параметр метода avg.apply().Первый параметр apply() это объект, на который будет ссылаться ключевое слово "this", если оно используется в теле вызываемой функции. Например, можно сделать тривиальную реализацию "new":

function trivialNew(constructor) {
    var o = {}; // создаем объект
    constructor.apply(o, arguments);
    return o;
}

Это конечно не совсем "new", так как не создается прототипная цепочка ( prototype chain ).

Для apply() есть похожая функция call, которая также позволяет установить "this", но вместо массива параметров принимает параметры через запятую (как при обычном вызове):

function lastNameCaps() {
    return this.last.toUpperCase();
}
var s = new Person("Иван", "Петров");

lastNameCaps.call(s);
// Тоже самое, что и:
s.lastNameCaps = lastNameCaps;
s.lastNameCaps();

12.1.5.12. Внутренние функции

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

function betterExampleNeeded() {
    var a = 1;
    function oneMoreThanA() {
        return a + 1;
    }
    return oneMoreThanA();
}

Это позволяет не засорять глобальный контекст ( scope ) именами функций, которые нужны для решения частных проблем в одной части кода. А также разделять переменные между разными вложенными функциями, не пользуясь глобальным пространством имен.

12.1.6. Встраивание в веб-страницы

Для добавления JavaScript -кода на страницу, можно использовать теги <script></script>. Скрипт, выводящий модальное окно с классической надписью "Hello, World!" внутри браузера:

<script type="text/javascript">
alert('Hello, World!');
</script>

12.1.6.1. Расположение внутри тега

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

<a href="delete.php" onclick="return confirm('Вы уверены?');">Удалить</a>

12.1.6.2. Отделение от разметки

В приведенном примере при нажатии на ссылку функция confirm('Вы уверены?') ; вызывает модальное окно с надписью "Вы уверены?", а return false; блокирует переход по ссылке. Разумеется, этот код будет работать, только если в браузере есть и включена поддержка JavaScript, иначе переход по ссылке произойдет без предупреждения.

Использование кода JavaScript в контексте разметки страницы в рамках ненавязчивого JavaScript расценивается как плохая практика. Аналогом (при условии снабжения ссылки идентификатором alertLink ):

<a href="delete.aspx" id="alertLink">Удалить</a>

приведенного примера может выступать, например, следующий фрагмент JavaScript:

window.onload = function() {
    var linkWithAlert = document.getElementById("alertLink");
    linkWithAlert.onclick = function() {
        return confirm('Вы уверены?');
    };
};

12.1.6.3. Вынесение в отдельный файл

Есть и третья возможность подключения JavaScript – написать скрипт в отдельном файле, а потом подключить его с помощью конструкции:

<script type="text/javascript" src="http://Путь_к_файлу_со_скриптом"></script>

12.1.6.4. Атрибуты тега script

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

При этом атрибут language (language="JavaScript"), несмотря на его активное использование, относится к не рекомендуемым (deprecated), отсутствует в DTD, поэтому считается некорректным.

12.1.7. Область применения

12.1.7.1. Веб-приложения

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

12.1.7.2. AJAX

JavaScript используется в AJAX, популярном подходе к построению интерактивных пользовательских интерфейсов Веб-приложений, заключающемся в "фоновом" асинхронном обмене данными браузера с Веб-сервером. В результате, при обновлении данных Веб-страница не перезагружается полностью и интерфейс Веб-приложения становится быстрее, чем это происходит при традиционном подходе (без применения AJAX) [6].

12.1.7.3. Comet

Comet – термин, описывающий механизм работы Веб-приложений, использующих постоянные HTTP-соединения, что позволяет Веб-серверу отправлять данные браузеру без дополнительного запроса со стороны браузера. Для таких приложений используются технологии, непосредственно поддерживаемые браузерами. В частности, в них широко используется JavaScript. Сама технология Comet позволяет создавать чаты, графики биржевых котировок в браузере [7].

12.1.7.4. Браузерные операционные системы

JavaScript широко используется в браузерных операционных системах. Так, например, исходный код IndraDesktop WebOS на 73 % состоит из JavaScript, код браузерной операционной системы IntOS – на 70 %. Доля JavaScript в исходном коде eyeOS – 21 % (рис. 12.1), однако и в рамках этой операционной системы JavaScript играет важную роль, участвуя в визуализации на клиенте и являясь необходимым механизмом для коммуникации клиента и сервера.

12.1.7.5. Пользовательские скрипты в браузере

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

12.1.7.6. Серверные приложения

Приложения, написанные на JavaScript, могут исполняться на серверах, использующих Java 6 и более поздних версий. Это обстоятельство используется для построения серверных приложений, позволяющих обрабатывать JavaScript на стороне сервера. JavaScript на стороне сервера используется в проектах Google. Так, например, Google Sites допускает подстройку с помощью JavaScript -сценариев, исполняемых движком Rhino.

12.1.7.7. Мобильные приложения

Перевод мобильных устройств Palm на использование Palm webOS в качестве операционной системы с Mojo SDK в качестве средств разработки позволяет использовать JavaScript в качестве языка разработки мобильных приложений.

12.1.7.8. Виджеты

Виджет – вспомогательная мини-программа, графический модуль, которой размещается в рабочем пространстве соответствующей родительской программы, служащая для украшения рабочего пространства, развлечения, решения отдельных рабочих задач или быстрого получения информации из интернета без помощи веб-браузера. JavaScript используется как для реализации виджетов, так и для реализации движков виджетов. В частности, при помощи JavaScript реализованы Apple Dashboard, Microsoft Gadgets, Yahoo! Widgets, Google Desktop Gadgets .

12.1.7.9. Прикладное программное обеспечение

JavaScript используется для написания прикладного ПО. Одним из ярких примеров является Mozilla Firefox, 57 % исходного кода которого написано на JavaScript (для сравнения, следующим языком программирования по объему кодовой базы Firefox является C++, доля которого составляет 17 % ).

Google Chrome OS в качестве прикладного ПО использует Веб-приложения.

12.1.7.10. Манипуляция объектами приложений

JavaScript также находит применение в качестве скриптового языка доступа к объектам приложений. Платформа Mozilla (XUL/Gecko) использует JavaScript. Среди сторонних продуктов, например, Java, начиная с версии 6, содержит встроенный интерпретатор JavaScript на базе Rhino. Сценарии JavaScript поддерживаются в таких приложениях Adobe, как Adobe Photoshop, Adobe Dreamweaver, Adobe Illustrator и Adobe InDesign.

12.1.7.11. Офисные приложения

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

12.1.8. Библиотеки JavaScript

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

Среди известных JavaScript библиотек можно отметить Adobe life, Dojo Toolkit, ExtJS, jQuery, Mootools, Prototype, Qooxdoo [9, 10, 11, 12]. Некоторые из этих библиотек будут рассмотрены в следующей лекции.

12.1.9. Поддержка браузерами

На сегодняшний день поддержку JavaScript обеспечивают современные версии всех наиболее часто используемых браузеров. В Internet Explorer, Mozilla Firefox, Safari, Chrome, Opera имеется полная поддержка третьей редакции ECMA-262. При этом в Mozilla Firefox предпринята попытка осуществления поддержки четвертой редакции спецификации, а первым браузером, в котором появилась неполная поддержка спецификации 3.1, явился Internet Explorer 8.

12.1.10. Безопасность

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

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

12.1.10.1. Межсайтовые уязвимости

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

Уязвимости XSS также происходят из-за ошибок, допущенных разработчиками браузеров.

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

12.1.10.2. Ошибки в браузере, плагинах и расширениях

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

Подобные ошибки выявлялись у часто используемых браузеров, включая Mozilla Firefox, Internet Explorer, Safari. При выявлении потенциально опасных ошибок в браузере и наличия сведений о реализованных эксплойтов фирма-производитель и эксперты по безопасности рекомендуют отключать JavaScript до выхода патча.

Плагины, такие как плееры, Macromedia Flash и ряд ActiveX компонент, доступных по умолчанию в Internet Explorer, могут также содержать ошибки, эксплуатируемые с помощью JavaScript, что уже случалось ранее.

Расширения Mozilla Firefox не изолированы друг от друга: одно расширение может исправлять другое, что может использоваться злоумышленниками.

12.1.10.3. Ошибки реализации песочницы

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

Неправильное наделение привилегиями JavaScript из Интернета служило причиной уязвимостей как Internet Explorer, так и Mozilla Firefox.

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

12.2. Ключевые термины

JavaScript, ECMAScript, BOM, DOM.

12.3. Краткие итоги

JavaScript – объектно-ориентированный скриптовый язык программирования.

Основные архитектурные черты JavaScript:

Для добавления JavaScript -кода на страницу, можно использовать теги <script></script>. При этом JavaScript можно внедрять в страницу следующими способами:

Область применения JavaScript достаточно широка:

Среди известных JavaScript библиотек можно отметить Adobe life, Dojo Toolkit, ExtJS, jQuery, Mootools, Prototype, Qooxdoo.

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

В целях безопасности JavaScript имеет два ограничения:

JavaScript имеет проблемы безопасности, связанные с: