XUL/Введение в JavaScript

JavaScript - кроссплатформенный язык программирования с динамической типизацией. Это быстрый встраиваемый язык, используемый не только в Web, но и в XUL. Здесь он предназначен для динамического управления внешним видом, общения по сети с другими серверами, и др. JavaScript похож на С, но значительно гибче его. JavaScript появился в недрах компании Netscape и использовался в одноимённом браузере.

Переменные

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

// 1
var x;

// 2
y = 100;

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

var x  = 100;
x = 200.2;
x = "test";

Конечное значение переменной x - строка «test».

Попытка использовать необъявленную переменную (за исключением операции присваивания, как показано вначале) приводит к генерации исключения ReferenceError.

Константы

Константы - переменные, которые не могут менять своё значение или переопределяться во время работы скрипта. Например

const a = "some string";
const b = 100;

a = 100; // ошибка, "a" не изменится

Значения переменных

Переменные могут хранить несколько типов значений:

• числовые, включая дробные - 100, 3.14;
• строковые - "some string";
• булевые - true или false;
• null - специальное нулевое значение;
• undefined - значение не определено.

Значение undefined ведёт себя как false, если используется в булевых операциях. Результатом арифметических операций определённых и не определённых переменных будет NaN, например

var x; // значение "x" - undefined, не определено

if(!x)
    x = 100; // x == 100

var x; // x == undefined

var z = x * 100; // z == NaN

Значение null ведёт себя как false и как 0 соответственно в булевых и численных операциях, например

var x = null;

if(!x)
    x = 100; // x == 100

var x = null;

var z = x * 2; // z == 0

Литералы

Литералы - значения, используемые в коде прямым текстом, например 1.24, "some string". В JavaScript есть несколько типов литералов:

• массивы
• булевы
• дробные числа
• целые числа
• объекты
• строки

Например:

// переменной "x" присвоен массив из трёх чисел - 100, не определено, 200.
var x = [100, , 200];

// переменной "x" присвоен литерал "true".
var x = true;

// переменной "x" присвоен литерал "200".
var x = 200;

// переменной "x" присвоен литерал "3.14".
var x = 3.14;

// переменной "x" присвоен литерал "2.2e+10" (другая форма записи дробного числа).
var x = 2.2e+10;

// переменной "x" присвоен литерал "hello, world!\n". Escape-последовательности
// поддерживаются такие же, как и в C.
var x = "hello, world!\n";

// переменной "x" присвоен литерал "½#M". Поддерживаются Unicode последовательности
// "\uXXXX" (XXXX - 16-ричное число), ASCII последовательности "\xXX" (XX - 16-ричное число)
// и "\XXX" (XXX - 8-ричное число).
var x = "\u00BD\x23\115";

// переменной "x" присвоен объектный литерал, теперь "x" ссылается на объект,
// у которого 3 поля "first", "second" и "third" (аналогично структуре в C).
var x = { first: 100, second: 2.2, third: "hmm" };

// пример использования объекта
var y = x.first; // y теперь равен 100.

Операторы

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

доступ к члену, создание нового объекта	[] . new
вызов функции	()
инкремент, декремент	++ --
логическое не, бинарное не, одиночные +/-, тип, void, удаление	! ~ + - typeof void delete
умножение, деление, модуль	* / %
сложение, вычитание	+ -
бинарные сдвиги	<< >> >>>
отношения, существование, определение	< <= > >= in instanceof
равенство, тождественное равенство	== != === !==
бинарное И	&
бинарное ИЛИ-НЕ	^
бинарное ИЛИ	ǀ
логическое И	&&
логическое ИЛИ	ǁ
условие	?:
присвоение	= += -= *= /= %= <<= >>= >>>= &= ^= ǀ=
запятая	,

Стоит отметить, что

• тождественное равенство или неравенство учитывает не только значения переменных, но и их тип;
• new распределяет память под новый объект указанного типа, аналогично C++:

var d = new Date();

• delete служит для удаления переменных распределённых с помощью new (1), переменных созданных автоматически (2), "своих" свойств объектов (3), и элементов массивов (длина массива не меняется) (4):

// 1
var x = new Date();
delete x;

// 2
x = 100;
delete x;

// 3
var x = new Date();
x.prop = 200;
delete x.prop; // свойства "prop" больше нет

// 4a
var x = new Array(1, 2, 3, 4, 5);
delete x[0]; // элемента больше нет

// 4b
var x = [ 1, 2, 3, 4, 5];
delete x[0];

• typeof возвращает строку с типом объекта:

var x;          // typeof x == "undefined"
var y = 100;    // typeof y == "number"
var z = "str";  // typeof z == "string"
var g = [1, 2]; // typeof g == "object"
function s() {} // typeof s == "function"

• instanceof возвращает true, если данный объект является объектом данного типа. Иначе возвращает false:

var x = [1, 2];

if(x instanceof Array) // true
    ...

• in возвращает true, если данное имя свойства или его индекс присутствуют в данном объекте:

var x = [1, 2];

if(0 in x) // true, свойство по индексу 0 есть - число 1
    ...

if(3 in x) // false, такого индекса нет
    ...

if("prop" in x) // false, свойства с именем "prop" нет
    ...

x["prop"] = 100;

if("prop" in x) // true, свойство с именем "prop" уже есть
    ...

Функции

Для создания функции используется ключевое слово function. Функция одновременно является и объектом. Да, это свойство JavaScript. Функция - это объект стандартного класса объектов Function, который мы рассмотрим ниже в главе Предопределённые объекты. Функции можно объявлять одну в одной, в таком случае внутренняя функция видна только внутри той функции, в которой она объявлена. Внутри функции можно создавать переменные, которые не видны за пределами данной функции (кроме свойств, задействуя дуальную природу функций), и прячут глобальные переменные. Параметры передаются в скобках через запятую, без указания типа. Функция может возвращать значение с помощью ключевого слова return [литерал или переменная]. Например:

// объявление функции f с аргументами a и b
function f(a, b)
{
    // тело функции
    ...
}

var a = 100;

function f()
{
    a = 200;
}

// a == 200, использовалась глобальная переменная "a"

var a = 100;

// аргумент функции "a" прячет глобальный идентификатор "a",
// поэтому внутри этой функции мы будем работать с аргументом, а не
// с глобальной переменной
function f(a)
{
    a = 200;
}

var z;
f(z);

// a == 100, глобальная переменная не поменялась

function f()
{
    // внутренняя функция
    function func() { return 100; }

    var a = func(); // a == 100, использовалась внутренняя функция "func()"
}

// x == undefined, внутренняя функция "func()" не видна
// за пределами "f"
var x = typeof(func);

// функция, возвращающая число 100
function f()
{
    return 100;
}

function f2()
{
    return; // аналогично как в void функции в С
}

var x = f(); // x == 100

x = f(); // x == undefined т.к. функция ничего не вернула

Параметры примитивных типов передаются по значению, сложных (объекты) - по значению ссылки (как в Java). Это значит, что если функция принимает сложный объект как параметр, она сможет менять его свойства, но не сам объект. Такое поведение сходно с поведением функции в С, которая принимает на вход указатель. Например:

#include <stdio.h>
#include <stdlib.h>

struct S
{
    int a;
};

void f(struct S *s)
{
    struct S *s2 = (struct S *)malloc(sizeof(struct S));
    s2->a = 200;

    // пробуем переустановить поле
    s->a = 100;

    // пробуем переустановить сам указатель
    s = s2;
}

int main(int argc, char **argv)
{
    struct S *s = (struct S *)malloc(sizeof(struct S));

    f(s);

    // "s" не поменялся, но память утекла :-)
    // s->a == 100
    printf("%d\n", s->a);

    return 0;
}

Аналогично и в JavaScript:

function f(obj)
{
    // поменяем свойство объекта
    obj.prop = "another";

    // попробуем поменять сам объект
    obj = { first: "hello" };
}

var x = { prop: "other" };

f(x);

// теперь
// x.prop == "another"
// x.first == undefined

Функции можно создавать по условию:

if(false)
{
    function f()
    {
        alert("hello");
    }
}

alert(typeof f); // "undefined"

if(true)
{
    function f()
    {
        alert("hello");
    }
}

alert(typeof f); // "function"

И даже присваивать переменным:

var x = function() { alert("hello");  }

x();

Можно передавать в качестве аргументов в другие функции:

function a(obj)
{
    var x = obj(); // подразумеваем, что obj - функция

    return x;
}

function f()
{
    return 100;
}

var y = a(f); // y == 100
var z = a( function() { return 200; } ); // z == 200

Возвращать из других функций:

function f()
{
    return function() { return 300; };
}

var x = f()(); // x == 300

И даже использовать в качестве прототипов объектов с поддержкой замыканий:

function a()
{
    this.x = 200;

    this.returnsomething = function() { return 100; }
}

var x = new a();
var y = x.returnsomething();

// x.x == 200
// y == 100

Неплохо, верно? :-)

Предопределённые функции

• escape(str)

Возвращает Unicode строку, в которой все символы не из латинского алфавита и набора * @ - _ + . / заменены на %XX (например пробел - %20), а все символы выше ASCII - на Unicode представление вида %uXXXX. Например:

escape("Hello world"); // вернёт "Hello%20world" escape("hello #%"); // "hello%20%23%25" escape("hello½"); // "hello%BD" escape("hello☺"); // "hello%u263A"

Не рекомендуется использовать эту функцию для кодирования URI, используйте encodeURI().

• unescape(str)

Проделывает обратные операции - заменяет все специальные последовательности символов на реальные символы.

• encodeURI(str)

Кодирует URI. Не кодирует символы : / ; ?, которые можно закодировать с помощью encodeURIComponent(). Например:

encodeURI("http://хеллоу.com"); // "http://%D1%85%D0%B5%D0%BB%D0%BB%D0%BE%D1%83.com"
encodeURI("http://hello world.com"); // "http://hello%20world.com"

• decodeURI(str)

Проделывает обратные операции.

• encodeURIComponent(str)

Кодирует URI, включая символы : / ; ?, а это значит что URI, содержащий несколько компонент (/dir1/dir2/index.html), станет нечитаем веб-сервером. В таком случае пользуйтесь encodeURI.

• decodeURIComponent(str)

Проделывает обратные операции.

• isFinite(num)

Проверка на конечность числа:

if(isFinite(x))
...

• isNaN(num)

Проверка на NaN (не-число) значение:

if(isNaN(x))
...

• parseInt(str [, radix])

Конвертация строки, содержащей число, в число:

var x = parseInt("0xFF", 16); // x == 255

• parseFloat(str)

Конвертация строки, содержащей дробное число, в число:

var x = parseFloat("2.24355e+2"); // x == 224.355
var y = parseFloat("100"); // y == 100

• String(obj)

Конвертация объекта в строку, использует метод toString() в объекте:

var d = new Date();
var x = String(d); // "Thu Sep 18 2008 21:56:44 GMT+0300 (EET)"

var d2 = { some: "string in object", toString: function() { return "" + this.some; } };
var x2 = String(d); // "string in object"

• Number(obj)

• eval()

Есть также несколько очень полезных методов в объекте window:

• dump

Вывод в шелл сообщения. Может быть полезно при отладке. Например:

var x = 1;
...
dump("Value of x: " + x + "\n");

• alert

Показывает визуальное сообщение (message box). Например:

var x = 1;
...
alert("Value of x: " + x);

Объекты

Объекты - это некие сложные сущности, хранящие свойства. Свойством может быть число, строка, метод и т.д. Это аналогично объектам в C++ или С. С объектами связано понятие прототипа. Прототип - это объект, хранящий свойства и методы для объекта внутри которого он объявлен, наподобие определения класса в C++. При создании новых объектов с помощю new, все эти объекты будут иметь свойства, определённые в прототипе. Уже созданные объекты с помощью new (до изменения прототипа) также будут иметь новые свойства, определённые в прототипе. К прототипу обращаются через имя базового объекта (Object, Date, и т.д.) и слова "prototype". Можно дописывать прототип своих и предопределённых объектов. Например:

// объект x создали до изменения прототипа
var x = new Date();

// добавляем в стандартный объект Date свой метод
Date.prototype.mymethod = function()
{
    return 100;
}

// добавляем в стандартный объект Date своё числовое свойство
Date.prototype.X = 255;

// объект y создали после изменения прототипа
var y = new Date();

var z1 = x.mymethod(); // z1 == 100
var z2 = y.mymethod(); // z2 == 100

var z3 = x.X; // z3 == 255
var z4 = y.X; // z4 == 255

Для своих классов объектов можно полностью перезаписывать прототип, например, как показано в следующей главе с классом объектов Shop. Используем пример попроще:

// базовый объект, с пустым телом
function Shop() {}

// полностью перезаписали прототип на свой объект, который суть
// есть объект-инициализатор, которые мы рассмотрим ниже
// в пункте "прямая инициализация"
Shop.prototype =
{
    // все объекты класса Shop будут иметь этот метод
    method: function(which)
    {
        return 100;
    }
}

var o1 = new Shop();
var o2 = new Shop();

var z1 = o1.method(); // z1 == 100
var z2 = o2.method(); // z2 == 100

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

• прямая инициализация

Мы уже рассматривали такой способ выше. В фигурных скобках через запятую создаются пары имя_свойства:значение_свойства (т.н. объектный литерал, литерал-объект, object literal):

// создали объект
var x = { some: "string in object", toString: function() { return this.some; } };

// вызвали его метод
var s = x.toString();

• с помощью функции-прототипа и операции new

Мы уже рассматривали такой способ выше.

Отметим лишь, что объект объявленный через {} а не через function не может служить классом объектов, т.е. нельзя создать другие такие же объекты с помощью операции new:

function a(X)
{
    // создаём новые свойства через "this" ссылку,
    // к которым можно будет обращаться после создания объекта
    this.x = X;

    this.returnsomething = function() { return 100; }
}

// новый объект
var x = new a(10);
var y = x.returnsomething();

// x.x == 10
// y == 100

var z = x.x + y; // z == 110

var O = {};
var x = new O(); // исключение "TypeError: O is not a constructor"

• медленная инициализация

Основана на свойстве JavaScript создавать свойства по мере обращения к ним на запись:

var z = {}; // пустой объект

// создали свойство "value" со значением "200"
z.value = 200;

// создали свойство-метод, который возвращает свойство "value"
z.getValue = function() { return this.value; }

var y = z.getValue(); // y == 200

Заметим, что внедрять таким образом свои свойства можно в любые объекты.

Вы уже заметили, что мы несколько раз использовали ключевое слово this. Это ссылка на текущий объект, в котором используется this, аналогично как в C++ или Java. По этой ссылке можно получать доступ к свойствам объекта из контекста самого объекта, например из вызываемой функции getValue(). За пределами всех объектов this ссылается на глобальный объект окна.

К свойству можно обращаться двумя способами:

• напрямую по имени

var a = {};
a.x = 100;
var z = a.x; // z == 100

• как к члену массива свойств, по имени

var a = {};
a.x = 100;
var z = a["x"]; // z == 100

Предопределённые объекты

Object (базовый объект)

Object представляет собой базовый объект. Все стандартные объекты (Date, Math, и т.д.) наследуются от него. Экземпляры базового объекта можно создавать с помощью new или инициализатором, как показано выше. Например:

var o = {}; // инициализатор, typeof(o) == object
var o2 = new Object(); // typeof(o2) == object

Методы:

• hasOwnProperty - определяет, является ли аргумент прямым свойством объекта

Наследованные свойства, или свойства находящиеся в прототипе, не являются прямыми свойствами данного объекта. Например:

function Shop()
{
    this.d = "direct property";
}

Shop.prototype =
{
    things: [ "dvd", "cd" ],

    sell: function(which)
    {
        return this.things.indexOf(which) >= 0;
    },

    toString: function()
    {
        return "We have " + this.things;
    }
}

var x = new Shop();

var y = x.hasOwnProperty("things"); // false, т.к. things - свойства из прототипа
var z = x.hasOwnProperty("d"); // true, прямое свойство

• isPrototypeOf - определяет, является ли один объект прототипом другого

Объект Shop возьмём из прошлого пункта.

var x = new Shop(); // объект Shop
var y = {}; // обычный объект

function MegaShop() {} // другой магазин

MegaShop.prototype = new Shop(); // наследник Shop

var z = new MegaShop();

var b1 = Shop.prototype.isPrototypeOf(x); // true, прототип x - это прототип Shop
var b2 = Shop.prototype.isPrototypeOf(y); // false, прототип y - не прототип Shop
var b3 = Shop.prototype.isPrototypeOf(z); // true, прототип z - прототип Shop

• propertyIsEnumerable - определяет, является ли свойство перечислимым

Если свойство не перечислимо, оно не будет появляться в операциях перечисления свойст объекта, например с помощью for(i in obj). Свойства объявленные в прототипе не перечислимы.

var x = new Shop();

var b1 = x.propertyIsEnumerable("things"); // false, things - свойство прототипа
var b2 = x.propertyIsEnumerable("toString"); // false, toString - наследованое свойство
var b3 = x.propertyIsEnumerable("d"); // true, d - прямое свойство

• toString - возвращает объект как строку

Это важный метод, преобразующий объект в строку там, где подразумеваются операции со строками. Можно (и скорее всего нужно) переопределить toString для своих классов объектов. По умолчанию возвращает строку «[object Object]». Стандартные объекты (Date, Number, и т.д.) переопределяют этот метод. toString уже определён в нашем объекте Shop. Например:

var x = new Shop();

// dump принимает строку как аргумент,
// результатом операции "+" будет строка "We have dvd,cd".
//
// JavaScript при сложении фактически выполнит
// x.toString() + "\n". Важно, что при вызове нашего метода toString (где происходит
// сложение строки "We have " и массива things), JavaScript также преобразует
// встроенный массив things в строку.
dump(x + "\n");

• valueOf - возвращает примитивное хранимое значение

Используется редко. Можно (и скорее всего нужно) переопределить valueOf для своих классов объектов.

Array (массив)

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

var x = new Array(); // пустой массив
var y = new Array(100, 200, "string"); // 3 элемента - 2 числа и строка
var z = [1, 2, 3]; // также объект Array

var z1 = y[0]; // z1 == 100
var z2 = y[2]; // z2 == "string"

К элементам массива можно обращаться (как на чтение, так и на запись) через оператор доступа []. Индексация элементов, также как и в С, начинается с 0.

Массив имеет свойство length, которое доступно на чтение и запись. Массив может динамически менять сой размер при записи несуществующих элементов через оператор доступа [], или через запись значения в свойство length. Важно помнить, что массив не может быть дырявым, т.е. он всегда имеет length-1 элементов, некоторые из которых могут быть не определены (undefined, несуществующие элементы). Например:

var x = new Array(); // пустой массив
x[30] = 100;

// z == 31, 30 undefined элементов и 1 число
var z = x.length;

Методы:

• concat - объединение

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

var x = new Array();
var y = new Array(100, 200, "string");

var z = x.concat(y); // z == [ "1", 100, 200, "string" ]

• join - объединение в строку

Объединяет элементы массива в строку, принимая разделитель элементов в строке как аргумент. Разделитель по умолчанию - ", ":

var y = new Array(100, 200, "string");

var z = y.join(", "); // z == "100, 200, string"

• pop - удаляет и возвращает последний элемент

var y = new Array(100, 200, "string");
var z = y.pop(); // z == "string", размер массива == 2 элемента

• push - вставляет элемент в конец, возвращает длину массива

var y = new Array(100, 200, "string");
var z = y.push("string2"); // z == 4, размер массива == 4 элемента

• reverse - обращает следование элементов

var y = new Array(100, 200, "string");
y.reverse(); // y == [ "string", 200, 100 ]

• shift - удаляет и возвращает первый элемент

var y = new Array(100, 200, "string");
var z = y.shift(); // z == 100, размер массива == 2 элемента

• slice - возвращает секцию

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

var y = new Array(100, 200, "string");
var z = y.slice(1,3); // z == [ 200, "string" ]

• splice - вставляет элементы, с возможностью удаления

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

var y = new Array(100, 200, 300, "string");

y.splice(1, 0, "hehe", "str"); // y == [ 100, "hehe", "str", 200, 300, "string" ]

y.splice(1, 2, "hehe2", "str2");  // y == [ 100, "hehe2", "str2", 200, 300, "string" ]

• sort - сортировка массива

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

var y = new Array(11, 2, 3, 4, 10, 0);
y.sort(); // y == [ 0, 10, 11, 2, 3, 4 ], странновато отсортировано

y = new Array(11, 2, 3, 4, 10, 0);

// используем прямое сравнение, т.к. мы знаем, что наши аргументы - числа,
// на выходе получаем нормально отсортированный массив
y.sort(
function(a, b)
{
    if(a < b) return -1;
    if(a > b) return 1;
    if(a  == b) return 0;
});

// y == [ 0, 2, 3, 4, 10, 11 ], отсортировано нормально

• unshift - втавляет элементы в начало, возвращает длину массива

var y = new Array(100, 200);
var z = y.unshift(400, 500); // z == 4, y == [ 400, 500, 100, 200 ]

Date (дата)

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

var d;

d = new Date(); // текущая дата
d = new Date("September 19, 2008 00:30:00"); // из строки
d = new Date(2008, 11, 19); // год, месяц (начиная с нуля), день
d = new Date(2008, 11, 19, 0, 30, 0); // год, месяц, день, час, минуты, секунды

Методы:

• getTime - возвращает количество миллисекунд с начала эпохи

d = new Date(2008, 11, 19, 0, 30, 0);
var z = d.getTime(); // z == 1229639400000

• getFullYear - возвращает полный год

d = new Date(2008, 11, 19, 0, 30, 0);
var z = d.getFullYear(); // z == 2008

• getYear - возвращает год, начиная с 1900

d = new Date(2008, 11, 19, 0, 30, 0);
var z = d.getYear(); // z == 108

• getMonth - возвращает номер месяца

d = new Date(2008, 11, 19, 0, 30, 0);
var z = d.getMonth(); // z == 11

• getDay - возвращает день недели

d = new Date(2008, 11, 19, 0, 30, 0);
var z = d.getDay(); // z == 5

• getDate - возвращает день месяца

d = new Date(2008, 11, 19, 0, 30, 0);
var z = d.getDate(); // z == 19

• getHours - возвращает часы

d = new Date(2008, 11, 19, 0, 30, 0);
var z = d.getHours(); // z == 0

• getMinutes - возвращает минуты

d = new Date(2008, 11, 19, 0, 30, 0);
var z = d.getMinutes(); // z == 30

• getSeconds - возвращает секунды

d = new Date(2008, 11, 19, 0, 30, 25);
var z = d.getSeconds(); // z == 25

• getMilliseconds - возвращает миллисекунды

d = new Date(2008, 11, 19, 0, 30, 25);
var z = d.getMilliseconds(); // z == 0

• getTimezoneOffset - возвращает смещение по GMT

d = new Date(); // текущее локальное время и дата
var z = d.getTimezoneOffset(); // z == -180 (GMT+03, Беларусь)

• набор аналогичных методов, но для UTC зоны:
  1. getUTCFullYear - возвращает полный год
  2. getUTCMonth - возвращает год, начиная с 1900
  3. getUTCDate - возвращает день месяца
  4. getUTCDay - возвращает день недели
  5. getUTCHours - возвращает часы
  6. getUTCMinutes - возвращает минуты
  7. getUTCSeconds - возвращает секунды
  8. getUTCMilliseconds - возвращает миллисекунды

• набор методов для установки времени:
  1. setFullYear(year, [month], [day])
  2. setYear(year)
  3. setMonth(month, [day])
  4. setDate(day_of_month)
  5. setHours(hours, [minutes], [seconds], [millisec])
  6. setMinutes(minutes, [seconds], [millisec])
  7. setSeconds(seconds, [millisec])
  8. setMilliseconds(milli)
  9. setTime(milli)

• набор методов для установки времени, для UTC зоны
  1. setUTCFullYear(year, [month], [day])
  2. setUTCMonth(month, [day])
  3. setUTCDate(day_of_month)
  4. setUTCHours(hours, [minutes], [seconds], [millisec])
  5. setUTCMinutes(minutes, [seconds], [millisec])
  6. setUTCSeconds(seconds, [millisec])
  7. setUTCMilliseconds(milli)

• toLocaleString - возвращает дату и время в виде строки, в текущей локали

d = new Date();
var z = d.toLocaleString(); // z == "Птн 19 Сен 2008 00:20:40"

• toLocaleDateString - возвращает дату в виде строки, в текущей локали

d = new Date();
var z = d.toLocaleDateString(); // z == "19.09.2008"

• toLocaleTimeString - возвращает время в виде строки, в текущей локали

d = new Date();
var z = d.toLocaleTimeString(); // z == "00:22:08"

• toString - возвращает полное описание даты, включая GMT смещение

d = new Date();
var z = d.toString(); // z == "Fri Sep 19 2008 00:22:38 GMT+0300 (EET)"

• toUTCString - возвращает полное описание даты для UTC зоны

d = new Date();
var z = d.toUTCString(); // z == "Thu, 18 Sep 2008 21:27:29 GMT"

• parse - возвращает количество миллисекунд для даты из строки

d = new Date();
var z = Date.parse("Sep 19, 2008"); // z == 1221771600000

• valueOf - аналогично getTime

Function (функция)

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

var x = new Function ("a", "b", "c", "return (a + b + c);");

var z = x("hello", ", ", "world"); // z == "hello, world"

Math (математика)

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

Методы:

• abs - возвращает абсолютное значение

var x = Math.abs(-1.1); // x == 1.1

• sin, cos, tan - тригонометрические функции, аргумент - радианы

var x = Math.sin(1); // x == 0.8414709848078965

• acos, asin, atan, atan2 - обратные тригонометрические функции

var x = Math.asin(0.8414709848078965); // x == 1

• exp, log - экспоненциальный и натуральный логарифм

var x = Math.log(2.718281828459045); // x == 1

• ceil - округляет в большую сторону

var x = Math.ceil(2.7); // x == 3

• floor - округляет в меньшую сторону

var x = Math.floor(2.7); // x == 2

• min, max - возвращает минимум и максимум

var x = Math.min(-3, 10); // x == -3

• pow - возведение в степень

var x = Math.pow(10, 2); // x == 100

• random - возвращает случайное число от 0 до 1

var x = Math.random(); // x == 0.577903639379265
var y = Math.random(); // y == 0.9858962869730497

• round - округление к ближайшему целому

var x = Math.round(2.99); // x == 3

• sqrt - возвращает квадратный корень числа

var x = Math.sqrt(25); // x == 5

Константы:

• Math.E - число Эйлера, т.н. e
• Math.LN2 - натуральный логарифм из 2
• Math.LN10 - натуральный логарифм из 10
• Math.LOG2E логарифм по основанию 2 из e
• Math.LOG10E - десятичный логарифм из e
• Math.PI - число Пи
• Math.SQRT1_2 - квадратный корень из 1/2
• Math.SQRT2 - квадратный корень из 2

Number (число)

Объект Number содержит различные методы для операций с числом и константы. Имеет конструктор.

Методы:

• toExponential - возвращает строку с записанным числом в экспоненциальном виде

var z = new Number(2200);
var x = z.toExponential(); // x == "2.200e+3"

• toFixed - возвращает строку с записанным числом в фиксированном виде

var z = new Number(2.200e+3);
var x = z.toFixed(); // x == "2200"

• toPrecision Returns a string representing the number to a specified precision in fixed-point notation.
• toSource - возвращает строку с кодом, создающую данный объект

var z = new Number(2.5);
var x = z.toSource();

var y = eval(x); // y == 2.5

• toString - объект в виде строки

var z = new Number(2.5);
var x = z.toString(); // x == "2.5"

• valueOf

Константы:

• 'Number.MAX_VALUE - максимально возможное значение
• Number.MIN_VALUE - минимально возможное значение
• Number.NaN - значение для представления не-числа
• Number.NEGATIVE_INFINITY - отрицательная бесконечность
• Number.POSITIVE_INFINITY - положительная бесконечность

String (строка)

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

// JavaScript автоматически преобразует строковый литерал во временный объект
// String, и выполнит запрошенный метод
var y = "Hello".toLowerCase(); // y == "hello"

Методы:

• anchor - возвращает html ссылку, аргумент - атрибут ссылки "name"

var x = new String("hello");
var y = x.anchor("http://hello.com"); // y == "<a name="http://hello.com">hello</a>"

• big, blink, bold, fixed, italics, small, strike, sub, sup - html форматирование строки

var x = new String("hello");
var y = x.big(); // y == "<big>hello</big>"
var z = x.bold(); // z == "<b>hello</b>"

• charAt, charCodeAt - возвращают символ и код символа по позиции в строке

var x = new String("hello");
var y = x.charAt(2); // y == "l"
var z = x.charCodeAt(); // z == 104 (символ 'l')

• indexOf, lastIndexOf - возвращают позицию подстроки, и последнюю позицию подстроки

var x = new String("hello");
var y = x.indexOf("l"); // y == 2
var z = x.lastIndexOf("l"); // z == 3

• link - возвращает html ссылку, аргумент - атрибут ссылки "href"

var x = new String("hello");
var y = x.link("http://hello.com"); // y == "<a href="http://hello.com">hello</a>"

• concat - возвращает объединение двух строк

var x = new String("hello, ");
var y = x.concat("http://hello.com"); // y == "hello, http://hello.com"

• fromCharCode - возвращает строку, составленную из переданных кодов символов

Этот метод должен вызываться напрямую через объект String:

var x = String.fromCharCode(0x2639, 0x263a); // x == "☹☺"

• split - возвращает массив строк, полученный из разделённой на части строки

Аргументы - строка-разделитель (или регулярное выражение), и максимальное количество обработанных элементов.

var x = new String("1, 2, 3, 4");

// "," - разделитель, число 2 - находим максимум 2 элемента
var y = x.split(",", 2); // y == [ "1", "2" ]

var x = new String("");
var y = x.split(","); // y = [ "" ]

• slice - возвращает подстроку между указанными индексами

var x = new String("hello, world");
var y = x.slice(5, 8); // y == ", w"
var z = x.slice(5); // z == ", world"

• substring, substr - возвращают подстроки

var x = new String("hello, world");

// подстрока между первым индексом и вторым
var y = x.substring(7, 10); // y == "wor"

// подстрока от индекса, с указанной длиной подстроки
var z = x.substr(0, 4); // z == "hell"

• match, replace, search - поиск и замена подстрок, опираясь на регулярные выражения

var x = new String("hello, world");

// поиск регулярного выражения "o.", что значит "символ o и любой другой символ за ним",
// возвращает массив найденных совпадений, в данном случае - 2 совпадения
var y = x.match(/o./g); // y == [ "o,", "or" ]

var x = new String("hello, world");

// поиск и замена на,строку "!"
var y = x.replace(/o./g, "!"); // y == "hell! w!ld"

var x = new String("hello, world");

// поиск и замена используя функцию, принимающую как аргумент найденное совпадение
// и возвращающую строку
var y = x.replace(/o./g, function(a) { return a + "!"; }); // y == "hello,! wor!ld"

var x = new String("hello, world");

// поиск регулярного выражения, возвращает найденный индекс, или -1
var y = x.search(/o./); // y == 4

• toLowerCase, toUpperCase - возвращают строки в нижнем и верхнем регистрах

var x = new String("Hello, World");
var y = x.toLowerCase(); // y == "hello, world"
var z = x.toUpperCase(); // z == "HELLO, WORLD"

Вставка в XUL документ

Вставить код JavaScript в XUL документ можно двумя способами:

• прямой вставкой

В этом случае мы обрамляем JavaScript код элементом script:

<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>

<window
    title="Example"
    width="320" height="200"
    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">

<script type="application/x-javascript">

function func()
{
    alert("Hello");
}

addEventListener("load", func, false);

</script>

</window>

Надо помнить, что в этом случае XML парсер нашего документа сочтёт, например, операторы > и <, элементами XML разметки. В этом случае надо использовать специальную XML секцию CDATA, внутри которой и пишется код. Например:

<script type="application/x-javascript">

<![CDATA[

function func()
{
    var x = 0;

    // сложный момент для XML парсера, но мы предупредили его
    // с помощью секции CDATA
    if(x < 0)
        alert("Hello");
}

addEventListener("load", func, false);

]]>

</script>

• внешней вставкой

Аналогично с помощью элемента script и атрибута src вставляем JavaScript код из внешнего файла:

<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>

<window
    title="Example"
    width="320"
    height="200"
    xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">

<script type="application/x-javascript" src="example.js" />

</window>

Где файл example.js лежит в этом же каталоге, где и XUL документ. Можно указывать относительные пути, и chrome:// пути.

Ссылки

• [1]
• [2]
• [3]
• [4]