8. Преобразование типов. Слабый контроль типов.

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

var х = "3.14"; х = 3.14;

Результаты преобразования к значению типа Boolean

Тип	Конвертируется в булево значение
Неопределенный (Undefined)	False
Пустой (Null)	False
Числовой (Number)	False, если это 0 или NaN, иначе true
Строковый (String)	False, если это длина строки равна 0, иначе true
Другие объекты	True

Результаты преобразования к значению типа Number

Тип	Конвертируется в числовое значение
Неопределенный (Undefined)	NaN
Пустой (Null)	0
Логический (Boolean)	1,если это true, 0, если это false
Строковый (String)	Соответствующее числовое значение, если строка похожа на число, иначе NaN
Другие объекты	NaN

Результаты преобразования к значению типа String

Тип	Конвертируется в строку
Неопределенный (Undefined)	"undefined"
Пустой (Null)	"null"
Логический (Boolean)	"true", если это true, " f а 1 se ", если это false
Числовой (Number)	"NaN", " 0 " или строка, представляющая соответствующее числовое значение
Другие объекты	Значение, возвращаемое объектом с помощью метода toStr ing (), если таковой имеется, иначе "undefined

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

9. Принципы построения операторов. Арифметические операции.

Операторы являются инструкциями интерпретатору по выполнению конкретных действий. Оператор присваивания = - в результате присваивания значение переменной стоящее справа от помещается в переменную стоящую слева. x= y+12;

; - указание конца оператора.

{} – группировка набора последовательно идущих операторов, создание одного большого оператора или блока программного кода.

Арифметические операции: +, -,*,/,%, ++ (инкремент), --(декремент)

var x=3, y=6;

x=-x;

x=y+2;

x=y-1;

Когда знак операции инкремента(декремента) размещается слева от операнда, запись называется префиксной записью, а когда этот знак размещается справа – постфиксной записью. Постфиксная и префиксная запись отличаются порядком выполнения действий. 1. Увеличение операнда на 1. 2. Использовать значение операнда (х) как значение выражения (х++или ++х)

Префиксная запись выполняет сначала шаг 1, а потом шаг 2, а постфиксная - наоборот.

var x=10, y=10;

alert(“x++ = “+(x++)+”; ++y = “+(++y)) //10 11

alert(“x = “+x+”; y = “+y); //11 11

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

Конкатенация строк. Оператор +

12. Ветвление в JS. Операторы if u switch.

Для создания конструкций ветвления (условных переходов) JavaScript поддерживает условные опера­торы типа if и switch-case, которые дают возможность выборочного выполне­ния кусков программного кода.

Общий вид записи оператора if:

if (выражение) оператор;

Указанное выражение приводится к логическому значению, и если оно принима­ет значение true, то выполняется оператор. Иначе оператор if пропускается.

Вариантом оператора if является оператор if-else, позволяющий выполнить один оператор, если усовие истинно, и другой оператор, если условие ложно:

if (выражение)

оператор1

else

оператор2

При необходимости операторы if-else можно помещать друг в друга, для организации множественного ветвления:

if (выражение1)

оператор1 else if (выражение2)

оператор2 else if (выражениеЗ)

оператор3 else

оператор4

Пример:

if(x > 10){

x = 0;

}

else {

x = x + 1;

}

Сначала оценивается условие оператора if и, если сравнение дает true (т.е. х дей­ствительно больше 10), то х устанавливается равным нулю. Иначе для х выполняется приращение.

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

Общий вид записи этого оператора:

switch (выражение) {

case значение_1: оператор(ы)

case значение_2: оператор(ы)

…

case значение_N: оператор(ы)

default: оператор(ы)

}

В зависимости от значения переменной выражение во время выполнения программы будет исполнен тот код, в начале которого стоит метка case со значением этой переменной. Если такой метки не найдется, то будет выполнен код с меткой default, а при его отсутствии оператор switch будет пропущен.

Если выполнение программы перешло к одной из строк case, то выполнение оператора не прекращается по достижению следующей строки case. Например, в коде

var a = 5, s = "";

switch(a){

case 6: s +=a;

case 5: s +=a;

case 4: s +=a;

case 3: s+=a;

default: s+=" s= "+a;

}

alert(s);

выполняются все подчеркнутые выше строки:

Поэтому после case: может идти более одного оператора, в отличие от if.

Для того, чтобы завершить оператор switch, используется оператор break;. Используя этот оператор, можно все операторы, идущие после меток case внутри switch, сделать взаимоискоючающими, ставя break перед каждой следующей строкой с меткой case:

var a = 5, s = "";

switch(a){

case 6: s +=a; break;

case 5: s +=a; break;

case 4: s +=a; break;

case 3: s+=a; break;

default: s+=" s= "+a;

}

alert(s);

Результат:

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

var a = 5, s = "";

if(a === 6) s +=a; else

if(a === 5) s +=a; else

if(a === 4) s +=a; else

if(a === 3) s +=a; else

s+=" s= "+a;

alert(s);

13. Циклы в JS. Операторы for, while и do while.

Часто требуется повторить выполнение ряда операторов несколько раз, пока вы­полняется соответствующее условие. Например, может потребоваться выполнить одно и то же действие с каждым элементом массива, пока не будет достигнут конец этого массива. Как и в других языках программирования, в JavaScript это реализуется с помощью операторов цикла. Циклы продолжают выполнять операторы тела их про­граммного кода до тех пор, пока не будет выполнено условие остановки. В JavaScript поддерживаются циклы while, do-while, for и for-in. Вот

Общий вид цикла while:

while (выражение)

оператор

Благодаря циклу while выполнение некоторого оператора или блока программного кода повторяется до тех пор, пока выражение имеет значение true. Как только вы­ражение получит значение false или будет обнаружен оператор break, произойдет выход из цикла.

Пример цикла while:

var x=0;

while(x < 10) {

document.write(x);

document.write("<br />");

x++;

}

document.write("Готово");

В этом цикле выполняется приращение х до тех пор, пока условие цикла — х меньше 10 — имеет значение true. Как только х принимает значение 10, условие получает зна­чение false, поэтому выполнение цикла заканчивается, а выполнение сценария про­должается с первого оператора, следующего после тела цикла, как показано ниже:

Цикл do-while подобен циклу while, за исключением того, что проверка условия выполняется в конце цикла. Другими словами, do-while – это цикл с постусловием. Это значит, что указанный цикл всегда выполняется как минимум один раз, если только не будет обнаружен оператор break.

Общая запись этого цикла:

do

оператор;

while (выражение);

Пример:

var x=0;

do {

document.write(x);

document.write("<br />");

x++;

} while(x < 10)

document.write("Готово");

В конце оператора do-while обязательна точка с запятой.

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

Его базовый синтаксис выглядит так:

for (инициализация; условие; обновление_переменной) оператор

Оператор инициализация выполняется перед началом цикла, сам цикл продолжает выполняться до тех пор, пока условие не получит значение false и с каж­дой итерацией выполняется обновление_переменной.

Пример:

for(x=0; x<10; x++){

document.write(x);

document.write("<br />");

}

document.write("Готово");

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

var a,b,c,d;

а = (b=5, с=7, d=56);

Ниже приведен пример, позволяющий с помощью запятой использовать в областях инициализации и обновления переменной цикла for использовать более одного оператора:

for(count1=1, count2=4; (count1 + count2) < 10; count1++, count2++)

document.write("Countl= " +count1+ " Count2 = " +count2+ "<br>");

Вариацией цикла for является конструкция for-in. Эта конструк­ция позволяет выполнить цикл по различным свойствам объекта.

Общий вид этого цикла:

for (имя_переменной in объект)

оператор

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

var aProperty;

for (aProperty in window) {

document.write(aProperty)

document.write("<br />");

}

14. Операторы break и continue в циклах.

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

Пример (вывод на экран чисел 1-10, исключая число 5):

var x=0;

while(true){

x++;

if(x >= 10) break;

if(x == 5) continue;

document.write(x);

document.write("<br />");

}

С операторами break и continue можно использовать метки, чтобы напра­вить поток выполнения программы по более точному руслу. Метка — это просто идентификатор, завершенный двоеточием, который применяется к оператору или блоку программного кода. Пример:

outerloop: for (var i = 0; i < 3; i++) {

document.write("Внешний цикл: "+i+"<br />");

for (var j = 0; j < 5; j++) {

if (j == 3)

break outerloop;

document.write("Внутренний цикл: "+j+"<br />");

}

}

document.write("Все циклы завершены"+"<br />");

Метку можно также использовать с оператором continue. Такой оператор con­tinue заставит передать управление потоком выполнения программы циклу, указан­ному меткой.

15.  Основы построения функций. Оператор return.

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

function add(x, y){

var sum = x + y;

return sum;

}

Этот программный код объявляет функцию с именем add, которая вычисляет сумму аргументов и "возвращает" вычисленное значение. Оператор return сообщает интер­претатору, какое значение должна вычислить функция. Можно, например, установить значение функции равным значению некоторой переменной:

var result = add(2, 3);

Функции передаются аргументы 2 и 3, выполняются операторы тела функции, а ре­зультат сложения аргументов — значение 5 — помещается в переменную result.

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

var a=3, b=5;

var result;

result = add(a,b);

Функции в JavaScript на самом деле являются полноцен­ными типами данных. Это значит, что функции рассматриваются наравне с другими непримитивными типами. Их можно присваивать переменным, передавать другим функциям, создавать и уничтожать динамически.

16. Глобальные и локальные переменные.

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

var х;

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

var х = 2;

Кроме того, одним оператором var можно объявить много переменных, если раз­делить переменные запятыми (при этом можно смешивать операторы объявления и инициализации):

var х, у = 2, z;

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

Что есть глобальные переменные: переменные "видимые" в любой точке выполнения программы, везде из можно прочитать и перезаписать. Обычно глобальные переменные определяются в самом начале программы, вне всяких блоков ({}) в случае Js, они задаются после script, или все всяких функций

Таким образом, получается, что на глобальную область использование var никак не влияет. Переменная, упомянутая в script вне процедур считается глобальной даже, если она заключения в скобочки {} блока if while for и других области останется глобальной даже внутри циклов

локальные переменные- переменные задаваемые внутри исполняемого блока (функции) и не виляют на другие функции. и внешнюю среду, т.е. глобальную область.

17. Функции, как обьекты.

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

function add(x, y){

var sum = x + y;

return sum;

}

Этот программный код объявляет функцию с именем add, которая вычисляет сумму аргументов и "возвращает" вычисленное значение. Оператор return сообщает интер­претатору, какое значение должна вычислить функция. Можно, например, установить значение функции равным значению некоторой переменной:

var result = add(2, 3);

Функции передаются аргументы 2 и 3, выполняются операторы тела функции, а ре­зультат сложения аргументов — значение 5 — помещается в переменную result.

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

var a=3, b=5;

var result;

result = add(a,b);

Функции в JavaScript на самом деле являются полноцен­ными типами данных. Это значит, что функции рассматриваются наравне с другими непримитивными типами. Их можно присваивать переменным, передавать другим функциям, создавать и уничтожать динамически.

18. Принципы работы с объектами.

Свойства

Свойство объекта — это именованный фрагмент содержащихся в объекте данных. Свойства доступны с помощью применения к объекту опера­ции, обозначаемой точкой (.). Например,

var myString = new String("Всем привет");

alert(myString.length);

обеспечивает доступ к свойству length объекта String, на который ссылается пере­менная myString.

Попытка доступа к несуществующему свойству возвращает значение undefined:

var myString = new String("Всем привет");

alert(myString.noSuchValue);

В JavaScript также можно использовать свойства экземпляра — свой­ства, динамически добавляемые сценарием:

var myString = new String("Всем привет");

myString.simpleExample = true;

alert(myString.simpleExample);

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

Удалить свойства экземпляра можно с помощью операции delete. Пример:

var myString = new String("Всем привет");

myString.simpleExample = true;

delete myString.simpleExample;

alert("Значением myString.simpleExample является " + myString.SimpleExample);

Результат:

Методы

Свойства, являющиеся функциями, называются методами. Доступ к методам обычно осуществляется с помощью операции точки, аналогично доступу к свойствам. Следующий пример иллюстрирует вызов метода toUpperCase () объекта String:

var myString = new String("Я говорю не слишком громко? ");

alert(myString.toUpperCase()) ;

Можно использовать и синтаксис массива:

var myString = new String("Я говорю не слишком громко? ");

alert(myString["toUpperCase"]());

но такой вариант используется редко.

Установка методов экземпляра тоже аналогична установке свойств экземпляра:

var myString = new String("Я говорю не слишком громко? ");

myString.sayNo = function() { alert("Да нет.");};

myString.sayNo();

19. Базовые и пользовательские объекты. Литералы объектов. Объекты как ассоциативные массивы.

Базовые и пользовательские объекты

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

var robot = new Object();

robot.name = "Парабеллум";

robot.model = "Страж";

robot.hasJetpack = true;

Динамически можно добавлять и функции:

function strikeIntruder(){

alert("БАХ!");

}

robot.attack = strikeIntruder ();

Обратите внимание на то, что мы назвали метод attack, хотя функция называлась strikeIntruder. Это связано с тем, что функция strikeIntruder была добавлена объекту robot как метод attack. Можно использовать и анонимную функцию:

robot.attack = function(){

alert("БАХ!");

};

Этот синтаксис более предпочтителен.

Объекты как ассоциативные массивы

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

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

объект.свойство

и

объект["свойство"]

Ассоциативные массивы в JavaScript — это просто объекты, используемые с синтакси­сом массивов, а пары ключ/значение — это имена свойств экземпляра и их значения. Сохранять значения в массиве можно следующим образом:

var customers = new Object();

customers["John Doe"] = "123 Main St., Metropolis, USA";

А извлечь их можно так:

var address = customers["John Doe"];

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

Литералы объектов. JavaScript поддерживает синтаксис литералов для многих типов данных (в частности, для чисел, строк, массивов и функций), поэтому нет ничего неожиданного в том, что в JavaScript 1.2+ поддерживаются литералы объектов. Их синтаксис - это заключенный в фигурные скобки список разделенных запятыми пар свойство/значение. Пара свойство/значение задается с помощью указания имени свойства, за которым после двоеточия следует соответствующее значение. Ниже предлагается новый вариант предыдущего примера, в котором используются литералы, как объекта, так и функции:

var robot = { name: "Парабеллум", model: "Страж", hasJetpack: true, attack: function() { alert("БАХ!"); } };

20. Прототипы и конструкторы.

Конструкторы

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

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

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

var имя_переменной = new имя_объекта(список_параметров);

Пример: var s = new String();

Можно определить собственный конструктор с помощью функции:

function Robot(){

}

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

var guard = new Robot();

Мы создали экземпляр объекта Robot. При вызове конструктора интерпретатор выделяет память для нового объекта и неявно передает новый объект соответствующей функции. Конструктор может полу­чить доступ к создаваемому объекту, используя this — специальное ключевое слово, содержащее ссылку на текущий объект (для конструктора текущий объект – это новый объект, создаваемый этим конструктором). Интерпретатор делает this доступным, чтобы конструктор мог работать с создаваемым им объектом. Например, это ключевое слово можно использовать для установки значений по умолчанию. Переопределим наш конструктор, чтобы отразить указанную возможность:

function Robot(){

}

function Robot(needsToFly){

if (needsToFly)

this.hasJetpack = true;

else

this.hasJetpack = false;

}

var guard = new Robot(true);

var sidekick = new Robot();

В этом примере мы могли бы явно передать значение false при создании экземпляра sidekick. Но, не передав ничего, мы неявно сделали то же самое, поскольку параметр needsToFly в этом случае получает значение undefined.

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

Прототипы

Каждый объект имеет свойство prototype, указывающее на прототип, который задает структуру объекта. Это ссылка на Object, описывающий программный код и данные, которые будут общими для всех объектов этого типа. Можно добавить в прототип конструктора программный код и данные, которыми должны обладать все объекты Robot. Для этого модифицируем наше определение следующим образом:

Robot.prototype.hasJetpack = false;

Robot.prototype.doAction = function(){

alert("Тревога!");

}

В этом примере мы переместили свойство hasJetpack в прототип и дали этому свойству значение по умолчанию — false. Во-вторых, мы до­бавили в прототип конструктора функцию doAction (). Каждый создаваемый объект Robot теперь будет иметь оба свойства:

var guard = new Robot(true);

var canFly = guard.hasJetpack;

guard.doAction();

Методы могут ссылаться на экземпляр объекта, в котором они содержатся, с по­мощью this. Можно снова переопределить наш класс, чтобы продемонстрировать эту новую возможность:

Robot.prototype.hasJetpack = false;

Robot.prototype.actionValue = "Тревога! Нарушитель!";

Robot.prototype.doAction = function(){alert(this.actionValue);};

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

Изменение прототипов встроенных объектов может оказаться очень полезным. Предположим, что вам часто приходится извлекать из строк третий символ. Можно изменить прототип объекта String так, чтобы все строки имели определенный вами метод:

String.prototype.getThirdChar = function() {

return this.charAt(2);

}

После этого вы можете вызывать этот метод точно так же, как любой встроенный ме­тод объекта String:

var с = "Пример".getThirdChar();

т

21. Наследование, замещение свойств

Наследование через цепочку прототипов

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

Например, с помощью "связывания" прототипов можно определить новый тип объекта, который наследует все возможности нашего объекта Robot:

function UltraRobot(extraFeature) {

if (extraFeature)

this.feature = extraFeature;

}

UltraRobot.prototype = new Robot();

UltraRobot.prototype.feature = "Радар";

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

var guard = new UltraRobot("Выполняет вычисления");

var feature = guard.feature;

var canFly = guard.hasJetpack;

guard.doAction();

Способ проверки доступности свойств интерпретатором в этом примере анало­гичен тому, который обсуждался выше. Сначала проверяются свойства экземпляра объекта, затем, если совпадения не обнаружено, проверяется прототип (UltraRobot). Если совпадений не обнаружено и в прототипе, проверяется прототип "родителя" (Robot), и далее процесс повторяется рекурсивно вплоть до Object.

Замена свойств

Часто бывает полезно заменить поведение "родителя" новым, чтобы обеспечить нужные свойства для пользовательских объектов. Например, значением по умол­чанию toString () для объектов является " [object Object] ". Если нужно заменить такое поведение, то можно создать новый, более подходящий метод toString () для объектов определенных типов:

Robot.prototype.toString = function() { return "[object Robot]"; };

Для классов, унаследованных от Robot, метод можно тоже заменить, например, так:

UltraRobot.prototype.toString = function() {return "[object UltraRobot]"; };

Объект Date обеспечивает сложное множество методов для работы с датами и значениями времени.

JavaScript хранит даты в виде числа миллисекунд, прошедших с начала "эпохи" — 1 января 1970 г. (GMT). Это артефакт способа хранения времени в системах UNIX, что может вызвать проблемы, если вам придется работать с датами до начала "эпохи" в старых браузерах.

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

Дни недели и месяцы года перечисляются, начиная с нуля. Так что день 0 — это воскресенье, а день 6 — суббота, месяц 0 — это январь, а месяц 11 — декабрь. Однако нумерация дней месяца начинается с единицы.

1. — Создается объект с текущими датой и временем var rightNow * new Date ();

2. "месяц дд, ггггчч.ммхс" Создается объект с датой, представленной указанными месяцем, днем (дд), годом (гггг), часом (чч), минутами (мм) и секундами (сс). Все пропущенные значения считаются равными нулю var birthDay = new Date("March 24, 1970");

3. Миллисекунды Создается объект с датой, представленной указанным целого числа миллисекунд, прошедших с начала "эпохи" var someDate = new Date(795600003020);

4. rrrr, мм, дд Создается объект с датой, представленной указанными целыми значениями года (гггг), месяца (мм) и дня (дд) var birthDay = new Date(1970, 2, 24);

5. гггг, мм, дд, чч, мм, сс Создается объект с датой, представленной указанными целыми значениями года, месяца, дня, часа, минут и секунд var birthDay = new Date(1970, 2, 24, 15, 0, 0);

6. гггг, мм, дд, чч, мм, сс, мс Создается объект с датой, представленной указанными целыми значениями года, месяца, дня, часа, минут, секунд и миллисекунд var birthDay « new Date(1970, 2, 24, 15, 0, 250);

Методы для работы с датой :

1. год - getFullYear – возвращает значение года без параметров

с параметрами setFullYear – set FullYear (YearValue [,Monthvalue [,Day value]]);

2. месяц – getMonth()

setMonth(mothvalue[dayvalue]);

3. день - getDay()

setDay(dayvalue);

4. часы - getHours()

setHours (Hoursvalue[,minutesvalue[,secondvalue[,msValue]]]);

5. минуты, секунды, миллисекунды.

Преобразование даты в строку

1. toString();

2. toLocalString();

3. toGMTString();

4. toUTString();

Преобразование строк в дату – parse()

var today = new Date("18 Jan 2010");

today.setFullYear(2008, 11, 21);

today.setHours(15, 25, 0, 0);

alert(today.toLocaleString());