attempt to return to highlights

Author: karmazzin

chapters/chapter0.md

@@ -78,7 +78,7 @@
 
 Вот та же программа на JavaScript:
 
-```
+```js
 var total = 0, count = 1;
 while (count <= 10) {
   total += count;
@@ -94,7 +94,7 @@ console.log(total);
 
 И наконец, вот так могла бы выглядеть программа, если б у нас были удобные операции range и sum, которые, соответственно, создавали бы набор номеров в заданном промежутке и подсчитывали сумму набора:
 
-```
+```js
 console.log(sum(range(1, 10)));
 // → 55
 ```

chapters/chapter1.md

@@ -10,7 +10,7 @@
 
 К примеру, номер 13. Вместо десятичной системы, состоящей из 10 цифр, у вас есть двоичная система с двумя цифрами. Значение каждой позиции числа удваивается при движении справа налево. Биты, составляющие число 13, вместе с их весами:
 
-```
+```js
 0   0   0   0 1 1 0 1
 128 64 32  16 8 4 2 1
 ```
@@ -31,7 +31,7 @@
 ##Числа
 Величины числовых типов, это – сюрприз – числа. В программе JavaScript они записываются как
 
-```
+```js
 13
 ```
 
@@ -45,13 +45,13 @@ JavaScript использует фиксированное число бит (64
 
 Дроби записываются с помощью точки.
 
-```
+```js
 9.81
 ```
 
 Очень большие или маленькие числа записываются научной записью с буквой “e” (exponent), за которой следует степень:
 
-```
+```js
 2.998e8
 ```
 
@@ -62,23 +62,23 @@ JavaScript использует фиксированное число бит (64
 ##Арифметика
 Главное, что можно делать с числами – это арифметические вычисления. Сложения и умножения используют два числа и выдают третье. Как это записывается в JavaScript:
 
-```
+```js
 100 + 4 * 11
 ```
 
 Символы + и * называются операторами. Первый – сложение, второй – умножение. Помещаем оператор между двумя величинами и получаем значение выражения.
 
 А в примере получается «сложить 4 и 100 и затем умножить результат на 11», или умножение выполняется сначала? Как вы могли догадаться, умножение выполняется первым. Но как и в математике, это можно изменить при помощи скобок:
 
-```
+```js
 (100 + 4) * 11
 ```
 
 Для вычитания используется оператор -, а для деления - /
 
 Когда операторы используются без скобок, порядок их выполнения определяется их приоритетом. У операторов * и / приоритет одинаковый, выше, чем у + и -, которые между собой равны по приоритету. При вычислении операторов с равным приоритетом они вычисляются слева направо:
 
-```
+```js
 1 - 2 + 1
 ```
 
@@ -98,7 +98,7 @@ JavaScript использует фиксированное число бит (64
 ##Строки
 Следующий базовый тип данных – строки. Они используются для хранения текста. Записываются они в кавычках:
 
-```
+```js
 "Что посеешь, то из пруда"
 'Баба с возу, потехе час'
 ```
@@ -109,20 +109,20 @@ JavaScript использует фиксированное число бит (64
 
 Строка “Между первой и второй\nсимвол будет небольшой” на самом деле будет выглядеть так:
 
-```
+```js
 Между первой и второй
 символ будет небольшой
 ```
 
 Если вам нужно включить в строку обратный слеш, его тоже нужно экранировать: \\\\. Инструкцию “Символ новой строки — это “\n”” нужно будет написать так:
 
-```
+```js
 "Символ новой строки – это \"\\n\""
 ```
 
 Строки нельзя делить, умножать и складывать. Однако с ними можно использовать оператор +, который будет соединять их друг с другом. Следующее выражение выдаст слово «соединение»:
 
-```
+```js
 "сое" + "ди" + "н" + "ение"
 ```
 
@@ -131,7 +131,7 @@ JavaScript использует фиксированное число бит (64
 ##Унарные операторы
 Не все операторы записываются символами – некоторые словами. Один из таких операторов – `typeof`, который выдаёт название типа величины, к которой он применяется.
 
-```
+```js
 console.log(typeof 4.5)
 // → number
 
@@ -143,7 +143,7 @@ console.log(typeof "x")
 
 Предыдущие операторы работали с двумя величинами, однако typeof использует только одну. Операторы, работающие с двумя величинами, называются бинарными, а с одной – унарными. Минус (вычитание) можно использовать и как унарный, и как бинарный.
 
-```
+```js
 console.log(- (10 - 2))
 // → -8
 ```
@@ -154,7 +154,7 @@ console.log(- (10 - 2))
 ##Сравнения
 Один из способов получить булевские величины:
 
-```
+```js
 console.log(3 > 2)
 // → true
 console.log(3 < 2)
@@ -165,7 +165,7 @@ console.log(3 < 2)
 
 Строки можно сравнивать так же:
 
-```
+```js
 console.log("Арбуз" <  "Яблоко")
 // → true
 ```
@@ -174,14 +174,14 @@ console.log("Арбуз" <  "Яблоко")
 
 Другие сходные операторы – это >= (больше или равно), <= (меньше или равно), == (равно), != (не равно).
 
-```
+```js
 console.log("Хочется" != "Колется")
 // → true
 ```
 
 В JavaScript есть только одна величина, которая не равна самой себе – `NaN` («не число»).
 
-```
+```js
 console.log(NaN == NaN)
 // → false
 ```
@@ -192,7 +192,7 @@ NaN – это результат любого бессмысленного вы
 
 Оператор &amp;&amp; — логическое «и». Он бинарный, и его результат – правда, только если обе величины, к которым он применяется, тоже правда.
 
-```
+```js
 console.log(true && false)
 // → false
 console.log(true && true)
@@ -201,7 +201,7 @@ console.log(true && true)
 
 Оператор || — логическое «или». Выдаёт true, если одна из величин true.
 
-```
+```js
 console.log(false || true)
 // → true
 console.log(false || false)
@@ -212,13 +212,13 @@ console.log(false || false)
 
 При использовании логических и арифметических операторов не всегда ясно, когда нужны скобки. На практике вы можете справиться с этим, зная, что у || приоритет ниже всех, потом идёт &amp;&amp;, потом операторы сравнения, потом все остальные. Такой порядок был выбран для того, чтобы в выражениях типа следующего можно было использовать минимальное количество скобок:
 
-```
+```js
 1 + 1 == 2 && 10 * 10 > 50
 ```
 
 Последний логический оператор не унарный и не бинарный – он тройной. Записывается при помощи вопросительного знака и двоеточия:
 
-```
+```js
 console.log(true ? 1 : 2);
 // → 1
 console.log(false ? 1 : 2);
@@ -235,7 +235,7 @@ console.log(false ? 1 : 2);
 ##Автоматическое преобразование типов
 Ранее я упоминал, что JavaScript позволяет выполнять любые, подчас очень странные программы. К примеру:
 
-```
+```js
 console.log(8 * null)
 // → 0
 console.log("5" - 1)
@@ -254,7 +254,7 @@ console.log(false == 0)
 
 При сравнении величин одного типа через ==, легко предсказать, что вы должны получить true, если они одинаковые (исключая случай с NaN). Но когда типы различаются, JavaScript использует сложный и запутанный набор правил для сравнений. Обычно он пытается преобразовать тип одной из величин в тип другой. Когда с одной из сторон оператора возникает null или undefined, он выдаёт true, если обе стороны имеют значение null или undefined.
 
-```
+```js
 console.log(null == undefined);
 // → true
 console.log(null == 0);
@@ -272,7 +272,7 @@ console.log(null == 0);
 
 К примеру, || вернёт значение с левой части, когда его можно преобразовать в true – а иначе вернёт правую часть.
 
-```
+```js
 console.log(null || "user")
 // → user
 console.log("Karl" || "user")

chapters/chapter10.md

@@ -49,7 +49,7 @@
 
 Обратите внимание на простейший модуль, связывающий имена с номерами дней недели – как делает метод getDay объекта Date.
 
-```
+```js
 var names = ["Понедельник", "Вторник", "Среда", "Четверг", "Пятница", "Суббота", "Воскресенье"];
 function dayName(number) {
   return names[number];
@@ -63,7 +63,7 @@ console.log(dayName(1));
 
 Можно сделать так:
 
-```
+```js
 var dayName = function() {
   var names = ["Понедельник", "Вторник", "Среда", "Четверг", "Пятница", "Суббота", "Воскресенье"];
   return function(number) {
@@ -79,7 +79,7 @@ console.log(dayName(3));
 
 Подобный шаблон можно использовать для изолирования кода. Следующий модуль пишет в консоль значение, но не предоставляет никаких значений для использования другими модулями.
 
-```
+```js
 (function() {
   function square(x) { return x * x; }
   var hundred = 100;
@@ -97,7 +97,7 @@ console.log(dayName(3));
 
 Представьте, что нам надо добавить ещё одну функцию в наш модуль «день недели». Мы уже не можем возвращать функцию, а должны завернуть две функции в объект.
 
-```
+```js
 var weekDay = function() {
   var names = ["Понедельник", "Вторник", "Среда", "Четверг", "Пятница", "Суббота", "Воскресенье"];
   return {
@@ -112,7 +112,7 @@ console.log(weekDay.name(weekDay.number("Sunday")));
 
 Когда модуль большой, собирать все возвращаемые значения в объект в конце функции неудобно, потому что многие возвращаемые функции будут большими, и вам было бы удобнее их записывать где-то в другом месте, рядом со связанным с ними кодом. Удобно объявить объект (обычно называемый exports) и добавлять к нему свойства каждый раз, когда нам надо что-то экспортировать. В следующем примере функция модуля принимает объект интерфейса как аргумент, позволяя коду снаружи функции создать его и сохранить в переменной. Снаружи функции this ссылается на объект глобальной области видимости.
 
-```
+```js
 (function(exports) {
   var names = ["Понедельник", "Вторник", "Среда", "Четверг", "Пятница", "Суббота", "Воскресенье"];
 
@@ -142,7 +142,7 @@ console.log(weekDay.name(weekDay.number("Saturday")));
 
 Самый очевидный – оператор eval, который выполняет строку кода в текущем окружении. Это плохая идея – он нарушает некоторые свойства окружения, которые обычно у него есть, например изоляция от внешнего мира.
 
-```
+```js
 function evalAndReturnX(code) {
   eval(code);
   return x;
@@ -154,7 +154,7 @@ console.log(evalAndReturnX("var x = 2"));
 
 Способ лучше – использовать конструктор Function. Он принимает два аргумента – строку, содержащую список имён аргументов через запятую, и строку, содержащую тело функции.
 
-```
+```js
 var plusOne = new Function("n", "return n + 1;");
 console.log(plusOne(4));
 // → 5
@@ -165,7 +165,7 @@ console.log(plusOne(4));
 ##Require
 Вот минимальная версия функции require:
 
-```
+```js
 function require(name) {
   var code = new Function("exports", readFile(name));
   var exports = {};
@@ -179,7 +179,7 @@ console.log(require("weekDay").name(1));
 
 Так как конструктор new Function оборачивает код модуля в функцию, нам не надо писать функцию, оборачивающую пространство имён, внутри самого модуля. А так как exports является аргументом функции модуля, модулю не нужно его объявлять. Это убирает много мусора из нашего модуля-примера.
 
-```
+```js
 var names = ["Понедельник", "Вторник", "Среда", "Четверг", "Пятница", "Суббота", "Воскресенье"];
 
 exports.name = function(number) {
@@ -192,7 +192,7 @@ exports.number = function(name) {
 
 При использовании такого шаблона модуль обычно начинается с объявления нескольких переменных, которые загружают модули, от которых он зависит.
 
-```
+```js
 var weekDay = require("weekDay");
 var today = require("today");
 
@@ -207,7 +207,7 @@ console.log(weekDay.name(today.dayNumber()));
 
 Традиционное решение – предоставить модули с другой переменной, module, которая является объектом со свойством exports. Оно изначально указывает на пустой объект, созданный require, но может быть перезаписано другим значением, чтобы экспортировать что-либо ещё.
 
-```
+```js
 function require(name) {
   if (name in require.cache)
     return require.cache[name];
@@ -235,7 +235,7 @@ require.cache = Object.create(null);
 
 Наша простая программа с зависимости выглядела бы в AMD так:
 
-```
+```js
 define(["weekDay", "today"], function(weekDay, today) {
   console.log(weekDay.name(today.dayNumber()));
 });
@@ -245,7 +245,7 @@ define(["weekDay", "today"], function(weekDay, today) {
 
 Загруженные таким образом модули должны содержать вызовы define. В качестве их интерфейса используется то, что было возвращено функцией, переданной в define. Вот модуль weekDay:
 
-```
+```js
 define([], function() {
   var names = ["Понедельник", "Вторник", "Среда", "Четверг", "Пятница", "Суббота", "Воскресенье"];
   return {
@@ -261,7 +261,7 @@ define([], function() {
 
 Функция getModule принимает имя и возвращает такой объект, и убеждается в том, что модуль поставлен в очередь загрузки. Она использует кеширующий объект, чтобы не грузить один модуль дважды.
 
-```
+```js
 var defineCache = Object.create(null);
 var currentMod = null;
 
@@ -285,7 +285,7 @@ function getModule(name) {
 
 Функция define сама использует getModule для загрузки или создания объектов модулей для зависимостей текущего модуля. Её задача – запланировать запуск функции moduleFunction (содержащей сам код модуля) после загрузки зависимостей. Для этого она определяет функцию whenDepsLoaded, добавляемую в массив onLoad, содержащий все пока ещё не загруженные зависимости. Эта функция сразу прекращает работу, если есть ещё незагруженные зависимости, так что она выполнит свою работу только раз, когда последняя зависимость загрузится. Она также вызывается сразу из самого define, в случае когда никакие зависимости не нужно грузить.
 
-```
+```js
 function define(depNames, moduleFunction) {
   var myMod = currentMod;
   var deps = depNames.map(getModule);
@@ -352,7 +352,7 @@ function define(depNames, moduleFunction) {
 ###Названия месяцев
 Напишите простой модуль типа weekday, преобразующий номера месяцев (начиная с нуля) в названия и обратно. Выделите ему собственное пространство имён, т.к. ему потребуется внутренний массив с названиями месяцев, и используйте чистый JavaScript, без системы загрузки модулей.
 
-```
+```js
 // Ваш код
 
 console.log(month.name(2));