renovations

1-js/4-data-structures/11-datetime/1-new-date/solution.md

@@ -0,0 +1,10 @@
+Дата в местной временной зоне создается при помощи `new Date`.
+
+Месяцы начинаются с нуля, так что февраль имеет номер 1. Параметры можно указывать с точностью до минут:
+
+```js
+//+ run
+var d = new Date(2012, 1, 20, 3, 12);
+alert(d);
+```
+

1-js/4-data-structures/11-datetime/1-new-date/task.md

@@ -0,0 +1,7 @@
+# Создайте дату
+
+[importance 5]
+
+Создайте объект `Date` для даты: 20 февраля 2012 года, 3 часа 12 минут. 
+
+Временная зона -- местная. Выведите его на экран.

1-js/4-data-structures/11-datetime/2-get-week-day/_js.view/solution.js

@@ -0,0 +1,5 @@
+function getWeekDay(date) {
+  var days = ['вс','пн','вт','ср','чт','пт','сб'] ;
+
+  return days[ date.getDay() ];
+}

1-js/4-data-structures/11-datetime/2-get-week-day/_js.view/test.js

@@ -0,0 +1,29 @@
+describe("getWeekDay", function() {
+  it("3 января 2014 - пятница", function() {
+    assert.equal( getWeekDay(new Date(2014, 0, 3)), 'пт');
+  });
+
+  it("4 января 2014 - суббота", function() {
+    assert.equal( getWeekDay(new Date(2014, 0, 4)), 'сб');
+  });
+
+  it("5 января 2014 - воскресенье", function() {
+    assert.equal( getWeekDay(new Date(2014, 0, 5)), 'вс');
+  });
+
+  it("6 января 2014 - понедельник", function() {
+    assert.equal( getWeekDay(new Date(2014, 0, 6)), 'пн');
+  });
+
+  it("7 января 2014 - вторник", function() {
+    assert.equal( getWeekDay(new Date(2014, 0, 7)), 'вт');
+  });
+
+  it("8 января 2014 - среда", function() {
+    assert.equal( getWeekDay(new Date(2014, 0, 8)), 'ср');
+  });
+
+  it("9 января 2014 - четверг", function() {
+    assert.equal( getWeekDay(new Date(2014, 0, 9)), 'чт');
+  });
+});

1-js/4-data-structures/11-datetime/2-get-week-day/solution.md

@@ -0,0 +1,16 @@
+Метод `getDay()` позволяет получить номер дня недели, начиная с воскресенья. 
+
+Запишем имена дней недели в массив, чтобы можно было их достать по номеру:
+
+```js
+//+ run
+function getWeekDay(date) {
+  var days = ['вс','пн','вт','ср','чт','пт','сб'] ;
+
+  return days[ date.getDay() ];
+}
+
+var date = new Date(2014,0,3);  // 3 января 2014
+alert( getWeekDay(date) );      // 'пт'
+```
+

1-js/4-data-structures/11-datetime/2-get-week-day/task.md

@@ -0,0 +1,13 @@
+# Имя дня недели
+
+[importance 5]
+
+Создайте функцию `getWeekDay(date)`, которая выводит текущий день недели в коротком формате 'пн', 'вт',  ... 'вс'.
+
+Например:
+
+```js
+var date = new Date(2012,0,3);  // 3 января 2012 
+alert( getWeekDay(date) );      // Должно вывести 'вт'
+```
+

1-js/4-data-structures/11-datetime/3-weekday/_js.view/solution.js

@@ -0,0 +1,10 @@
+function getLocalDay(date) {
+
+  var day = date.getDay();
+
+  if ( day == 0 ) { // день 0 становится 7
+    day = 7; 
+  }
+  
+  return day;
+}

1-js/4-data-structures/11-datetime/3-weekday/_js.view/test.js

@@ -0,0 +1,29 @@
+describe("getLocalDay возвращает день недели", function() {
+  it("3 января 2014 - пятница", function() {
+    assert.equal( getLocalDay(new Date(2014, 0, 3)), 5);
+  });
+
+  it("4 января 2014 - суббота", function() {
+    assert.equal( getLocalDay(new Date(2014, 0, 4)), 6);
+  });
+
+  it("5 января 2014 - воскресенье", function() {
+    assert.equal( getLocalDay(new Date(2014, 0, 5)), 7);
+  });
+
+  it("6 января 2014 - понедельник", function() {
+    assert.equal( getLocalDay(new Date(2014, 0, 6)), 1);
+  });
+
+  it("7 января 2014 - вторник", function() {
+    assert.equal( getLocalDay(new Date(2014, 0, 7)), 2);
+  });
+
+  it("8 января 2014 - среда", function() {
+    assert.equal( getLocalDay(new Date(2014, 0, 8)), 3);
+  });
+
+  it("9 января 2014 - четверг", function() {
+    assert.equal( getLocalDay(new Date(2014, 0, 9)), 4);
+  });
+});

1-js/4-data-structures/11-datetime/3-weekday/solution.md

@@ -0,0 +1,19 @@
+Решение - в использовании встроенной функции `getDay`. Она полностью подходит нашим целям, но для воскресенья возвращает 0 вместо 7:
+
+```js
+//+ run
+function getLocalDay(date) {
+
+  var day = date.getDay();
+
+  if ( day == 0 ) { // день 0 становится 7
+    day = 7; 
+  }
+  
+  return day;
+}
+
+alert( getLocalDay(new Date(2012,0,3)) );  // 2
+```
+
+Если удобнее, чтобы день недели начинался с нуля, то можно возвращать в функции `day - 1`, тогда дни будут от 0 (пн) до 6(вс).

1-js/4-data-structures/11-datetime/3-weekday/task.md

@@ -0,0 +1,13 @@
+# День недели в европейской нумерации
+
+[importance 5]
+
+Напишите функцию, `getLocalDay(date)` которая возвращает день недели для даты `date`.
+
+День нужно возвратить в европейской нумерации, т.е. понедельник имеет номер 1, вторник номер 2, ..., воскресенье - номер 7.
+
+```js
+var date = new Date(2012, 0, 3);  // 3 янв 2012 
+alert( getLocalDay(date) );       // вторник, выведет 2
+```
+

1-js/4-data-structures/11-datetime/4-get-date-ago/_js.view/solution.js

@@ -0,0 +1,6 @@
+function getDateAgo(date, days) {
+  var dateCopy = new Date(date);
+  
+  dateCopy.setDate( date.getDate() - days );
+  return dateCopy.getDate(); 
+}

1-js/4-data-structures/11-datetime/4-get-date-ago/_js.view/test.js

@@ -0,0 +1,27 @@
+describe("getDateAgo", function() {
+
+  it("1 день до 02.01.2015 -> число 1", function() {
+    assert.equal( getDateAgo(new Date(2015, 0, 2), 1), 1 );
+  });
+
+
+  it("2 день до 02.01.2015 -> число 31", function() {
+    assert.equal( getDateAgo(new Date(2015, 0, 2), 2), 31 );
+  });
+
+  it("100 дней от 02.01.2015 -> число 24", function() {
+    assert.equal( getDateAgo(new Date(2015, 0, 2), 100), 24 );
+  });
+
+  it("365 дней от 02.01.2015 -> число 2", function() {
+    assert.equal( getDateAgo(new Date(2015, 0, 2), 365), 2 );
+  });
+
+  it("не меняет переданный объект Date", function() {
+    var date = new Date(2015, 0, 2);
+    var dateCopy = new Date(date);
+    getDateAgo(dateCopy, 100);
+    assert.equal(date.getTime(), dateCopy.getTime());
+  });
+    
+});

1-js/4-data-structures/11-datetime/4-get-date-ago/solution.md

@@ -0,0 +1,29 @@
+Из даты `date` нужно вычесть указанное количество дней.  Это просто:
+
+```js
+function getDateAgo(date, days) {
+  date.setDate( date.getDate() - days );
+  return date.getDate(); 
+}
+```
+
+Ситуацию осложняет то, что исходный объект даты не должен меняться. Это разумное требование, оно позволит избежать сюрпризов.
+
+Для того чтобы ему соответствовать, создадим копию объекта даты:
+
+```js
+//+ run
+function getDateAgo(date, days) {
+  var dateCopy = new Date(date);
+  
+  dateCopy.setDate( date.getDate() - days );
+  return dateCopy.getDate(); 
+}
+
+var date = new Date(2015, 0, 2);
+
+alert( getDateAgo(date, 1) ); // 1, (1 января 2015)
+alert( getDateAgo(date, 2) ); // 31, (31 декабря 2014)
+alert( getDateAgo(date, 365) ); // 2, (2 января 2014)
+```
+

1-js/4-data-structures/11-datetime/4-get-date-ago/task.md

@@ -0,0 +1,17 @@
+# День указанное количество дней назад
+
+[importance 4]
+
+Создайте функцию `getDateAgo(date, days)`, которая возвращает число, которое было `days` дней назад от даты `date`.
+
+Например, для 2 января 2015:
+
+```js
+var date = new Date(2015, 0, 2);
+
+alert( getDateAgo(date, 1) ); // 1, (1 января 2015)
+alert( getDateAgo(date, 2) ); // 31, (31 декабря 2014)
+alert( getDateAgo(date, 365) ); // 2, (2 января 2014)
+```
+
+P.S. Важная деталь: в процессе вычислений функция не должна менять переданный ей объект `date`. 

1-js/4-data-structures/11-datetime/5-last-day-of-month/_js.view/solution.js

@@ -0,0 +1,4 @@
+function getLastDayOfMonth(year, month) {
+  var date = new Date(year, month+1, 0);
+  return date.getDate();
+}

1-js/4-data-structures/11-datetime/5-last-day-of-month/_js.view/test.js

@@ -0,0 +1,13 @@
+describe("getLastDayOfMonth", function() {
+  it("последний день 01.01.2012 - 31", function() {
+    assert.equal( getLastDayOfMonth(2012, 0), 31);
+  });
+
+  it("последний день 01.02.2012 - 29 (високосный год)", function() {
+    assert.equal( getLastDayOfMonth(2012, 1), 29);
+  });
+
+  it("последний день 01.02.2013 - 28", function() {
+    assert.equal( getLastDayOfMonth(2013, 1), 28);
+  });
+});

1-js/4-data-structures/11-datetime/5-last-day-of-month/solution.md

@@ -0,0 +1,14 @@
+Создадим дату из следующего месяца, но день не первый, а "нулевой" (т.е. предыдущий):
+
+```js
+//+ run
+function getLastDayOfMonth(year, month) {
+  var date = new Date(year, month+1, 0);
+  return date.getDate();
+}
+
+alert( getLastDayOfMonth(2012, 0) ); // 31
+alert( getLastDayOfMonth(2012, 1) ); // 29
+alert( getLastDayOfMonth(2013, 1) ); // 28
+```
+

1-js/4-data-structures/11-datetime/5-last-day-of-month/task.md

@@ -0,0 +1,13 @@
+# Последний день месяца?
+
+[importance 5]
+
+Напишите функцию `getLastDayOfMonth(year, month)`, которая возвращает последний день месяца.
+
+Параметры:
+<ul>
+<li>`year` -- 4-значный год, например 2012.</li>
+<li>`month` -- месяц от 0 до 11.</li>
+</ul>
+
+Например, `getLastDayOfMonth(2012, 1) = 29` (високосный год, февраль).

1-js/4-data-structures/11-datetime/6-get-seconds-today/solution.md

@@ -0,0 +1,19 @@
+Для вывода достаточно сгенерировать объект `Date`, соответствующий началу дня, т.е. "сегодня" 00 часов 00 минут 00 секунд, и вычесть его из текущей даты.
+
+Полученная разница -- это как раз количество миллисекунд от начала дня, которое достаточно поделить на `1000`, чтобы получить секунды:
+
+```js
+//+ run
+function getSecondsToday() {
+  var now = new Date();
+
+  // создать объект из текущей даты, без часов-минут-секунд
+  var today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+
+  var diff = now - today; // разница в миллисекундах
+  return Math.round(diff / 1000); // перевести в секунды
+}
+
+alert( getSecondsToday() );
+```
+

1-js/4-data-structures/11-datetime/6-get-seconds-today/task.md

@@ -0,0 +1,13 @@
+# Сколько секунд уже прошло сегодня?
+
+[importance 5]
+
+Напишите функцию `getSecondsToday()` которая возвращает, сколько секунд прошло с начала сегодняшнего дня.
+
+Например, если сейчас `10:00` и не было перехода на зимнее/летнее время, то:
+
+```js
+getSecondsToday() == 36000 // (3600 * 10)
+```
+
+Функция должна работать в любой день, т.е. в ней не должно быть конкретного значения сегодняшней даты.

1-js/4-data-structures/11-datetime/7-get-seconds-to-tomorrow/solution.md

@@ -0,0 +1,17 @@
+Для получения оставшихся до конца дня миллисекунд нужно из "завтра 00ч 00мин 00сек" вычесть текущее время. 
+
+Чтобы сгенерировать "завтра" -- увеличим текущую дату на 1 день:
+
+```js
+//+ run
+function getSecondsToTomorrow() {
+  var now = new Date();
+
+  // создать объект из завтрашней даты, без часов-минут-секунд
+  var tomorrow = new Date(now.getFullYear(), now.getMonth(), *!*now.getDate()+1*/!*);
+
+  var diff = tomorrow - now; // разница в миллисекундах
+  return Math.round(diff / 1000); // перевести в секунды
+}
+```
+

1-js/4-data-structures/11-datetime/7-get-seconds-to-tomorrow/task.md

@@ -0,0 +1,13 @@
+# Сколько секунд - до завтра?
+
+[importance 5]
+
+Напишите функцию `getSecondsToTomorrow()` которая возвращает, сколько секунд осталось до завтра.
+
+Например, если сейчас `23:00`, то:
+
+```js
+getSecondsToTomorrow() == 3600
+```
+
+P.S. Функция должна работать в любой день, т.е. в ней не должно быть конкретного значения сегодняшней даты.

1-js/4-data-structures/11-datetime/8-format-date-ddmmyy/_js.view/solution.js

@@ -0,0 +1,13 @@
+function formatDate(date) {
+
+  var dd = date.getDate();
+  if ( dd < 10 ) dd = '0' + dd;
+
+  var mm = date.getMonth()+1;
+  if ( mm < 10 ) mm = '0' + mm;
+
+  var yy = date.getFullYear() % 100;
+  if ( yy < 10 ) yy = '0' + yy;
+
+  return dd+'.'+mm+'.'+yy;
+}

1-js/4-data-structures/11-datetime/8-format-date-ddmmyy/_js.view/test.js

@@ -0,0 +1,13 @@
+describe("formatDate", function() {
+  it("правильно форматирует дату 30.01.14", function() {
+    assert.equal( formatDate(new Date(2014, 0, 30)), '30.01.14');
+  });
+
+  it("правильно форматирует дату 01.01.01", function() {
+    assert.equal( formatDate(new Date(2001, 0, 1)), '01.01.01');
+  });
+
+  it("правильно форматирует дату 01.01.00", function() {
+    assert.equal( formatDate(new Date(2000, 0, 1)), '01.01.00');
+  });
+});

1-js/4-data-structures/11-datetime/8-format-date-ddmmyy/solution.md

@@ -0,0 +1,51 @@
+Получим компоненты один за другим.
+<ol>
+<li>День можно получить как `date.getDate()`. При необходимости добавим ведущий ноль:
+
+```js
+var dd = date.getDate();
+if (dd<10) dd= '0'+dd;
+```
+
+</li>
+<li>`date.getMonth()` возвратит месяц, начиная с нуля. Увеличим его на 1:
+
+```js
+var mm = date.getMonth() + 1;  // месяц 1-12
+if (mm<10) mm= '0'+mm;
+```
+
+</li>
+<li>`date.getFullYear()` вернет год в 4-значном формате. Чтобы сделать его двузначным - воспользуемся оператором взятия остатка `'%'`:
+
+```js
+var yy = date.getFullYear() % 100;
+if (yy<10) yy= '0'+yy;
+```
+
+Заметим, что год, как и другие компоненты, может понадобиться дополнить нулем слева, причем возможно что `yy == 0` (например, 2000 год). При сложении со строкой `0+'0' == '00'`, так что будет все в порядке.
+</li>
+</ol>
+
+Полный код:
+
+```js
+//+ run
+function formatDate(date) {
+
+  var dd = date.getDate();
+  if ( dd < 10 ) dd = '0' + dd;
+
+  var mm = date.getMonth()+1;
+  if ( mm < 10 ) mm = '0' + mm;
+
+  var yy = date.getFullYear() % 100;
+  if ( yy < 10 ) yy = '0' + yy;
+
+  return dd+'.'+mm+'.'+yy;
+}
+
+var d = new Date(2014, 0, 30);  // 30 Янв 2014
+alert( formatDate(d) );  // '30.01.14'
+```
+

1-js/4-data-structures/11-datetime/8-format-date-ddmmyy/task.md

@@ -0,0 +1,14 @@
+# Вывести дату в формате дд.мм.гг
+
+[importance 3]
+
+Напишите функцию `formatDate(date)`, которая выводит дату `date` в формате `дд.мм.гг`:
+
+Например:
+
+```js
+var d = new Date(2014, 0, 30); // 30 января 2014
+alert( formatDate(d) ); // '30.01.14'
+```
+
+P.S. Обратите внимание, ведущие нули должны присутствовать, то есть 1 января 2001 должно быть 01.01.01, а не 1.1.1.

1-js/4-data-structures/11-datetime/9-format-date-relative/_js.view/solution.js

@@ -0,0 +1,34 @@
+function formatDate(date) {
+  var diff = new Date() - date; // разница в миллисекундах
+  
+  if (diff < 1000) { // прошло менее 1 секунды
+    return 'только что';
+  }
+
+  var sec = Math.floor( diff / 1000 ); // округлить diff до секунд
+	
+  if (sec < 60) {
+    return sec + ' сек. назад';
+  }
+	
+  var min = Math.floor( diff / 60000 ); // округлить diff до минут
+  if (min < 60) {
+    return min + ' мин. назад';		
+  }
+
+  // форматировать дату, с учетом того, что месяцы начинаются с 0
+  var d = date;
+  d = [
+    '0'+d.getDate(),
+    '0'+(d.getMonth()+1),
+    ''+d.getFullYear(),
+     '0'+d.getHours(),
+    '0'+d.getMinutes()
+  ];
+
+  for(var i=0; i<d.length; i++) {
+    d[i] = d[i].slice(-2); 
+  }
+
+  return d.slice(0,3).join('.')+' '+d.slice(3).join(':');
+}

1-js/4-data-structures/11-datetime/9-format-date-relative/_js.view/test.js

@@ -0,0 +1,18 @@
+describe("formatDate", function() {
+  it("выводит дату 1мс назад как \"только что\"", function() {
+    assert.equal( formatDate( new Date(new Date - 1) ), 'только что' );
+  });
+
+  it('выводит дату "30 сек назад"', function() {
+    assert.equal( formatDate( new Date( new Date - 30*1000) ), "30 сек. назад" );
+  });
+
+  it('выводит дату "5 мин назад"', function() {
+    assert.equal( formatDate( new Date( new Date- 5*60*1000) ), "5 мин. назад");
+  });
+
+  it("выводит старую дату в формате дд.мм.гг чч:мм", function() {
+    assert.equal( formatDate( new Date(2014, 2, 1, 11, 22, 33) ), "01.03.14 11:22" ); 
+  });
+
+});

1-js/4-data-structures/11-datetime/9-format-date-relative/solution.md

@@ -0,0 +1,48 @@
+Для того, чтобы узнать время от `date` до текущего момента - используем вычитание дат.
+
+```js
+//+ run
+function formatDate(date) {
+  var diff = new Date() - date; // разница в миллисекундах
+  
+  if (diff < 1000) { // прошло менее 1 секунды
+    return 'только что';
+  }
+
+  var sec = Math.floor( diff / 1000 ); // округлить diff до секунд
+	
+  if (sec < 60) {
+    return sec + ' сек. назад';
+  }
+	
+  var min = Math.floor( diff / 60000 ); // округлить diff до минут
+  if (min < 60) {
+    return min + ' мин. назад';		
+  }
+
+  // форматировать дату, с учетом того, что месяцы начинаются с 0
+  var d = date;
+  d = [
+    '0'+d.getDate(),
+    '0'+(d.getMonth()+1),
+    ''+d.getFullYear(),
+     '0'+d.getHours(),
+    '0'+d.getMinutes()
+  ];
+
+  for(var i=0; i<d.length; i++) {
+    d[i] = d[i].slice(-2); 
+  }
+
+  return d.slice(0,3).join('.')+' '+d.slice(3).join(':');
+}
+
+alert( formatDate( new Date( new Date - 1) ) ); // только что 
+
+alert( formatDate( new Date( new Date - 30*1000) ) ); // 30 сек. назад
+
+alert( formatDate( new Date( new Date- 5*60*1000) ) ); // 5 мин. назад
+
+alert( formatDate( new Date( new Date - 86400*1000) ) ); // вчерашняя дата в формате "дд.мм.гг чч:мм"
+```
+

1-js/4-data-structures/11-datetime/9-format-date-relative/task.md

@@ -0,0 +1,26 @@
+# Относительное форматирование даты
+
+[importance 4]
+
+Напишите функцию `formatDate(date)`, которая форматирует дату `date` так:
+<ul>
+<li>Если со времени `date` прошло менее секунды, то возвращает `"только что"`.</li>
+<li>Иначе если со времени `date` прошло менее минуты, то `"n сек. назад"`.</li>
+<li>Иначе если прошло меньше часа, то `"m мин. назад"`.</li>
+<li>Иначе полная дата в формате `"дд.мм.гг чч:мм"`.</li>
+</ul>
+
+Например:
+
+```js
+function formatDate(date) { /* ваш код */ }
+
+alert( formatDate( new Date(new Date - 1) ) ); // "только что"
+
+alert( formatDate( new Date(new Date - 30*1000) ) ); // "30 сек. назад"
+
+alert( formatDate( new Date(new Date- 5*60*1000) ) ); // "5 мин. назад"
+
+alert( formatDate( new Date(new Date - 86400*1000) ) ); // вчерашняя дата в формате "дд.мм.гг чч:мм"
+```
+

1-js/4-data-structures/11-datetime/article.md

@@ -0,0 +1,492 @@
+# Дата и Время
+
+Для работы с датой и временем в JavaScript используются объекты [Date](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date/).
+
+[cut]
+## Создание
+
+Для создания нового объекта типа `Date` используется один из синтаксисов:
+<dl>
+<dt>`new Date()`</dt>
+<dd>Создает объект `Date` с текущей датой и временем:
+
+```js
+//+ run
+var now = new Date();
+alert(now);
+```
+
+</dd>
+<dt>`new Date(milliseconds)`</dt>
+<dd>Создает объект `Date`, значение которого равно количеству миллисекунд (1/1000 секунды), прошедших с 1 января 1970 года GMT+0.
+
+```js
+//+ run
+// 24 часа после 01.01.1970 GMT+0
+var Jan02_1970 = new Date(3600*24*1000);
+alert( Jan02_1970 );
+```
+
+</dd>
+<dt>`new Date(datestring)`</dt>
+<dd>Если единственный аргумент - строка, используется вызов `Date.parse` для ее разбора.</dd>
+<dt>`new Date(year, month, date, hours, minutes, seconds, ms)`</dt>
+<dd>Дату можно создать, используя компоненты в местной временной зоне. Для этого формата обязательны только первые два аргумента. Отсутствующие параметры, начиная с `hours` считаются равными нулю, а `date` -- единице.
+
+**Заметим, что год `year` должен быть из 4 цифр, а отсчет месяцев `month` начинается с нуля 0.** Например:
+
+```js
+new Date(2011, 0, 1) // 1 января 2011, 00:00:00 в местной временной зоне
+new Date(2011, 0) // то же самое, date по умолчанию равно 1
+new Date(2011, 0, 1, 0, 0, 0, 0); // то же самое
+```
+
+Дата задана с точностью до миллисекунд:
+
+```js
+//+ run
+var d = new Date(2011, 0, 1, 2, 3, 4, 567); 
+alert(d); // 1.01.2011, 02:03:04.567
+```
+
+</dd>
+</dl>
+
+
+## Получение компонентов даты 
+
+Для доступа к компонентам даты-времени объекта `Date` используются следующие методы:
+<dl>
+<dt>`getFullYear()`</dt>
+<dd>Получить год(из 4 цифр)</dd>
+<dt>`getMonth()`</dt>
+<dd>Получить месяц, **от 0 до 11**.</dd>
+<dt>`getDate()`</dt>
+<dd>Получить число месяца, от 1 до 31.</dd>
+<dt>`getHours(), getMinutes(), getSeconds(), getMilliseconds()`</dt>
+<dd>Получить соответствующие компоненты.</dd>
+</dl>
+
+[warn header="Устаревший `getYear()`"]
+Некоторые браузеры реализуют нестандартный метод `getYear()`. Где-то он возвращает только две цифры из года, где-то четыре. Так или иначе, этот метод отсутствует в стандарте JavaScript. Не используйте его. Для получения года есть `getFullYear()`.
+[/warn]
+
+Дополнительно можно получить день недели:
+<dl>
+<dt>`getDay()`</dt>
+<dd>Получить номер дня в неделе. Неделя в JavaScript начинается с воскресенья, так что результат будет числом **от 0(воскресенье) до 6(суббота)**.</dd>
+</dl>
+
+**Все методы, указанные выше, возвращают результат для местной временной зоны.**
+
+Существуют также UTC-варианты этих методов, возвращающие день, месяц, год и т.п. для зоны GMT+0 (UTC): `getUTCFullYear()`, `getUTCMonth()`, `getUTCDay()`. То есть, сразу после `"get"` вставляется `"UTC"`.
+
+Если ваше локальное время сдвинуто относительно UTC, то следующий код покажет разные часы:
+
+```js
+//+ run
+var date = new Date();
+
+alert( date.getHours() ); // час в вашей зоне для даты date
+alert( date.getUTCHours() ); // час в зоне GMT+0 для даты date
+```
+
+Кроме описанных выше, существуют два специальных метода без UTC-варианта:
+
+<dl>
+<dt>`getTime()`</dt>
+<dd>Возвращает число миллисекунд, прошедших с 01.01.1970 00:00:00 UTC. Это то же число, которое используется в конструкторе `new Date(milliseconds)`.</dd>
+<dt>`getTimezoneOffset()`</dt>
+<dd>Возвращает разницу между местным и UTC-временем, в минутах.
+
+```js
+//+ run
+alert( new Date().getTimezoneOffset() );  // Для GMT-1 выведет 60
+```
+
+</dd>
+</dl>
+
+
+
+## Установка компонентов даты   
+
+Следующие методы позволяют устанавливать компоненты даты и времени:
+<ul>
+<li>`setFullYear(year [, month, date])`</li>
+<li>`setMonth(month [, date])`</li>
+<li>`setDate(date)`</li>
+<li>`setHours(hour [, min, sec, ms])`</li>
+<li>`setMinutes(min [, sec, ms])`</li>
+<li>`setSeconds(sec [, ms])`</li>
+<li>`setMilliseconds(ms)`</li>
+<li>`setTime(milliseconds)` (устанавливает всю дату по миллисекундам с 01.01.1970 UTC)</li>
+</ul>
+
+Все они, кроме `setTime()`, обладают также UTC-вариантом, например: `setUTCHours()`.
+
+Как видно, некоторые методы могут устанавливать несколько компонентов даты одновременно, в частности, `setHours`. При этом если какая-то компонента не указана, она не меняется. Например:
+
+```js
+//+ run
+var today = new Date;
+
+today.setHours(0); 
+alert( today ); // сегодня, но час изменён на 0
+
+today.setHours(0, 0, 0, 0); 
+alert (today ); // сегодня, ровно 00:00:00.
+```
+
+### Автоисправление даты   
+
+*Автоисправление* -- очень удобное свойство объектов `Date`. Оно заключается в том, что можно устанавливать заведомо некорректные компоненты (например 32 января), а объект сам себя поправит.
+
+```js
+//+ run
+var d = new Date(2013, 0, *!*32*/!*); // 32 января 2013 ?!?
+alert(d); // ... это 1 февраля 2013!
+```
+
+**Неправильные компоненты даты автоматически распределяются по остальным.** 
+
+Например, нужно увеличить на 2 дня дату "28 февраля 2011". Может быть так, что это будет 2 марта, а может быть и 1 марта, если год високосный. Но нам обо всем этом думать не нужно. Просто прибавляем два дня. Остальное сделает `Date`:
+
+```js
+//+ run
+var d = new Date(2011, 1, 28);
+*!*
+d.setDate( d.getDate() + 2 );
+*/!*
+
+alert(d); // 2 марта, 2011
+```
+
+Также это используют для получения даты, отдаленной от имеющейся на нужный промежуток времени. Например, получим дату на 70 секунд большую текущей:
+
+```js
+//+ run
+var d = new Date();
+d.setSeconds( d.getSeconds()+70);
+
+alert(d); // выведет корректную дату
+```
+
+Можно установить и нулевые, и даже отрицательные компоненты. Например:
+
+```js
+//+ run
+var d = new Date;
+
+d.setDate(1); // поставить первое число месяца
+alert(d);
+
+d.setDate(0); // нулевого числа нет, будет последнее число предыдущего месяца
+alert(d);
+```
+
+
+
+```js
+//+ run
+var d = new Date;
+
+d.setDate(-1); // предпоследнее число предыдущего месяца
+alert(d);
+```
+
+### Преобразование к числу, разность дат   
+
+Когда объект `Date` используется в числовом контексте, он преобразуется в количество миллисекунд:
+
+```js
+//+ run
+alert( +new Date ) // +date то же самое, что: +date.valueOf()
+```
+
+**Важный побочный эффект: даты можно вычитать, результат вычитания объектов `Date` -- их временная разница, в миллисекундах**.
+
+Это используют для измерения времени:
+
+```js
+//+ run
+var start = new Date; // засекли время
+
+// что-то сделать
+for (var i=0; i<100000; i++) {
+  var doSomething = i*i*i; 
+}
+
+var end = new Date; // конец измерения
+
+alert("Цикл занял " + (end-start) + " ms");
+```
+
+### Бенчмаркинг
+
+Допустим, у нас есть несколько вариантов решения задачи, каждый описан функцией. 
+
+Как узнать, какой быстрее?
+
+Для примера возьмем две функции, которые бегают по массиву:
+
+```js
+function walkIn(arr) {
+  for(var key in arr) arr[i]++
+}
+
+function walkLength(arr) {
+  for(var i=0; i<arr.length; i++) arr[i]++;
+}
+```
+
+Чтобы померять, какая из них быстрее, нельзя запустить один раз `walkIn`, один раз `walkLength` и замерить разницу. Одноразовый запуск ненадежен, любая мини-помеха исказит результат.
+
+Для правильного бенчмаркинга функция запускается много раз, чтобы сам тест занял существенное время. Это сведет влияние помех к минимуму. Сложную функцию можно запускать 100 раз, простую -- 1000 раз... 
+
+Померяем, какая из функций округления быстрее:
+
+```js
+//+ run
+var arr = [];
+for(var i=0; i<1000; i++) arr[i] = 0;
+
+function walkIn(arr) {  for(var key in arr) arr[i]++; }
+function walkLength(arr) { for(var i=0; i<arr.length; i++) arr[i]++; }
+
+function bench(f) {
+  var date = new Date();
+  for (var i=0; i<10000; i++) f(arr);
+  return new Date() - date;
+}
+
+alert('Время walkIn: ' + bench(walkIn) + 'мс');
+alert('Время walkLength: ' + bench(walkLength) + 'мс');
+```
+
+Теперь представим себе, что во время первого бенчмаркинга `bench(walkIn)` компьютер что-то делал параллельно важное (вдруг) и это занимало ресурсы, а во время второго -- перестал. Реальная ситуация? Конечно реальна, особенно на современных ОС, где много процессов одновременно.
+
+**Гораздо более надёжные результаты можно получить, весь пакет тестов прогнать много раз.**
+
+```js
+//+ run
+var arr = [];
+for(var i=0; i<1000; i++) arr[i] = 0;
+
+function walkIn(arr) {  for(var key in arr) arr[i]++; }
+function walkLength(arr) { for(var i=0; i<arr.length; i++) arr[i]++; }
+
+function bench(f) {
+  var date = new Date();
+  for (var i=0; i<1000; i++) f(arr);
+  return new Date() - date;
+}
+
+*!*
+// bench для каждого теста запустим много раз, чередуя
+var timeIn = 0, timeLength = 0;
+for(var i=0; i<100; i++) {
+  timeIn += bench(walkIn);
+  timeLength += bench(walkLength);
+}
+*/!*
+
+alert('Время walkIn: ' + timeIn + 'мс');
+alert('Время walkLength: ' +timeLength + 'мс');
+```
+
+[smart header="Более точное время с `performance.now()`"]
+В современных браузерах (кроме IE9-) вызов [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/performance.now) возвращает количество миллисекунд, прошедшее с начала загрузки страницы, а если точнее -- с момента выгрузки предыдущей страницы из памяти. 
+
+Его можно посмотреть в любом месте страницы, даже в `<head>`, чтобы узнать, сколько времени потребовалось браузеру, чтобы до него добраться, включая загрузку HTML. 
+
+Возвращаемое значение измеряется в миллисекундах, но дополнительно имеет точность 3 знака после запятой (до миллионных долей секунды!), поэтому можно использовать его и для более точного бенчмаркинга в том числе.
+[/smart]
+
+[smart header="`console.time(метка)` и `console.timeEnd(метка)`"]
+Для измерения с одновременным выводом результатов в консоли есть методы:
+<ul>
+<li>`console.time(метка)` -- включить внутренний хронометр браузера с меткой.</li>
+<li>`console.timeEnd(метка)` -- выключить внутренний хронометр браузера с меткой и вывести результат.</li>
+</ul>
+Параметр `"метка"` используется для идентификации таймера, чтобы можно было делать много замеров одновременно и даже вкладывать измерения друг в друга. 
+
+В коде ниже таймеры `walkIn`, `walkLength` -- конкретные тесты, а таймер "All Benchmarks" -- время "на всё про всё":
+
+```js
+//+ run
+var arr = [];
+for(var i=0; i<1000; i++) arr[i] = 0;
+
+function walkIn(arr) {  for(var key in arr) arr[i]++; }
+function walkLength(arr) { for(var i=0; i<arr.length; i++) arr[i]++; }
+
+function bench(f) {
+  for (var i=0; i<10000; i++) f(arr);
+}
+
+console.time("All Benchmarks");
+
+console.time("walkIn");
+bench(walkIn);
+console.timeEnd("walkIn");
+
+
+console.time("walkLength");
+bench(walkLength);
+console.timeEnd("walkLength");
+
+console.timeEnd("All Benchmarks");
+```
+
+**При запуске этого примера нужно открыть консоль, иначе вы ничего не увидите.**
+[/smart]
+
+[warn header="Внимание, оптимизатор!"]
+Современные интерпретаторы JavaScript делают массу оптимизаций, например:
+<ol>
+<li>Автоматически выносят инвариант, то есть постоянное в цикле значение типа `arr.length`, за пределы цикла.</li>
+<li>Стараются понять, значения какого типа хранит данная переменная или массив, какую структуру имеет объект и, исходя из этого, оптимизировать внутренние алгоритмы.</li>
+<li>Выполняют простейшие операции, например сложение явно заданных чисел и строк, на этапе компиляции.</li>
+<li>В теории, могут выкинуть код, который ни на что не влияет, например присваивание к неиспользуемой локальной переменной, хотя делают это редко.</li>
+</ol>
+Они могут влиять на результаты тестов. 
+[/warn]
+
+
+## Форматирование
+
+Во всех браузерах, кроме IE10-, поддерживается новый стандарт [Ecma 402](http://www.ecma-international.org/publications/standards/Ecma-402.htm), который добавляет специальные методы для форматирования дат.
+
+Это делается взыовом `date.toLocaleString(локаль, опции)`, у которого много настроек. Он позволяет указать, какие параметры даты нужно вывести, и ряд настроек вывода, после чего интерпретатор сам сформирует строку.
+
+Пример с почти всеми параметрами даты и русским, затем английским (США) форматированием:
+
+```js
+//+ run
+var date = new Date(2014, 11, 31, 12, 30, 0);
+
+var options = {
+  era: 'long',
+  year: 'numeric',
+  month: 'long',
+  day: 'numeric',
+  weekday: 'long',
+  timezone: 'UTC',
+  hour: 'numeric',
+  minute: 'numeric',
+  second: 'numeric'
+};
+
+alert( date.toLocaleString("ru", options) ); // среда, 31 декабря 2014 г. н.э. 12:30:00
+alert( date.toLocaleString("en-US", options) ); // Wednesday, December 31, 2014 Anno Domini 12:30:00 PM
+```
+
+Вы сможете подробно узнать о них в статье [](/intl), которая посвящена этому стандарту. 
+
+
+**Методы вывода без локализации:**
+
+<dl>
+<dt>`toString()`, `toDateString()`, `toTimeString()`</dt>
+<dd>Возвращают стандартное строчное представление, не указанное в стандарте, а зависящее от браузера. Единственное требование - читаемость человеком. Метод `toString` возвращает дату целиком, `toDateString()` и `toTimeString()` - только дату и время соответственно.
+
+```js
+//+ run
+var d = new Date();
+
+alert( d.toString() ); // вывод, похожий на 'Wed Jan 26 2011 16:40:50 GMT+0300'
+```
+
+<dt>`toUTCString()`</dt>
+<dd>То же самое, что `toString()`, но дата в зоне UTC.</dd>
+</dl>
+<dt>`toISOString()`</dt>
+<dd>Возвращает дату в формате ISO Детали формата будут далее. Поддерживается современными браузерами, не поддерживается IE&lt;9.
+
+```js
+//+ run
+var d = new Date();
+
+alert( d.toISOString() ); // вывод, похожий на '2011-01-26T13:51:50.417Z'
+```
+
+</dd></dl>
+
+**Если хочется иметь большую гибкость и кросс-браузерность, то также можно воспользоваться специальной библиотекой, например [Moment.JS](http://momentjs.com/) или написать свою функцию.**
+
+
+
+## Разбор строки, Date.parse   
+
+Все современные браузеры, включая IE9+, понимают даты в упрощённом формате ISO 8601 Extended.
+
+Этот формат выглядит так: `YYYY-MM-DDTHH:mm:ss.sssZ`. Для разделения даты и времени в нем используется символ `'T'`. Часть `'Z'` обозначает (необязательную) временную зону -- она может отсутствовать, тогда зона UTC, либо может быть символ `z` -- тоже  UTC, или зона в формате `+-hh:mm`.
+
+Также возможны упрощенные варианты, к примеру:
+
+```js
+YYYY 
+YYYY-MM 
+YYYY-MM-DD
+```
+
+Метод `Date.parse(str)` разбирает строку `str` в таком формате и возвращает соответствующее ей количество миллисекунд. Если это невозможно, `Date.parse` возвращает `NaN`.
+
+На момент написания некоторые браузеры (Safari) воспринимали формат без `'Z'` как дату в локальной таймзоне (по стандарту UTC), поэтому пример ниже в них работает некорректно:
+
+```js
+//+ run
+var msNoZone = Date.parse('2012-01-26T13:51:50.417'); // без зоны, значит UTC
+
+alert(msNoZone); // 1327571510417 (число миллисекунд)
+
+var msZ = Date.parse('2012-01-26T13:51:50.417z'); // зона z означает UTC
+alert(msZ == msNoZone); // true, если браузер правильный
+```
+
+С таймзоной `-07:00 GMT` в конце все современные браузеры работают правильно:
+
+```js
+//+ run
+var ms = Date.parse('2012-01-26T13:51:50.417-07:00');
+
+alert(ms); // 1327611110417 (число миллисекунд)
+```
+
+[smart header="Формат дат для IE8-"]
+До появления спецификации EcmaScript 5 формат не был стандартизован, и браузеры, включая IE8-, имели свои собственные форматы дат. Частично, эти форматы пересекаются.
+
+Например, код ниже работает везде, включая старые IE:
+
+```js
+//+ run
+var ms = Date.parse("January 26, 2011 13:51:50");
+
+alert(ms);
+```
+
+Вы также можете почитать о старых форматах IE в документации к методу  <a href="http://msdn.microsoft.com/en-us/library/k4w173wk%28v=vs.85%29.aspx">MSDN Date.parse</a>. 
+
+Конечно же, сейчас лучше использовать современный формат. Если же нужна поддержка IE8-, то метод `Date.parse`, как и ряд других современных методов, добавляется библиотекой [es5-shim](https://github.com/kriskowal/es5-shim).
+[/smart]
+
+## Метод Date.now()
+
+Метод `Date.now()` возвращает дату сразу в виде миллисекунд.
+
+Технически, он аналогичен вызову `+new Date()`, но в отличие от него не создаёт промежуточный объект даты, а поэтому -- во много раз быстрее. 
+
+Его использование особенно рекомендуется там, где производительность при работе с датами критична. Обычно это не на веб-страницах, а, к примеру, в разработке игр на JavaScript.
+
+## Итого
+
+<ul>
+<li>Дата и время представлены в JavaScript одним объектом: [Date](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date/). Создать "только время" при этом нельзя, оно должно быть с датой. Список методов `Date` вы можете найти в справочнике [Date](http://javascript.ru/Date) или выше.</li>
+<li>Отсчёт месяцев начинается с нуля.</li>
+<li>Отсчёт дней недели (для `getDay()`) тоже начинается с нуля (и это воскресенье).</li>
+<li>Объект `Date` удобен тем, что автокорректируется. Благодаря этому легко сдвигать даты.</li>
+<li>При преобразовании к числу объект `Date` даёт количество миллисекунд, прошедших с 1 января 1970 UTC. Побочное следствие -- даты можно вычитать, результатом будет разница в миллисекундах.</li>
+<li>Для получения текущей даты в миллисекундах лучше использовать `Date.now()`, чтобы не создавать лишний объект `Date` (кроме IE8-)</li>
+<li>Для бенчмаркинга лучше использовать `performance.now()` (кроме IE9-), он в 1000 раз точнее.</li>
+</ul>