diff --git a/1-js/2-first-steps/1-hello-world/1-hello-alert/solution.md b/1-js/2-first-steps/1-hello-world/1-hello-alert/solution.md index 95104042..b27e40d9 100644 --- a/1-js/2-first-steps/1-hello-world/1-hello-alert/solution.md +++ b/1-js/2-first-steps/1-hello-world/1-hello-alert/solution.md @@ -4,16 +4,19 @@ + + - + + ``` diff --git a/1-js/2-first-steps/1-hello-world/article.md b/1-js/2-first-steps/1-hello-world/article.md index 50da17ba..ef740038 100644 --- a/1-js/2-first-steps/1-hello-world/article.md +++ b/1-js/2-first-steps/1-hello-world/article.md @@ -16,23 +16,25 @@ + +

Начало документа...

- *!* */!*

...Конец документа

+ ``` @@ -88,6 +90,7 @@ Выглядит это примерно так: ```html + diff --git a/1-js/2-first-steps/10-bitwise-operators/4-bit-rounding/task.md b/1-js/2-first-steps/10-bitwise-operators/4-bit-rounding/task.md index a0a19eac..13407c30 100644 --- a/1-js/2-first-steps/10-bitwise-operators/4-bit-rounding/task.md +++ b/1-js/2-first-steps/10-bitwise-operators/4-bit-rounding/task.md @@ -6,7 +6,7 @@ ```js //+ run -alert( 123456789 ^ 0 ); // 123456789 +alert( 123456789 ^ 0 ); // 123456789 alert( 12345678912345 ^ 0 ); // 1942903641 ``` diff --git a/1-js/2-first-steps/10-bitwise-operators/article.md b/1-js/2-first-steps/10-bitwise-operators/article.md index 77d348a0..6b6040fd 100644 --- a/1-js/2-first-steps/10-bitwise-operators/article.md +++ b/1-js/2-first-steps/10-bitwise-operators/article.md @@ -22,6 +22,7 @@ Примеры представления чисел в двоичной системе: ```js +//+ no-beautify a = 0; // 00000000000000000000000000000000 a = 1; // 00000000000000000000000000000001 a = 2; // 00000000000000000000000000000010 @@ -135,13 +136,13 @@ a = 255;// 00000000000000000000000011111111 ```js //+ run -var access = parseInt("11000", 2); // получаем число из строки +var access = parseInt("11000", 2); // получаем число из строки -alert(access); // 24, число с таким 2-ным представлением +alert( access ); // 24, число с таким 2-ным представлением var access2 = access.toString(2); // обратно двоичную строку из числа -alert(access2); // 11000 +alert( access2 ); // 11000 ``` Без них перевод в двоичную систему и обратно был бы куда менее удобен. @@ -167,6 +168,7 @@ alert(access2); // 11000 Пример: ```js +//+ no-beautify 9 (по осн. 10) = 00000000000000000000000000001001 (по осн. 2) 14 (по осн. 10) @@ -194,6 +196,7 @@ alert(access2); // 11000 Пример: ```js +//+ no-beautify 9 (по осн. 10) = 00000000000000000000000000001001 (по осн. 2) 14 (по осн. 10) @@ -225,6 +228,7 @@ alert(access2); // 11000 Пример: ```js +//+ no-beautify 9 (по осн. 10) = 00000000000000000000000000001001 (по осн. 2) 14 (по осн. 10) @@ -253,6 +257,7 @@ alert(access2); // 11000 Например, пусть в `data` очередное число равно `9`, а ключ `key` равен `1220461917`. ```js +//+ no-beautify Данные: 9 в двоичном виде 00000000000000000000000000001001 @@ -273,6 +278,7 @@ alert(access2); // 11000 В нашем случае: ```js +//+ no-beautify Полученная шифровка в двоичной системе: 9 ^ key = 1220461908 01001000101111101100010101010100 @@ -305,6 +311,7 @@ alert(access2); // 11000 Пример: ```js +//+ no-beautify 9 (по осн. 10) = 00000000000000000000000000001001 (по осн. 2) -------------------------------- @@ -319,8 +326,8 @@ alert(access2); // 11000 ```js //+ run -alert(~3); // -4 -alert(~-1); // 0 +alert( ~3 ); // -4 +alert( ~-1 ); // 0 ``` ### << (Битовый сдвиг влево) @@ -332,6 +339,7 @@ alert(~-1); // 0 Например, `9 << 2` даст `36`: ```js +//+ no-beautify 9 (по осн.10) = 00000000000000000000000000001001 (по осн.2) @@ -356,7 +364,7 @@ alert( 3 << 3 ); // 24, умножение на 2 три раза Конечно, следует иметь в виду, что побитовые операторы работают только с 32-битными числами, поэтому верхний порог такого "умножения" ограничен: ```js -//+ run +//+ run no-beautify *!* alert(10000000000 << 1); // -1474836480, отброшен крайний-левый бит */!* @@ -376,6 +384,7 @@ alert(10000000000 * 2); // 20000000000, обычное умножение Например, `9 >> 2` даст 2: ```js +//+ no-beautify 9 (по осн.10) = 00000000000000000000000000001001 (по осн.2) -------------------------------- @@ -389,6 +398,7 @@ alert(10000000000 * 2); // 20000000000, обычное умножение Аналогично, `-9 >> 2` даст `-3`: ```js +//+ no-beautify -9 (по осн.10) = 11111111111111111111111111110111 (по осн.2) -------------------------------- @@ -422,6 +432,7 @@ alert( 100 >> 3 ); // 12, деление на 2 три раза, целая ча Для отрицательных чисел -- результат работы разный. Например, `-9 >>> 2` даст `1073741821`, в отличие от `-9 >> 2` (дает `-3`): ```js +//+ no-beautify -9 (по осн.10) = 11111111111111111111111111110111 (по осн.2) -------------------------------- @@ -559,6 +570,7 @@ alert( 100 >> 3 ); // 12, деление на 2 три раза, целая ча Как правило, доступы задаются в виде констант: ```js +//+ no-beautify var ACCESS_ADMIN = 1; // 00001 var ACCESS_GOODS_EDIT = 2; // 00010 var ACCESS_GOODS_VIEW = 4; // 00100 @@ -592,7 +604,7 @@ alert(editor & ACCESS_ARTICLE_EDIT); // 8, доступ есть ```js var check = ACCESS_GOODS_VIEW | ACCESS_GOODS_EDIT; // 6, 00110 -alert(admin & check); // не 0, значит есть доступ к просмотру ИЛИ изменению +alert( admin & check ); // не 0, значит есть доступ к просмотру ИЛИ изменению ``` *Битовой маской* называют как раз комбинацию двоичных значений (`check` в примере выше), которая используется для проверки и выборки единиц на нужных позициях. @@ -626,14 +638,14 @@ alert( ~~12.345 ); // 12 ```js //+ run -alert( 12.345^0 ); // 12 +alert( 12.345 ^ 0 ); // 12 ``` Последнее даже более удобно, поскольку отлично читается: ```js //+ run -alert( 12.3 * 14.5 ^ 0); // (=178) "12.3 умножить на 14.5 *!*и округлить*/!*" +alert(12.3 * 14.5 ^ 0); // (=178) "12.3 умножить на 14.5 *!*и округлить*/!*" ``` У побитовых операторов достаточно низкий приоритет, он меньше чем у остальной арифметики: @@ -655,8 +667,8 @@ alert( 1.1 + 1.2 ^ 0 ); // 2, сложение выполнится раньше //+ run var n = 5; -if (~n) { // сработает, т.к. ~n = -(5+1) = -6 - alert("n не -1"); // выведет! +if (~n) { // сработает, т.к. ~n = -(5+1) = -6 + alert( "n не -1" ); // выведет! } ``` @@ -666,8 +678,8 @@ if (~n) { // сработает, т.к. ~n = -(5+1) = -6 //+ run var n = -1; -if (~n) { // не сработает, т.к. ~n = -(-1+1) = 0 - alert("...ничего не выведет..."); +if (~n) { // не сработает, т.к. ~n = -(-1+1) = 0 + alert( "...ничего не выведет..." ); } ``` @@ -678,7 +690,7 @@ if (~n) { // не сработает, т.к. ~n = -(-1+1) = 0 var str = "Проверка"; if (~str.indexOf("верка")) { // Сочетание "if (~...indexOf)" читается как "если найдено" - alert('найдено!'); + alert( 'найдено!' ); } ``` diff --git a/1-js/2-first-steps/11-uibasic/1-simple-page/solution.md b/1-js/2-first-steps/11-uibasic/1-simple-page/solution.md index 53bc8af2..a70b07e0 100644 --- a/1-js/2-first-steps/11-uibasic/1-simple-page/solution.md +++ b/1-js/2-first-steps/11-uibasic/1-simple-page/solution.md @@ -3,7 +3,7 @@ JS-код: ```js //+ demo run var name = prompt("Ваше имя?", ""); -alert(name); +alert( name ); ``` Полная страница: @@ -11,17 +11,20 @@ alert(name); ```html + + - + + ``` diff --git a/1-js/2-first-steps/11-uibasic/article.md b/1-js/2-first-steps/11-uibasic/article.md index e83f9c87..357967e6 100644 --- a/1-js/2-first-steps/11-uibasic/article.md +++ b/1-js/2-first-steps/11-uibasic/article.md @@ -15,7 +15,7 @@ alert(сообщение) ```js //+ run -alert("Привет"); +alert( "Привет" ); ``` Окно сообщения, которое выводится, является *модальным окном*. Слово "модальное" означает, что посетитель не может взаимодействовать со страницей, нажимать другие кнопки и т.п., пока не разберется с окном. В данном случае - пока не нажмет на "OK". @@ -25,6 +25,7 @@ alert("Привет"); Функция prompt принимает два аргумента: ```js +//+ no-beautify result = prompt(title, default); ``` @@ -87,7 +88,7 @@ result = confirm(question); //+ run var isAdmin = confirm("Вы - администратор?"); -alert(isAdmin); +alert( isAdmin ); ``` ## Особенности встроенных функций diff --git a/1-js/2-first-steps/12-ifelse/1-if-zero-string/solution.md b/1-js/2-first-steps/12-ifelse/1-if-zero-string/solution.md index 0e71c2b9..92098c3e 100644 --- a/1-js/2-first-steps/12-ifelse/1-if-zero-string/solution.md +++ b/1-js/2-first-steps/12-ifelse/1-if-zero-string/solution.md @@ -7,7 +7,7 @@ ```js //+ run if ("0") { - alert('Привет'); + alert( 'Привет' ); } ``` diff --git a/1-js/2-first-steps/12-ifelse/1-if-zero-string/task.md b/1-js/2-first-steps/12-ifelse/1-if-zero-string/task.md index 2b1bd3a7..27ce5aee 100644 --- a/1-js/2-first-steps/12-ifelse/1-if-zero-string/task.md +++ b/1-js/2-first-steps/12-ifelse/1-if-zero-string/task.md @@ -6,7 +6,7 @@ ```js if ("0") { - alert('Привет'); + alert( 'Привет' ); } ``` diff --git a/1-js/2-first-steps/12-ifelse/3-sign/solution.md b/1-js/2-first-steps/12-ifelse/3-sign/solution.md index 61af24e2..df54e347 100644 --- a/1-js/2-first-steps/12-ifelse/3-sign/solution.md +++ b/1-js/2-first-steps/12-ifelse/3-sign/solution.md @@ -2,14 +2,14 @@ ```js //+ run -var value = prompt('Введите число', 0); +var value = prompt('Введите число', 0); if (value > 0) { - alert(1); + alert( 1 ); } else if (value < 0) { - alert(-1); + alert( -1 ); } else { - alert(0); + alert( 0 ); } ``` diff --git a/1-js/2-first-steps/12-ifelse/4-check-login/solution.md b/1-js/2-first-steps/12-ifelse/4-check-login/solution.md index edafff62..edcdbb50 100644 --- a/1-js/2-first-steps/12-ifelse/4-check-login/solution.md +++ b/1-js/2-first-steps/12-ifelse/4-check-login/solution.md @@ -4,24 +4,24 @@ //+ run demo var userName = prompt('Кто пришёл?', ''); -if ( userName == 'Админ' ) { +if (userName == 'Админ') { var pass = prompt('Пароль?', ''); - if ( pass == 'Чёрный Властелин' ) { - alert('Добро пожаловать!'); - } else if ( pass == null ) { // (*) - alert('Вход отменён'); + if (pass == 'Чёрный Властелин') { + alert( 'Добро пожаловать!' ); + } else if (pass == null) { // (*) + alert( 'Вход отменён' ); } else { - alert('Пароль неверен'); + alert( 'Пароль неверен' ); } -} else if ( userName == null ) { // (**) - alert('Вход отменён'); +} else if (userName == null) { // (**) + alert( 'Вход отменён' ); } else { - alert('Я вас не знаю'); + alert( 'Я вас не знаю' ); } ``` diff --git a/1-js/2-first-steps/12-ifelse/article.md b/1-js/2-first-steps/12-ifelse/article.md index 9e9a9502..4b33eb99 100644 --- a/1-js/2-first-steps/12-ifelse/article.md +++ b/1-js/2-first-steps/12-ifelse/article.md @@ -8,7 +8,7 @@ //+ run var year = prompt('В каком году появилась спецификация ECMA-262 5.1?', ''); -if (year != 2011) alert('А вот и неправильно!'); +if (year != 2011) alert( 'А вот и неправильно!' ); ``` ## Оператор if @@ -19,8 +19,8 @@ if (year != 2011) alert('А вот и неправильно!'); ```js if (year != 2011) { - alert('А вот..'); - alert('..и неправильно!'); + alert( 'А вот..' ); + alert( '..и неправильно!' ); } ``` @@ -58,7 +58,7 @@ if (1) { // 1 преобразуется к true Можно и просто передать уже готовое логическое значение, к примеру, заранее вычисленное в переменной: ```js -var cond = (year != 2011); // true/false +var cond = (year != 2011); // true/false if (cond) { ... @@ -74,9 +74,9 @@ if (cond) { var year = prompt('Введите год появления стандарта ECMA-262 5.1', ''); if (year == 2011) { - alert('Да вы знаток!'); + alert( 'Да вы знаток!' ); } else { - alert('А вот и неправильно!'); // любое значение, кроме 2011 + alert( 'А вот и неправильно!' ); // любое значение, кроме 2011 } ``` @@ -89,11 +89,11 @@ if (year == 2011) { var year = prompt('В каком году появилась спецификация ECMA-262 5.1?', ''); if (year < 2011) { - alert('Это слишком рано..'); + alert( 'Это слишком рано..' ); } else if (year > 2011) { - alert('Это поздновато..'); + alert( 'Это поздновато..' ); } else { - alert('Да, точно в этом году!'); + alert( 'Да, точно в этом году!' ); } ``` @@ -104,7 +104,7 @@ if (year < 2011) { Иногда нужно в зависимости от условия присвоить переменную. Например: ```js -//+ run +//+ run no-beautify var access; var age = prompt('Сколько вам лет?', ''); @@ -164,12 +164,12 @@ access = age > 14; //+ run var age = prompt('возраст?', 18); -var message = (age < 3) ? 'Здравствуй, малыш!' : - (age < 18) ? 'Привет!' : - (age < 100) ? 'Здравствуйте!' : +var message = (age < 3) ? 'Здравствуй, малыш!' : + (age < 18) ? 'Привет!' : + (age < 100) ? 'Здравствуйте!' : 'Какой необычный возраст!'; -alert(message); +alert( message ); ``` Поначалу может быть сложно понять, что происходит. Однако, внимательно приглядевшись, мы замечаем, что это обычная последовательная проверка! @@ -195,7 +195,7 @@ if (age < 3) { Иногда оператор вопросительный знак `'?'` используют как замену `if`: ```js -//+ run +//+ run no-beautify var company = prompt('Какая компания создала JavaScript?', ''); *!* @@ -215,7 +215,7 @@ var company = prompt('Какая компания создала JavaScript?', ' Вот, для сравнения, то же самое с `if`: ```js -//+ run +//+ run no-beautify var company = prompt('Какая компания создала JavaScript?', ''); *!* diff --git a/1-js/2-first-steps/13-logical-ops/6-check-if-out-range/solution.md b/1-js/2-first-steps/13-logical-ops/6-check-if-out-range/solution.md index a901721c..3d2eab1a 100644 --- a/1-js/2-first-steps/13-logical-ops/6-check-if-out-range/solution.md +++ b/1-js/2-first-steps/13-logical-ops/6-check-if-out-range/solution.md @@ -1,7 +1,7 @@ Первый вариант: ```js -if ( !(age >= 14 && age <= 90) ) +if (!(age >= 14 && age <= 90)) ``` Второй вариант: diff --git a/1-js/2-first-steps/13-logical-ops/7-if-question/solution.md b/1-js/2-first-steps/13-logical-ops/7-if-question/solution.md index 90f7a877..f1b83dab 100644 --- a/1-js/2-first-steps/13-logical-ops/7-if-question/solution.md +++ b/1-js/2-first-steps/13-logical-ops/7-if-question/solution.md @@ -6,16 +6,16 @@ //+ run // Выполнится // Результат -1 || 0 = -1, в логическом контексте true -if (-1 || 0) alert('первое'); +if (-1 || 0) alert( 'первое' ); // Не выполнится // -1 && 0 = 0, в логическом контексте false -if (-1 && 0) alert('второе'); +if (-1 && 0) alert( 'второе' ); // Выполнится // оператор && имеет больший приоритет, чем || // так что -1 && 1 выполнится раньше // вычисления: null || -1 && 1 -> null || 1 -> 1 -if (null || -1 && 1) alert('третье'); +if (null || -1 && 1) alert( 'третье' ); ``` diff --git a/1-js/2-first-steps/13-logical-ops/7-if-question/task.md b/1-js/2-first-steps/13-logical-ops/7-if-question/task.md index bbf094d8..ee7018b6 100644 --- a/1-js/2-first-steps/13-logical-ops/7-if-question/task.md +++ b/1-js/2-first-steps/13-logical-ops/7-if-question/task.md @@ -7,8 +7,8 @@ Какие конкретно значения будут результатами выражений в условиях `if(...)`? ```js -if (-1 || 0) alert('первое'); -if (-1 && 0) alert('второе'); -if (null || -1 && 1) alert('третье'); +if (-1 || 0) alert( 'первое' ); +if (-1 && 0) alert( 'второе' ); +if (null || -1 && 1) alert( 'третье' ); ``` diff --git a/1-js/2-first-steps/13-logical-ops/article.md b/1-js/2-first-steps/13-logical-ops/article.md index 0f7fa965..27c01996 100644 --- a/1-js/2-first-steps/13-logical-ops/article.md +++ b/1-js/2-first-steps/13-logical-ops/article.md @@ -19,18 +19,18 @@ result = a || b; ```js //+ run -alert( true || true ); // true +alert( true || true ); // true alert( false || true ); // true -alert( true || false); // true -alert( false || false); // false +alert( true || false ); // true +alert( false || false ); // false ``` Если значение не логического типа -- то оно к нему приводится в целях вычислений. Например, число `1` будет воспринято как `true`, а `0` -- как `false`: ```js //+ run -if ( 1 || 0 ) { // сработает как if( true || false ) - alert('верно'); +if (1 || 0) { // сработает как if( true || false ) + alert( 'верно' ); } ``` @@ -41,9 +41,9 @@ if ( 1 || 0 ) { // сработает как if( true || false ) var hour = 9; *!* -if (hour < 10 || hour > 18) { +if (hour < 10 || hour > 18) { */!* - alert('Офис до 10 или после 18 закрыт'); + alert( 'Офис до 10 или после 18 закрыт' ); } ``` @@ -51,10 +51,11 @@ if (hour < 10 || hour > 18) { ```js //+ run -var hour = 12, isWeekend = true; +var hour = 12, + isWeekend = true; if (hour < 10 || hour > 18 || isWeekend) { - alert('Офис до 10 или после 18 или в выходной закрыт'); + alert( 'Офис до 10 или после 18 или в выходной закрыт' ); } ``` @@ -69,7 +70,7 @@ JavaScript вычисляет несколько ИЛИ слева направ При запуске примера ниже присвоение `x` не произойдёт: ```js -//+ run +//+ run no-beautify var x; *!*true*/!* || (x = 1); @@ -80,7 +81,7 @@ alert(x); // undefined, x не присвоен ...А в примере ниже первый аргумент -- `false`, так что ИЛИ попытается вычислить второй, запустив тем самым присваивание: ```js -//+ run +//+ run no-beautify var x; *!*false*/!* || (x = 1); @@ -99,7 +100,7 @@ alert(x); // 1 ```js //+ run alert( 1 || 0 ); // 1 -alert( true || 'неважно что'); // true +alert( true || 'неважно что' ); // true alert( null || 1 ); // 1 alert( undefined || 0 ); // 0 @@ -110,7 +111,7 @@ alert( undefined || 0 ); // 0 ```js //+ run var undef; // переменная не присвоена, т.е. равна undefined -var zero = 0; +var zero = 0; var emptyStr = ""; var msg = "Привет!"; @@ -118,15 +119,14 @@ var msg = "Привет!"; var result = undef || zero || emptyStr || msg || 0; */!* -alert(result); // выведет "Привет!" - первое значение, которое является true +alert( result ); // выведет "Привет!" - первое значение, которое является true ``` Если все значения "ложные", то `||` возвратит последнее из них: ```js //+ run - -alert(undefined || '' || false || 0); // 0 +alert( undefined || '' || false || 0 ); // 0 ``` [summary] @@ -146,20 +146,21 @@ result = a && b; ```js //+ run -alert( true && true ); // true +alert( true && true ); // true alert( false && true ); // false -alert( true && false); // false -alert( false && false); // false +alert( true && false ); // false +alert( false && false ); // false ``` Пример c `if`: ```js //+ run -var hour = 12, minute = 30; +var hour = 12, + minute = 30; if (hour == 12 && minute == 30) { - alert('Время 12:30'); + alert( 'Время 12:30' ); } ``` @@ -167,8 +168,8 @@ if (hour == 12 && minute == 30) { ```js //+ run -if ( 1 && 0 ) { // вычислится как true && false - alert('не сработает, т.к. условие ложно'); +if (1 && 0) { // вычислится как true && false + alert( 'не сработает, т.к. условие ложно' ); } ``` @@ -182,22 +183,22 @@ if ( 1 && 0 ) { // вычислится как true && false //+ run // Первый аргумент - true, // Поэтому возвращается второй аргумент -alert(1 && 0); // 0 -alert(1 && 5); // 5 +alert( 1 && 0 ); // 0 +alert( 1 && 5 ); // 5 // Первый аргумент - false, // Он и возвращается, а второй аргумент игнорируется -alert(null && 5); // null -alert(0 && "не важно"); // 0 +alert( null && 5 ); // null +alert( 0 && "не важно" ); // 0 ``` Можно передать и несколько значений подряд, при этом возвратится первое "ложное" (на котором остановились вычисления), а если его нет -- то последнее: ```js //+ run -alert(1 && 2 && null && 3); // null +alert( 1 && 2 && null && 3 ); // null -alert(1 && 2 && 3); // 3 +alert( 1 && 2 && 3 ); // 3 ``` [summary] @@ -211,7 +212,7 @@ alert(1 && 2 && 3); // 3 ```js //+ run -alert(5 || 1 && 0); // 5 +alert( 5 || 1 && 0 ); // 5 ``` [/smart] @@ -223,7 +224,7 @@ alert(5 || 1 && 0); // 5 //+ run var x = 1; -(x > 0) && alert('Больше'); +(x > 0) && alert( 'Больше' ); ``` Действие в правой части `&&` выполнится только в том случае, если до него дойдут вычисления. То есть, `alert` сработает, если в левой части будет `true`. @@ -235,7 +236,7 @@ var x = 1; var x = 1; if (x > 0) { - alert('Больше'); + alert( 'Больше' ); } ``` @@ -261,15 +262,15 @@ var result = !value; ```js //+ run -alert( !true ) // false -alert( !0 ) // true +alert(!true) // false +alert(!0) // true ``` **В частности, двойное НЕ используются для преобразования значений к логическому типу:** ```js //+ run -alert( !!"строка" ) // true -alert( !!null ) // false +alert(!!"строка") // true +alert(!!null) // false ``` diff --git a/1-js/2-first-steps/14-types-conversion/1-primitive-conversions-questions/solution.md b/1-js/2-first-steps/14-types-conversion/1-primitive-conversions-questions/solution.md index f344d41d..8367d6cf 100644 --- a/1-js/2-first-steps/14-types-conversion/1-primitive-conversions-questions/solution.md +++ b/1-js/2-first-steps/14-types-conversion/1-primitive-conversions-questions/solution.md @@ -1,17 +1,14 @@ ```js -"" + 1 + 0 = "10" // (1) -"" - 1 + 0 = -1 // (2) +"" + 1 + 0 = "10" // (1) +"" - 1 + 0 = -1 // (2) true + false = 1 -6 / "3" = 2 -"2" * "3" = 6 +6 / "3" = 2 "2" * "3" = 6 4 + 5 + "px" = "9px" "$" + 4 + 5
 = "$45" -"4" - 2
 = 2 -"4px" - 2
 = NaN -7 / 0
 = Infinity -" -9\n" + 5 = " -9\n5" +"4" - 2
 = 2 "4px" - 2
 = NaN +7 / 0
 = Infinity " -9\n" + 5 = " -9\n5" " -9\n" - 5 = -14 5 && 2
 = 2 2 && 5
 = 5 diff --git a/1-js/2-first-steps/14-types-conversion/1-primitive-conversions-questions/task.md b/1-js/2-first-steps/14-types-conversion/1-primitive-conversions-questions/task.md index f4b4928e..17f99243 100644 --- a/1-js/2-first-steps/14-types-conversion/1-primitive-conversions-questions/task.md +++ b/1-js/2-first-steps/14-types-conversion/1-primitive-conversions-questions/task.md @@ -5,18 +5,13 @@ Подумайте, какой результат будет у выражений ниже. Тут не только преобразования типов. Когда закончите -- сверьтесь с решением. ```js -"" + 1 + 0 -"" - 1 + 0 +"" + 1 + 0 "" - 1 + 0 true + false 6 / "3" "2" * "3" 4 + 5 + "px" -"$" + 4 + 5
 -"4" - 2
 -"4px" - 2
 -7 / 0
 -" -9\n" + 5 -" -9\n" - 5 +"$" + 4 + 5
 "4" - 2
 "4px" - 2
 +7 / 0
 " -9\n" + 5 " -9\n" - 5 5 && 2
 2 && 5
 5 || 0
 diff --git a/1-js/2-first-steps/14-types-conversion/article.md b/1-js/2-first-steps/14-types-conversion/article.md index 6cf8a89a..65e38666 100644 --- a/1-js/2-first-steps/14-types-conversion/article.md +++ b/1-js/2-first-steps/14-types-conversion/article.md @@ -20,7 +20,7 @@ //+ run var a = true; -alert(a); // "true" +alert( a ); // "true" ``` Можно также осуществить преобразование явным вызовом `String(val)`: @@ -37,7 +37,7 @@ alert( String(null) === "null" ); // true ```js //+ run alert( true + "test" ); // "truetest" -alert( "123" + undefined); // "123undefined" +alert( "123" + undefined ); // "123undefined" ``` ## Численное преобразование @@ -64,7 +64,7 @@ var a = Number("123"); // 123, тот же эффект ```js //+ run // после обрезания пробельных символов останется "123" -alert( +" \n 123 \n \n"); // 123 +alert( +" \n 123 \n \n" ); // 123 ``` Ещё примеры: @@ -74,7 +74,7 @@ alert( +" \n 123 \n \n"); // 123 ```js //+ run alert( +true ); // 1 -alert( +false); // 0 +alert( +false ); // 0 ``` @@ -120,18 +120,18 @@ alert( "1" == true ); ```js //+ run -alert(null >= 0); // true, т.к. null преобразуется к 0 -alert(null > 0); // false (не больше), т.к. null преобразуется к 0 -alert(null == 0 ); // false (и не равен!), т.к. == рассматривает null особо. +alert( null >= 0 ); // true, т.к. null преобразуется к 0 +alert( null > 0 ); // false (не больше), т.к. null преобразуется к 0 +alert( null == 0 ); // false (и не равен!), т.к. == рассматривает null особо. ``` Значение `undefined` вообще "несравнимо": ```js //+ run -alert(undefined > 0); // false, т.к. undefined -> NaN -alert(undefined == 0); // false, т.к. это undefined (без преобразования) -alert(undefined < 0); // false, т.к. undefined -> NaN +alert( undefined > 0 ); // false, т.к. undefined -> NaN +alert( undefined == 0 ); // false, т.к. это undefined (без преобразования) +alert( undefined < 0 ); // false, т.к. undefined -> NaN ``` **Для более очевидной работы кода и во избежание ошибок лучше не давать специальным значениям участвовать в сравнениях `> >= < <=`.** @@ -178,15 +178,15 @@ alert( !!" " ); // любые непустые строки, даже из пр ```js //+ run -alert( 0 == "\n0\n" ); // true +alert( 0 == "\n0\n" ); // true ``` ...А в логическом контексте левая часть даст `false`, правая -- `true`: ```js //+ run -if ("\n0\n") { - alert("true, совсем не как 0!"); +if ("\n0\n") { + alert( "true, совсем не как 0!" ); } ``` diff --git a/1-js/2-first-steps/15-while-for/1-loop-last-value/solution.md b/1-js/2-first-steps/15-while-for/1-loop-last-value/solution.md index 6bdf4691..15c634c9 100644 --- a/1-js/2-first-steps/15-while-for/1-loop-last-value/solution.md +++ b/1-js/2-first-steps/15-while-for/1-loop-last-value/solution.md @@ -4,8 +4,8 @@ //+ run var i = 3; -while(i) { - alert(i--); +while (i) { + alert( i-- ); } ``` @@ -15,7 +15,7 @@ while(i) { ```js var i = 3 -alert(i--); // выведет 3, затем уменьшит i до 2 +alert( i-- ); // выведет 3, затем уменьшит i до 2 alert(i--) // выведет 2, затем уменьшит i до 1 diff --git a/1-js/2-first-steps/15-while-for/1-loop-last-value/task.md b/1-js/2-first-steps/15-while-for/1-loop-last-value/task.md index 46b79f7e..25359633 100644 --- a/1-js/2-first-steps/15-while-for/1-loop-last-value/task.md +++ b/1-js/2-first-steps/15-while-for/1-loop-last-value/task.md @@ -7,8 +7,8 @@ ```js var i = 3; -while(i) { - alert(i--); +while (i) { + alert( i-- ); } ``` diff --git a/1-js/2-first-steps/15-while-for/2-which-value-while/solution.md b/1-js/2-first-steps/15-while-for/2-which-value-while/solution.md index 5d0afef5..f7e77582 100644 --- a/1-js/2-first-steps/15-while-for/2-which-value-while/solution.md +++ b/1-js/2-first-steps/15-while-for/2-which-value-while/solution.md @@ -4,7 +4,7 @@ ```js //+ run var i = 0; -while (++i < 5) alert(i); +while (++i < 5) alert( i ); ``` Первое значение: `i=1`, так как операция `++i` сначала увеличит `i`, а потом уже произойдёт сравнение и выполнение `alert`. @@ -18,7 +18,7 @@ while (++i < 5) alert(i); ```js //+ run var i = 0; -while (i++ < 5) alert(i); +while (i++ < 5) alert( i ); ``` Первое значение: `i=1`. Остановимся на нём подробнее. Оператор `i++` увеличивает `i`, возвращая старое значение, так что в сравнении `i++ < 5` будет участвовать старое `i=0`. diff --git a/1-js/2-first-steps/15-while-for/2-which-value-while/task.md b/1-js/2-first-steps/15-while-for/2-which-value-while/task.md index 8d477177..674f005b 100644 --- a/1-js/2-first-steps/15-while-for/2-which-value-while/task.md +++ b/1-js/2-first-steps/15-while-for/2-which-value-while/task.md @@ -8,7 +8,7 @@ ```js var i = 0; -while (++i < 5) alert(i); +while (++i < 5) alert( i ); ``` @@ -16,7 +16,7 @@ while (++i < 5) alert(i); ```js var i = 0; -while (i++ < 5) alert(i); +while (i++ < 5) alert( i ); ``` diff --git a/1-js/2-first-steps/15-while-for/3-which-value-for/solution.md b/1-js/2-first-steps/15-while-for/3-which-value-for/solution.md index 734224cf..941a07be 100644 --- a/1-js/2-first-steps/15-while-for/3-which-value-for/solution.md +++ b/1-js/2-first-steps/15-while-for/3-which-value-for/solution.md @@ -2,9 +2,9 @@ ```js //+ run -for(var i=0; i<5; ++i) alert(i); +for (var i = 0; i < 5; ++i) alert( i ); -for(var i=0; i<5; i++) alert(i); +for (var i = 0; i < 5; i++) alert( i ); ``` Такой результат обусловлен алгоритмом работы `for`: diff --git a/1-js/2-first-steps/15-while-for/3-which-value-for/task.md b/1-js/2-first-steps/15-while-for/3-which-value-for/task.md index a08c4743..e918c89c 100644 --- a/1-js/2-first-steps/15-while-for/3-which-value-for/task.md +++ b/1-js/2-first-steps/15-while-for/3-which-value-for/task.md @@ -7,14 +7,14 @@
  • Постфиксная форма: ```js -for(var i=0; i<5; i++) alert(i); +for (var i = 0; i < 5; i++) alert( i ); ```
  • Префиксная форма: ```js -for(var i=0; i<5; ++i) alert(i); +for (var i = 0; i < 5; ++i) alert( i ); ```
    • diff --git a/1-js/2-first-steps/15-while-for/4-for-even/solution.md b/1-js/2-first-steps/15-while-for/4-for-even/solution.md index 993f351d..62ca05c7 100644 --- a/1-js/2-first-steps/15-while-for/4-for-even/solution.md +++ b/1-js/2-first-steps/15-while-for/4-for-even/solution.md @@ -3,8 +3,8 @@ ```js //+ run demo for (var i = 2; i <= 10; i++) { - if ( i % 2 == 0) { - alert(i); + if (i % 2 == 0) { + alert( i ); } } ``` diff --git a/1-js/2-first-steps/15-while-for/5-replace-for-while/solution.md b/1-js/2-first-steps/15-while-for/5-replace-for-while/solution.md index d0c6d428..84915ab4 100644 --- a/1-js/2-first-steps/15-while-for/5-replace-for-while/solution.md +++ b/1-js/2-first-steps/15-while-for/5-replace-for-while/solution.md @@ -4,7 +4,7 @@ //+ run var i = 0; while (i < 3) { - alert("номер " + i + "!"); + alert( "номер " + i + "!" ); i++; } ``` diff --git a/1-js/2-first-steps/15-while-for/5-replace-for-while/task.md b/1-js/2-first-steps/15-while-for/5-replace-for-while/task.md index 4898d8b9..2da6d6f2 100644 --- a/1-js/2-first-steps/15-while-for/5-replace-for-while/task.md +++ b/1-js/2-first-steps/15-while-for/5-replace-for-while/task.md @@ -7,7 +7,7 @@ ```js //+ run for (var i = 0; i < 3; i++) { - alert("номер " + i + "!"); + alert( "номер " + i + "!" ); } ``` diff --git a/1-js/2-first-steps/15-while-for/6-repeat-until-correct/solution.md b/1-js/2-first-steps/15-while-for/6-repeat-until-correct/solution.md index 311bb68b..49d5396e 100644 --- a/1-js/2-first-steps/15-while-for/6-repeat-until-correct/solution.md +++ b/1-js/2-first-steps/15-while-for/6-repeat-until-correct/solution.md @@ -6,7 +6,7 @@ var num; do { num = prompt("Введите число больше 100?", 0); -} while(num <= 100 && num != null); +} while (num <= 100 && num != null); ``` Цикл `do..while` повторяется, пока верны две проверки: diff --git a/1-js/2-first-steps/15-while-for/7-list-primes/solution.md b/1-js/2-first-steps/15-while-for/7-list-primes/solution.md index 7a566562..eead33a3 100644 --- a/1-js/2-first-steps/15-while-for/7-list-primes/solution.md +++ b/1-js/2-first-steps/15-while-for/7-list-primes/solution.md @@ -2,9 +2,9 @@ ```js Для всех i от 1 до 10 { - проверить, делится ли число i на какое-либо из чисел до него - если делится, то это i не подходит, берем следующее - если не делится, то i - простое число + проверить, делится ли число i на какое - либо из чисел до него + если делится, то это i не подходит, берем следующее + если не делится, то i - простое число } ``` @@ -14,15 +14,15 @@ ```js //+ run -nextPrime: -for(var i=2; i<10; i++) { +nextPrime: + for (var i = 2; i < 10; i++) { - for(var j=2; j 5) ? alert(i) : *!*continue*/!*; ``` @@ -287,7 +288,7 @@ if (условие) { Например, внутри цикла по `i` находится цикл по `j`, и при выполнении некоторого условия мы бы хотели выйти из обоих циклов сразу: ```js -//+ run +//+ run no-beautify *!*outer:*/!* for (var i = 0; i < 3; i++) { for (var j = 0; j < 3; j++) { @@ -308,12 +309,14 @@ alert('Готово!'); Метка имеет вид `"имя:"`, имя должно быть уникальным. Она ставится перед циклом, вот так: ```js +//+ no-beautify outer: for (var i = 0; i < 3; i++) { ... } ``` Можно также выносить ее на отдельную строку: ```js +//+ no-beautify outer: for (var i = 0; i < 3; i++) { ... } ``` diff --git a/1-js/2-first-steps/16-switch/1-rewrite-switch-if-else/solution.md b/1-js/2-first-steps/16-switch/1-rewrite-switch-if-else/solution.md index 98ca59a1..1605333f 100644 --- a/1-js/2-first-steps/16-switch/1-rewrite-switch-if-else/solution.md +++ b/1-js/2-first-steps/16-switch/1-rewrite-switch-if-else/solution.md @@ -3,6 +3,7 @@ В реальном случае, скорее всего, подойдёт обычное сравнение `'=='`. ```js +//+ no-beautify if(browser == 'IE') { alert('О, да у вас IE!'); } else if (browser == 'Chrome' diff --git a/1-js/2-first-steps/16-switch/1-rewrite-switch-if-else/task.md b/1-js/2-first-steps/16-switch/1-rewrite-switch-if-else/task.md index f9d936ea..15bf197e 100644 --- a/1-js/2-first-steps/16-switch/1-rewrite-switch-if-else/task.md +++ b/1-js/2-first-steps/16-switch/1-rewrite-switch-if-else/task.md @@ -5,20 +5,20 @@ Напишите `if..else`, соответствующий следующему `switch`: ```js -switch(browser) { +switch (browser) { case 'IE': - alert('О, да у вас IE!'); + alert( 'О, да у вас IE!' ); break; case 'Chrome': case 'Firefox': case 'Safari': case 'Opera': - alert('Да, и эти браузеры мы поддерживаем'); + alert( 'Да, и эти браузеры мы поддерживаем' ); break; default: - alert('Мы надеемся, что и в вашем браузере все ок!'); + alert( 'Мы надеемся, что и в вашем браузере все ок!' ); } ``` diff --git a/1-js/2-first-steps/16-switch/2-rewrite-if-switch/solution.md b/1-js/2-first-steps/16-switch/2-rewrite-if-switch/solution.md index 149bcfa1..ab738f53 100644 --- a/1-js/2-first-steps/16-switch/2-rewrite-if-switch/solution.md +++ b/1-js/2-first-steps/16-switch/2-rewrite-if-switch/solution.md @@ -4,18 +4,18 @@ //+ run var a = +prompt('a?', ''); -switch(a) { +switch (a) { case 0: - alert(0); + alert( 0 ); break; case 1: - alert(1); + alert( 1 ); break; case 2: case 3: - alert('2,3'); + alert( '2,3' ); *!* break; */!* diff --git a/1-js/2-first-steps/16-switch/2-rewrite-if-switch/task.md b/1-js/2-first-steps/16-switch/2-rewrite-if-switch/task.md index a967428e..a542c993 100644 --- a/1-js/2-first-steps/16-switch/2-rewrite-if-switch/task.md +++ b/1-js/2-first-steps/16-switch/2-rewrite-if-switch/task.md @@ -9,14 +9,14 @@ var a = +prompt('a?', ''); if (a == 0) { - alert(0); + alert( 0 ); } if (a == 1) { - alert(1); + alert( 1 ); } -if (a == 2 || a == 3) { - alert('2,3'); +if (a == 2 || a == 3) { + alert( '2,3' ); } ``` diff --git a/1-js/2-first-steps/16-switch/article.md b/1-js/2-first-steps/16-switch/article.md index 023f542c..9a1f8fff 100644 --- a/1-js/2-first-steps/16-switch/article.md +++ b/1-js/2-first-steps/16-switch/article.md @@ -9,6 +9,7 @@ Выглядит она так: ```js +//+ no-beautify switch(x) { case 'value1': // if (x === 'value1') ... @@ -48,18 +49,18 @@ var a = 2 + 2; switch (a) { case 3: - alert('Маловато'); + alert( 'Маловато' ); break; *!* case 4: - alert('В точку!'); + alert( 'В точку!' ); break; */!* case 5: - alert('Перебор'); + alert( 'Перебор' ); break; default: - alert('Я таких значений не знаю'); + alert( 'Я таких значений не знаю' ); } ``` @@ -73,18 +74,18 @@ switch (a) { ```js //+ run -var a = 2+2; +var a = 2 + 2; switch (a) { case 3: - alert('Маловато'); + alert( 'Маловато' ); *!* case 4: - alert('В точку!'); + alert( 'В точку!' ); case 5: - alert('Перебор'); + alert( 'Перебор' ); default: - alert('Я таких значений не знаю'); + alert( 'Я таких значений не знаю' ); */!* } ``` @@ -92,9 +93,9 @@ switch (a) { В примере выше последовательно выполнятся три `alert`: ```js -alert('В точку!'); -alert('Перебор'); -alert('Я таких значений не знаю'); +alert( 'В точку!' ); +alert( 'Перебор' ); +alert( 'Я таких значений не знаю' ); ``` В `case` могут быть любые выражения, в том числе включающие в себя переменные и функции. @@ -106,10 +107,10 @@ alert('Я таких значений не знаю'); var a = 1; var b = 0; -switch(a) { +switch (a) { *!* - case b+1: - alert(1); + case b + 1: + alert( 1 ); break; */!* @@ -125,7 +126,7 @@ switch(a) { В примере ниже `case 3` и `case 5` выполняют один и тот же код: ```js -//+ run +//+ run no-beautify var a = 2+2; switch (a) { @@ -155,17 +156,17 @@ switch (a) { ```js //+ run var arg = prompt("Введите arg?") -switch(arg) { +switch (arg) { case '0': case '1': - alert('Один или ноль'); + alert( 'Один или ноль' ); case '2': - alert('Два'); + alert( 'Два' ); break; case 3: - alert('Никогда не выполнится'); + alert( 'Никогда не выполнится' ); default: alert('Неизвестное значение: ' + arg) diff --git a/1-js/2-first-steps/17-function-basics/4-pow/solution.md b/1-js/2-first-steps/17-function-basics/4-pow/solution.md index 7d818e30..30ec3ce4 100644 --- a/1-js/2-first-steps/17-function-basics/4-pow/solution.md +++ b/1-js/2-first-steps/17-function-basics/4-pow/solution.md @@ -13,7 +13,7 @@ function pow(x, n) { var result = x; - for(var i = 1; i < n; i++) { + for (var i = 1; i < n; i++) { result *= x; } diff --git a/1-js/2-first-steps/17-function-basics/4-pow/task.md b/1-js/2-first-steps/17-function-basics/4-pow/task.md index 522badc3..0160bfcf 100644 --- a/1-js/2-first-steps/17-function-basics/4-pow/task.md +++ b/1-js/2-first-steps/17-function-basics/4-pow/task.md @@ -5,9 +5,9 @@ Напишите функцию `pow(x,n)`, которая возвращает `x` в степени `n`. Иначе говоря, умножает `x` на себя `n` раз и возвращает результат. ```js -pow(3, 2) = 3*3 = 9 -pow(3, 3) = 3*3*3 = 27 -pow(1, 100) = 1*1*...*1 = 1 +pow(3, 2) = 3 * 3 = 9 +pow(3, 3) = 3 * 3 * 3 = 27 +pow(1, 100) = 1 * 1 * ...*1 = 1 ``` Создайте страницу, которая запрашивает `x` и `n`, а затем выводит результат `pow(x,n)`. diff --git a/1-js/2-first-steps/17-function-basics/article.md b/1-js/2-first-steps/17-function-basics/article.md index 08e2859d..d4b6710b 100644 --- a/1-js/2-first-steps/17-function-basics/article.md +++ b/1-js/2-first-steps/17-function-basics/article.md @@ -13,8 +13,8 @@ Пример объявления функции: ```js -function showMessage() { - alert('Привет всем присутствующим!'); +function showMessage() { + alert( 'Привет всем присутствующим!' ); } ``` @@ -24,8 +24,8 @@ function showMessage() { ```js //+ run -function showMessage() { - alert('Привет всем присутствующим!'); +function showMessage() { + alert( 'Привет всем присутствующим!' ); } *!* @@ -49,12 +49,12 @@ function showMessage() { var message = 'Привет, я - Вася!'; // локальная переменная */!* - alert(message); + alert( message ); } showMessage(); // 'Привет, я - Вася!' -alert(message); // <-- будет ошибка, т.к. переменная видна только внутри +alert( message ); // <-- будет ошибка, т.к. переменная видна только внутри ``` **Блоки `if/else`, `switch`, `for`, `while`, `do..while` не влияют на область видимости переменных.** @@ -64,6 +64,7 @@ alert(message); // <-- будет ошибка, т.к. переменная ви Например: ```js +//+ no-beautify function count() { // переменные i,j не будут уничтожены по окончании цикла for (*!*var*/!* i=0; i<3; i++) { @@ -86,12 +87,12 @@ function count() { *!* var i, j; // передвинули объявления var в начало */!* - for (i=0; i<3; i++) { + for (i = 0; i < 3; i++) { j = i * 2; } - alert(i); // i=3 - alert(j); // j=4 + alert( i ); // i=3 + alert( j ); // j=4 } ``` @@ -100,7 +101,7 @@ function count() { Функция может обратиться ко внешней переменной, например: ```js -//+ run +//+ run no-beautify var *!*userName*/!* = 'Вася'; function showMessage() { @@ -121,13 +122,13 @@ function showMessage() { userName = 'Петя'; // (1) присвоение во внешнюю переменную var message = 'Привет, я ' + userName; - alert(message); + alert( message ); } showMessage(); *!* -alert(userName); // Петя, значение внешней переменной изменено функцией +alert( userName ); // Петя, значение внешней переменной изменено функцией */!* ``` @@ -154,7 +155,7 @@ function showMessage() { showMessage(); -alert(message); // Привет +alert( message ); // Привет ``` В коде выше переменная `message` нигде не объявлена, а сразу присваивается. Скорее всего, программист просто забыл поставить `var`. @@ -177,7 +178,7 @@ alert(message); // Привет Например, этот код выводит два сообщения: ```js -//+ run +//+ run no-beautify function showMessage(*!*from, text*/!*) { // параметры from, text from = "** " + from + " **"; // здесь может быть сложный код оформления @@ -197,18 +198,18 @@ showMessage('Маша', 'Как дела?'); ```js //+ run -function showMessage(from, text) { +function showMessage(from, text) { *!* - from = '**' + from + '**'; // меняем локальную переменную from + from = '**' + from + '**'; // меняем локальную переменную from */!* - alert(from + ': ' + text); + alert( from + ': ' + text ); } var from = "Маша"; -showMessage(from, "Привет"); +showMessage(from, "Привет"); -alert(from); // старое значение from без изменений, в функции была изменена копия +alert( from ); // старое значение from без изменений, в функции была изменена копия ``` ## Аргументы по умолчанию @@ -234,7 +235,7 @@ function showMessage(from, text) { } */!* - alert(from + ": " + text); + alert( from + ": " + text ); } showMessage("Маша", "Привет!"); // Маша: Привет! @@ -254,9 +255,9 @@ showMessage("Маша"); // Маша: текст не передан ```js //+ run function showMessage(from, text) { - text = text || 'текст не передан'; + text = text || 'текст не передан'; - ... + ... } ``` @@ -273,7 +274,7 @@ function showMessage(from, text) { Например, создадим функцию `calcD`, которая будет возвращать дискриминант квадратного уравнения по формуле b2 - 4ac: ```js -//+ run +//+ run no-beautify function calcD(a, b, c) { *!*return*/!* b*b - 4*a*c; } @@ -291,7 +292,7 @@ alert(test); // 20 ```js //+ run function checkAge(age) { - if (age > 18) { + if (age > 18) { return true; } else { return confirm('Родители разрешили?'); @@ -301,9 +302,9 @@ function checkAge(age) { var age = prompt('Ваш возраст?'); if (checkAge(age)) { - alert('Доступ разрешен'); + alert( 'Доступ разрешен' ); } else { - alert('В доступе отказано'); + alert( 'В доступе отказано' ); } ``` @@ -318,8 +319,8 @@ function showMovie(age) { return; */!* } - - alert("Фильм не для всех"); // (*) + + alert( "Фильм не для всех" ); // (*) // ... } ``` @@ -342,7 +343,7 @@ alert( doNothing() ); // undefined ```js //+ run -function doNothing() { +function doNothing() { return; } @@ -360,12 +361,14 @@ alert( doNothing() === undefined ); // true Функции, которые начинаются с `"show"` -- что-то показывают: ```js +//+ no-beautify showMessage(..) // префикс show, "показать" сообщение ``` Функции, начинающиеся с `"get"` -- получают, и т.п.: ```js +//+ no-beautify getAge(..) // get, "получает" возраст calcD(..) // calc, "вычисляет" дискриминант createForm(..) // create, "создает" форму diff --git a/1-js/2-first-steps/18-function-declaration-expression/article.md b/1-js/2-first-steps/18-function-declaration-expression/article.md index 18db5aeb..0853f01c 100644 --- a/1-js/2-first-steps/18-function-declaration-expression/article.md +++ b/1-js/2-first-steps/18-function-declaration-expression/article.md @@ -6,8 +6,8 @@ ```js //+ run -function sayHi() { - alert( "Привет" ); +function sayHi() { + alert( "Привет" ); } *!* @@ -20,7 +20,7 @@ alert( sayHi ); // выведет код функции **Функцию можно скопировать в другую переменную:** ```js -//+ run +//+ run no-beautify function sayHi() { // (1) alert( "Привет" ); } @@ -53,7 +53,7 @@ sayHi(); // ошибка (4) ```js //+ run var f = function(параметры) { - // тело функции + // тело функции }; ``` @@ -62,7 +62,7 @@ var f = function(параметры) { ```js //+ run var sayHi = function(person) { - alert("Привет, " + person); + alert( "Привет, " + person ); }; sayHi('Вася'); @@ -84,7 +84,7 @@ sayHi('Вася'); function sum(a, b) { return a + b; } - + // Function Expression var sum = function(a, b) { return a + b; @@ -104,7 +104,7 @@ sayHi("Вася"); // Привет, Вася */!* function sayHi(name) { - alert("Привет, " + name); + alert( "Привет, " + name ); } ``` @@ -113,11 +113,11 @@ function sayHi(name) { ```js //+ run *!* -sayHi("Вася"); // ошибка! +sayHi("Вася"); // ошибка! */!* var sayHi = function(name) { - alert("Привет, " + name); + alert( "Привет, " + name ); } ``` @@ -140,9 +140,13 @@ var sayHi = function(name) { var age = +prompt("Сколько вам лет?", 20); if (age >= 18) { - function sayHi() { alert('Прошу вас!'); } + function sayHi() { + alert( 'Прошу вас!' ); + } } else { - function sayHi() { alert('До 18 нельзя'); } + function sayHi() { + alert( 'До 18 нельзя' ); + } } sayHi(); @@ -158,19 +162,24 @@ sayHi();
  • Дальше, во время выполнения, объявления Function Declaration игнорируются (они уже были обработаны). Это как если бы код был таким: ```js -function sayHi() { alert('Прошу вас!'); } -function sayHi() { alert('До 18 нельзя'); } +function sayHi() { + alert( 'Прошу вас!' ); +} + +function sayHi() { + alert( 'До 18 нельзя' ); +} var age = 20; if (age >= 18) { - /* объявление было обработано ранее */ + /* объявление было обработано ранее */ } else { /* объявление было обработано ранее */ } *!* -sayHi(); // "До 18 нельзя", сработает всегда вторая функция +sayHi(); // "До 18 нельзя", сработает всегда вторая функция */!* ``` @@ -191,9 +200,13 @@ var age = prompt('Сколько вам лет?'); var sayHi; if (age >= 18) { - sayHi = function() { alert('Прошу Вас!'); } + sayHi = function() { + alert( 'Прошу Вас!' ); + } } else { - sayHi = function() { alert('До 18 нельзя'); } + sayHi = function() { + alert( 'До 18 нельзя' ); + } } sayHi(); @@ -202,7 +215,7 @@ sayHi(); Или даже так: ```js -//+ run +//+ run no-beautify var age = prompt('Сколько вам лет?'); var sayHi = (age >= 18) ? @@ -226,17 +239,17 @@ sayHi(); //+ run *!* function ask(question, yes, no) { - if (confirm(question)) yes() - else no(); -} + if (confirm(question)) yes() + else no(); + } */!* function showOk() { - alert("Вы согласились."); + alert( "Вы согласились." ); } function showCancel() { - alert("Вы отменили выполнение."); + alert( "Вы отменили выполнение." ); } // использование @@ -250,7 +263,7 @@ ask("Вы согласны?", showOk, showCancel); Здесь обратим внимание на то, что то же самое можно написать более коротко: ```js -//+ run +//+ run no-beautify function ask(question, yes, no) { if (confirm(question)) yes() else no(); @@ -283,8 +296,8 @@ ask( //+ run var sum = new Function('a,b', ' return a+b; '); -var result = sum(1,2); -alert(result); // 3 +var result = sum(1, 2); +alert( result ); // 3 ``` То есть, функция создаётся вызовом `new Function(params, code)`: @@ -340,6 +353,7 @@ alert(result); // 3 Сравните по читаемости: ```js +//+ no-beautify // Function Expression var f = function() { ... } diff --git a/1-js/2-first-steps/19-recursion/1-sum-to/solution.md b/1-js/2-first-steps/19-recursion/1-sum-to/solution.md index 4fba66fe..791c4b3d 100644 --- a/1-js/2-first-steps/19-recursion/1-sum-to/solution.md +++ b/1-js/2-first-steps/19-recursion/1-sum-to/solution.md @@ -4,7 +4,7 @@ //+ run function sumTo(n) { var sum = 0; - for(var i=1; i<=n; i++) { + for (var i = 1; i <= n; i++) { sum += i; } return sum; @@ -19,7 +19,7 @@ alert( sumTo(100) ); //+ run function sumTo(n) { if (n == 1) return 1; - return n + sumTo(n-1); + return n + sumTo(n - 1); } alert( sumTo(100) ); @@ -30,7 +30,7 @@ alert( sumTo(100) ); ```js //+ run function sumTo(n) { - return n*(n+1)/2; + return n * (n + 1) / 2; } alert( sumTo(100) ); diff --git a/1-js/2-first-steps/19-recursion/1-sum-to/task.md b/1-js/2-first-steps/19-recursion/1-sum-to/task.md index 0d122262..9e7e8e8f 100644 --- a/1-js/2-first-steps/19-recursion/1-sum-to/task.md +++ b/1-js/2-first-steps/19-recursion/1-sum-to/task.md @@ -5,6 +5,7 @@ Напишите функцию `sumTo(n)`, которая для данного `n` вычисляет сумму чисел от 1 до `n`, например: ```js +//+ no-beautify sumTo(1) = 1 sumTo(2) = 2 + 1 = 3 sumTo(3) = 3 + 2 + 1 = 6 diff --git a/1-js/2-first-steps/19-recursion/2-factorial/solution.md b/1-js/2-first-steps/19-recursion/2-factorial/solution.md index dcc08cc3..94e5db7c 100644 --- a/1-js/2-first-steps/19-recursion/2-factorial/solution.md +++ b/1-js/2-first-steps/19-recursion/2-factorial/solution.md @@ -5,7 +5,7 @@ ```js //+ run function factorial(n) { - return (n!=1) ? n*factorial(n-1) : 1; + return (n != 1) ? n * factorial(n - 1) : 1; } alert( factorial(5) ); // 120 @@ -16,7 +16,7 @@ alert( factorial(5) ); // 120 ```js //+ run function factorial(n) { - return n ? n*factorial(n-1) : 1; + return n ? n * factorial(n - 1) : 1; } alert( factorial(5) ); // 120 diff --git a/1-js/2-first-steps/19-recursion/2-factorial/task.md b/1-js/2-first-steps/19-recursion/2-factorial/task.md index 47ef048a..bacfa24b 100644 --- a/1-js/2-first-steps/19-recursion/2-factorial/task.md +++ b/1-js/2-first-steps/19-recursion/2-factorial/task.md @@ -7,17 +7,17 @@ Определение факториала можно записать как: ```js -n! = n*(n-1)*(n-2)*...*1 +n! = n * (n - 1) * (n - 2) * ...*1 ``` Примеры значений для разных `n`: ```js 1! = 1 -2! = 2*1 = 2 -3! = 3*2*1 = 6 -4! = 4*3*2*1 = 24 -5! = 5*4*3*2*1 = 120 +2! = 2 * 1 = 2 +3! = 3 * 2 * 1 = 6 +4! = 4 * 3 * 2 * 1 = 24 +5! = 5 * 4 * 3 * 2 * 1 = 120 ``` Задача -- написать функцию `factorial(n)`, которая возвращает факториал числа `n!`, используя рекурсивный вызов. diff --git a/1-js/2-first-steps/19-recursion/3-fibonacci-numbers/solution.md b/1-js/2-first-steps/19-recursion/3-fibonacci-numbers/solution.md index 4e6b2301..67afa2fe 100644 --- a/1-js/2-first-steps/19-recursion/3-fibonacci-numbers/solution.md +++ b/1-js/2-first-steps/19-recursion/3-fibonacci-numbers/solution.md @@ -5,7 +5,7 @@ ```js //+ run function fib(n) { - return n <= 1 ? n : fib(n-1) + fib(n-2); + return n <= 1 ? n : fib(n - 1) + fib(n - 2); } alert( fib(3) ); // 2 @@ -18,6 +18,7 @@ alert( fib(7) ); // 13 Это потому, что функция порождает обширное дерево вложенных вызовов. При этом ряд значений вычисляются много раз. Например, посмотрим на отрывок вычислений: ```js +//+ no-beautify ... fib(5) = fib(4) + fib(3) fib(4) = fib(3) + fib(2) @@ -35,6 +36,7 @@ fib(4) = fib(3) + fib(2) Будем идти по формуле слева-направо: ```js +//+ no-beautify var a = 1, b = 1; // начальные значения var c = a + b; // 2 @@ -47,6 +49,7 @@ a b c Теперь следующий шаг, присвоим `a` и `b` текущие 2 числа и получим новое следующее в `c`: ```js +//+ no-beautify a = b, b = c; c = a + b; @@ -59,6 +62,7 @@ c = a + b; Следующий шаг даст нам еще одно число последовательности: ```js +//+ no-beautify a = b, b = c; c = a + b; @@ -77,18 +81,19 @@ P.S. Этот подход к вычислению называется [дин ```js //+ run function fib(n) { - var a = 1, b = 1; + var a = 1, + b = 1; for (var i = 3; i <= n; i++) { var c = a + b; a = b; b = c; - } + } return b; } alert( fib(3) ); // 2 alert( fib(7) ); // 13 -alert( fib(77)); // 5527939700884757 +alert( fib(77) ); // 5527939700884757 ``` Цикл здесь начинается с `i=3`, так как первое и второе числа Фибоначчи заранее записаны в переменные `a=1`, `b=1`. \ No newline at end of file diff --git a/1-js/2-first-steps/19-recursion/3-fibonacci-numbers/task.md b/1-js/2-first-steps/19-recursion/3-fibonacci-numbers/task.md index a174a148..b05734a0 100644 --- a/1-js/2-first-steps/19-recursion/3-fibonacci-numbers/task.md +++ b/1-js/2-first-steps/19-recursion/3-fibonacci-numbers/task.md @@ -11,6 +11,7 @@ Напишите функцию `fib(n)`, которая возвращает `n-е` число Фибоначчи. Пример работы: ```js +//+ no-beautify function fib(n) { /* ваш код */ } alert( fib(3) ); // 2 diff --git a/1-js/2-first-steps/19-recursion/article.md b/1-js/2-first-steps/19-recursion/article.md index 89ec2e62..b57660a6 100644 --- a/1-js/2-first-steps/19-recursion/article.md +++ b/1-js/2-first-steps/19-recursion/article.md @@ -22,7 +22,7 @@ Её можно представить как совокупность более простого действия и более простой задачи того же типа вот так: ```js -pow(x, n) = x * pow(x, n-1) +pow(x, n) = x * pow(x, n - 1) ``` То есть, xn = x * xn-1. @@ -46,9 +46,9 @@ pow(x, n) = x * pow(x, n-1) //+ run function pow(x, n) { if (n != 1) { // пока n != 1, сводить вычисление pow(x,n) к pow(x,n-1) - return x * pow(x, n-1); - } else { - return x; + return x * pow(x, n - 1); + } else { + return x; } } @@ -85,10 +85,10 @@ alert( pow(2, 3) ); // 8 function pow(x, n) { if (n != 1) { // пока n != 1 сводить вычисление pow(x,n) к pow(x,n-1) *!* - return x * pow(x, n-1); + return x * pow(x, n - 1); */!* - } else { - return x; + } else { + return x; } } ``` @@ -109,14 +109,14 @@ function pow(x, n) { //+ run function pow(x, n) { if (n != 1) { // пока n!=1 сводить вычисление pow(..n) к pow(..n-1) - return x * pow(x, n-1); - } else { - return x; + return x * pow(x, n - 1); + } else { + return x; } } *!* -alert( pow(2, 3) ); // (*) +alert( pow(2, 3) ); // (*) */!* ``` @@ -154,11 +154,11 @@ alert( pow(2, 3) ); // (*) ```js function pow(x, n) { - if (n != 1) { - return x * pow(x, n-1); - } else { + if (n != 1) { + return x * pow(x, n - 1); + } else { *!* - return x; // первая степень числа равна самому числу + return x; // первая степень числа равна самому числу */!* } } @@ -194,7 +194,7 @@ function pow(x, n) { ```js function pow(x, n) { var result = x; - for(var i=1; i - alert("обычный скрипт"); + alert( "обычный скрипт" ); ``` diff --git a/1-js/2-first-steps/2-external-script/3-async-defer-inline-first/task.md b/1-js/2-first-steps/2-external-script/3-async-defer-inline-first/task.md index e4013123..612fbbae 100644 --- a/1-js/2-first-steps/2-external-script/3-async-defer-inline-first/task.md +++ b/1-js/2-first-steps/2-external-script/3-async-defer-inline-first/task.md @@ -11,7 +11,7 @@ ``` diff --git a/1-js/2-first-steps/2-external-script/article.md b/1-js/2-first-steps/2-external-script/article.md index 9c610d68..9a3567ed 100644 --- a/1-js/2-first-steps/2-external-script/article.md +++ b/1-js/2-first-steps/2-external-script/article.md @@ -53,7 +53,7 @@ ```html ``` @@ -69,24 +69,27 @@ + +

    Начинаем считать:

    *!* */!*

    Кролики посчитаны!

    + ``` diff --git a/1-js/2-first-steps/20-named-function-expression/1-nfe-check/solution.md b/1-js/2-first-steps/20-named-function-expression/1-nfe-check/solution.md index f8cb2fb5..5875fae8 100644 --- a/1-js/2-first-steps/20-named-function-expression/1-nfe-check/solution.md +++ b/1-js/2-first-steps/20-named-function-expression/1-nfe-check/solution.md @@ -1,7 +1,7 @@ **Первый код выведет `function ...`, второй -- ошибку во всех браузерах, кроме IE8-.** ```js -//+ run untrusted +//+ run untrusted no-beautify // обычное объявление функции (Function Declaration) function g() { return 1; }; @@ -11,7 +11,7 @@ alert(g); // функция Во втором коде скобки есть, значит функция внутри является не `Function Declaration`, а частью выражения, то есть `Named Function Expression`. Его имя видно только внутри, снаружи переменная `g` не определена. ```js -//+ run untrusted +//+ run untrusted no-beautify // Named Function Expression! (function g() { return 1; }); diff --git a/1-js/2-first-steps/20-named-function-expression/1-nfe-check/task.md b/1-js/2-first-steps/20-named-function-expression/1-nfe-check/task.md index 1e7deaa8..0510ff4d 100644 --- a/1-js/2-first-steps/20-named-function-expression/1-nfe-check/task.md +++ b/1-js/2-first-steps/20-named-function-expression/1-nfe-check/task.md @@ -5,6 +5,7 @@ Каков будет результат выполнения кода? ```js +//+ no-beautify function g() { return 1; } alert(g); @@ -13,6 +14,7 @@ alert(g); А такого? Будет ли разница, если да -- почему? ```js +//+ no-beautify (function g() { return 1; }); alert(g); diff --git a/1-js/2-first-steps/20-named-function-expression/article.md b/1-js/2-first-steps/20-named-function-expression/article.md index 9d4de04e..51ff860b 100644 --- a/1-js/2-first-steps/20-named-function-expression/article.md +++ b/1-js/2-first-steps/20-named-function-expression/article.md @@ -9,12 +9,13 @@ Обычное функциональное выражение: ```js -var f = function (...) { /* тело функции */ }; +var f = function(...) { /* тело функции */ }; ``` Именованное с именем `sayHi`: ```js +//+ no-beautify var f = function *!*sayHi*/!*(...) { /* тело функции */ }; ``` @@ -29,10 +30,10 @@ var f = function *!*sayHi*/!*(...) { /* тело функции */ }; ```js //+ run var f = function sayHi(name) { - alert(sayHi); // изнутри функции - видно (выведет код функции) + alert( sayHi ); // изнутри функции - видно (выведет код функции) }; -alert(sayHi); // снаружи - не видно (ошибка: undefined variable 'sayHi') +alert( sayHi ); // снаружи - не видно (ошибка: undefined variable 'sayHi') ``` Кроме того, имя NFE нельзя перезаписать: @@ -43,7 +44,7 @@ var test = function sayHi(name) { *!* sayHi = "тест"; // попытка перезаписи */!* - alert(sayHi); // function... (перезапись не удалась) + alert( sayHi ); // function... (перезапись не удалась) }; test(); @@ -63,8 +64,8 @@ NFE используется в первую очередь в тех ситуа ```js //+ run -function f(n) { - return n ? n*f(n-1) : 1; +function f(n) { + return n ? n * f(n - 1) : 1; }; alert( f(5) ); // 120 @@ -74,8 +75,8 @@ alert( f(5) ); // 120 ```js //+ run -function f(n) { - return n ? n*f(n-1) : 1; +function f(n) { + return n ? n * f(n - 1) : 1; }; *!* @@ -91,7 +92,7 @@ alert( g(5) ); // запуск функции с новым именем - ош Для того, чтобы функция всегда надёжно работала, объявим её как Named Function Expression: ```js -//+ run +//+ run no-beautify var f = function *!*factorial*/!*(n) { return n ? n**!*factorial*/!*(n-1) : 1; }; @@ -118,7 +119,7 @@ var f = function factorial(n) { /*...*/ }; // в IE8- false // в остальных браузерах ошибка, т.к. имя factorial не видно -alert(f === factorial); +alert( f === factorial ); ``` Все остальные браузеры полностью поддерживают именованные функциональные выражения. diff --git a/1-js/2-first-steps/21-javascript-specials/article.md b/1-js/2-first-steps/21-javascript-specials/article.md index 8b01bf72..467bb5c6 100644 --- a/1-js/2-first-steps/21-javascript-specials/article.md +++ b/1-js/2-first-steps/21-javascript-specials/article.md @@ -13,14 +13,14 @@ Операторы разделяются точкой с запятой: ```js -//+ run +//+ run no-beautify alert('Привет'); alert('Мир'); ``` Как правило, перевод строки тоже подразумевает точку с запятой. Так тоже будет работать: ```js -//+ run +//+ run no-beautify alert('Привет') alert('Мир') ``` @@ -28,7 +28,7 @@ alert('Мир') ...Однако, иногда JavaScript не вставляет точку с запятой. Например: ```js -//+ run +//+ run no-beautify var a = 2 +3 @@ -66,6 +66,7 @@ x = "Петя";
  • Есть 5 "примитивных" типов и объекты: ```js +//+ no-beautify x = 1; // число x = "Тест"; // строка, кавычки могут быть одинарные или двойные x = true; // булево значение true/false @@ -144,8 +145,8 @@ alert( x ); // undefined var userName = prompt("Введите имя?", "Василий"); var isTeaWanted = confirm("Вы хотите чаю?"); -alert( "Посетитель: " + userName); -alert( "Чай: " + isTeaWanted); +alert( "Посетитель: " + userName ); +alert( "Чай: " + isTeaWanted ); ``` Подробнее: [](/uibasic). @@ -159,7 +160,7 @@ alert( "Чай: " + isTeaWanted); ```js //+ run -alert( 1 + 2 ); // 3, число +alert( 1 + 2 ); // 3, число alert( '1' + 2 ); // '12', строка alert( 1 + '2' ); // '12', строка ``` @@ -172,7 +173,7 @@ alert( 1 + '2' ); // '12', строка ```js //+ run alert( 0 == false ); // true -alert( true > 0 ); // true +alert( true > 0 ); // true ``` Исключение -- сравнение двух строк (см. далее). @@ -188,7 +189,7 @@ alert( true > 0 ); // true Например, забавное следствие этих правил для `null`: ```js -//+ run +//+ run no-beautify alert( null > 0 ); // false, т.к. null преобразовано к 0 alert( null >= 0 ); // true, т.к. null преобразовано к 0 alert( null == 0 ); // false, в стандарте явно указано, что null равен лишь undefined @@ -205,7 +206,7 @@ alert( null == 0 ); // false, в стандарте явно указано, ч ```js //+ run -alert('а' > 'Я'); // true +alert( 'а' > 'Я' ); // true ```
    • @@ -243,14 +244,14 @@ alert( null || 1 || 2 ); // 1 ```js // 1 -while (условие) { +while (условие) { ... } // 2 -do { +do { ... -} while(условие); +} while (условие); // 3 for (var i = 0; i < 10; i++) { @@ -294,15 +295,15 @@ for(;;) { var age = prompt('Ваш возраст', 18); switch (age) { - case 18: - alert('Никогда не сработает'); // результат prompt - строка, а не число + case 18: + alert( 'Никогда не сработает' ); // результат prompt - строка, а не число - case "18": // вот так - сработает! - alert('Вам 18 лет!'); + case "18": // вот так - сработает! + alert( 'Вам 18 лет!' ); break; default: - alert('Любое значение, не совпавшее с case'); + alert( 'Любое значение, не совпавшее с case' ); } ``` @@ -333,7 +334,7 @@ alert( sum(1, 2) ); // 3
  • Функция без `return` считается возвращающей `undefined`. Вызов `return` без значения также возвращает `undefined`: ```js -//+ run +//+ run no-beautify function f() { } alert( f() ); // undefined ``` @@ -379,7 +380,7 @@ alert( sum(1, 2) ); // 3 ```js //+ run var factorial = function me(n) { - return (n == 1) ? n : n * me(n-1); + return (n == 1) ? n : n * me(n - 1); } alert( factorial(5) ); // 120 diff --git a/1-js/2-first-steps/3-structure/article.md b/1-js/2-first-steps/3-structure/article.md index c0376ffc..b9cfb3d4 100644 --- a/1-js/2-first-steps/3-structure/article.md +++ b/1-js/2-first-steps/3-structure/article.md @@ -11,14 +11,14 @@ Например, вместо одного вызова `alert` сделаем два: ```js -//+ run +//+ run no-beautify alert('Привет'); alert('Мир'); ``` Как правило, каждая команда пишется на отдельной строке -- так код лучше читается: ```js -//+ run +//+ run no-beautify alert('Привет'); alert('Мир'); ``` @@ -30,7 +30,7 @@ alert('Мир'); Так тоже будет работать: ```js -//+ run +//+ run no-beautify alert('Привет') alert('Мир') ``` @@ -42,7 +42,7 @@ alert('Мир') Например, запустите этот код: ```js -//+ run +//+ run no-beautify alert(3 + 1 + 2); @@ -69,7 +69,7 @@ alert(3 + Важно, что вот такой код уже работать не будет: ```js -//+ run +//+ run no-beautify alert("Сейчас будет ошибка") [1, 2].forEach(alert) ``` @@ -79,7 +79,7 @@ alert("Сейчас будет ошибка") Если её поставить, то всё будет в порядке: ```js //+ run -alert("Сейчас будет ошибка"); +alert( "Сейчас будет ошибка" ); [1, 2].forEach(alert) ``` @@ -96,9 +96,9 @@ alert("Сейчас будет ошибка"); ```js //+ run // Команда ниже говорит "Привет" -alert('Привет'); +alert( 'Привет' ); -alert('Мир'); // Второе сообщение выводим отдельно +alert( 'Мир' ); // Второе сообщение выводим отдельно ``` *Многострочные комментарии* начинаются слешем-звездочкой "/*" и заканчиваются звездочкой-слэшем "*/", вот так: @@ -108,8 +108,8 @@ alert('Мир'); // Второе сообщение выводим отдель /* Пример с двумя сообщениями. Это - многострочный комментарий. */ -alert('Привет'); -alert('Мир'); +alert( 'Привет' ); +alert( 'Мир' ); ``` Все содержимое комментария игнорируется. Если поместить код внутрь /* ... */ или после `//` -- он не выполнится. @@ -117,9 +117,9 @@ alert('Мир'); ```js //+ run /* Закомментировали код -alert('Привет'); +alert( 'Привет' ); */ -alert('Мир'); +alert( 'Мир' ); ``` [smart header="Используйте горячие клавиши!"] @@ -130,7 +130,7 @@ alert('Мир'); В этом коде будет ошибка: ```js -//+ run +//+ run no-beautify /* /* вложенный комментарий ?!? */ */ diff --git a/1-js/2-first-steps/5-variables/1-hello-variables/solution.md b/1-js/2-first-steps/5-variables/1-hello-variables/solution.md index 1eab8bc7..e81aff84 100644 --- a/1-js/2-first-steps/5-variables/1-hello-variables/solution.md +++ b/1-js/2-first-steps/5-variables/1-hello-variables/solution.md @@ -4,10 +4,10 @@ //+ run var admin, name; // две переменных через запятую -name = "Василий"; +name = "Василий"; admin = name; -alert(admin); // "Василий" +alert( admin ); // "Василий" ``` diff --git a/1-js/2-first-steps/5-variables/article.md b/1-js/2-first-steps/5-variables/article.md index 2138e339..d0e996b9 100644 --- a/1-js/2-first-steps/5-variables/article.md +++ b/1-js/2-first-steps/5-variables/article.md @@ -28,9 +28,9 @@ message = 'Hello'; // сохраним в переменной строку ```js //+ run var message; -message = 'Hello!'; +message = 'Hello!'; -alert(message); // выведет содержимое переменной +alert( message ); // выведет содержимое переменной ``` Для краткости можно совместить объявление переменной и запись данных: @@ -42,6 +42,7 @@ var message = 'Hello!'; Можно даже объявить несколько переменных сразу: ```js +//+ no-beautify var user = 'John', age = 25, message = 'Hello'; ``` @@ -59,11 +60,11 @@ var user = 'John', age = 25, message = 'Hello'; //+ run var message; -message = 'Hello!'; +message = 'Hello!'; -message = 'World!'; // заменили значение +message = 'World!'; // заменили значение -alert(message); +alert( message ); ``` При изменении значения старое содержимое переменной удаляется. @@ -83,8 +84,8 @@ var message; message = hello; */!* -alert(hello); // Hello world! -alert(message); // Hello world! +alert( hello ); // Hello world! +alert( message ); // Hello world! ``` [smart] @@ -114,15 +115,16 @@ var test123; ```js //+ run untrusted -var $ = 1; // объявили переменную с именем '$' +var $ = 1; // объявили переменную с именем '$' var _ = 2; // переменная с именем '_' -alert($ + _); // 3 +alert( $ + _ ); // 3 ``` А такие переменные были бы неправильными: ```js +//+ no-beautify var 1a; // начало не может быть цифрой var my-name; // дефис '-' не является разрешенным символом @@ -139,7 +141,7 @@ var my-name; // дефис '-' не является разрешенным си ```js //+ run var имя = "Вася"; -alert(имя); // "Вася" +alert( имя ); // "Вася" ``` Технически, ошибки здесь нет, но на практике сложилась традиция использовать в именах только английские буквы. @@ -152,7 +154,7 @@ alert(имя); // "Вася" Например, такой пример выдаст синтаксическую ошибку: ```js -//+ run +//+ run no-beautify var return = 5; // ошибка alert(return); ``` @@ -205,7 +207,7 @@ num = 5; // ошибки не будет, так как строгий режи *!* test = 5; // здесь будет ошибка! */!* - alert(test); // не сработает + alert( test ); // не сработает ``` @@ -230,7 +232,7 @@ var COLOR_BLUE = "#00F"; var COLOR_ORANGE = "#FF7F00"; var color = COLOR_ORANGE; -alert(color); // #FF7F00 +alert( color ); // #FF7F00 ``` Технически, константа является обычной переменной, то есть её *можно* изменить. Но мы *договариваемся* этого не делать. diff --git a/1-js/2-first-steps/6-variable-names/article.md b/1-js/2-first-steps/6-variable-names/article.md index a802c827..ceb5ab74 100644 --- a/1-js/2-first-steps/6-variable-names/article.md +++ b/1-js/2-first-steps/6-variable-names/article.md @@ -10,7 +10,9 @@ Что такое это "развитие"? Это когда я вчера написал код, а сегодня (или спустя неделю) прихожу и хочу его поменять. Например, вывести сообщение не так, а эдак... Обработать товары по-другому, добавить функционал.. А где у меня там сообщение хранится? А где товар?... -**Гораздо проще найти нужные данные, если они правильно помечены, то есть когда переменная названа *правильно*.** +Гораздо проще найти нужные данные, если они правильно помечены, то есть когда переменная названа *правильно*. + +## Правила именования -Позвольте поделиться одним небольшим секретом, который позволит улучшить ваши названия переменных и сэкономит вам время. +Позвольте поделиться одним небольшим секретом, который очень прост, но позволит улучшить названия переменных и сэкономит время. -Бывает так, что вы написали код, через некоторое время к нему возвращаетесь, и вам надо что-то поправить. Например, изменить какую-то рамку `border`... +Бывает так, что, написав код, мы через некоторое время к нему возвращаемся, надо что-то поправить. И мы примерно помним, что переменная, в которой хранится нужное вам значение, называется... Ну, скажем, `borderLeftWidth`. Мы ищем в её в коде, не находим, но, разобравшись, обнаруживаем, что на самом деле переменная называлась вот так: `leftBorderWidth`. -...И вы помните, что переменная, в которой хранится нужное вам значение, называется примерно так: `borderLeftWidth`. Вы ищете ее в коде, не находите, разбираетесь, и обнаруживаете, что на самом деле переменная называлась вот так: `leftBorderWidth`. После чего вносите нужные правки. +**Если мы ищем переменную с одним именем, а находим -- с другим, то зачастую самый лучший ход -- это *переименовать* переменную, чтобы имя было тем, которое вы искали.** -**Если вы искали переменную с одним именем, а нашли -- с другим, то самый лучший ход -- это *переименовать* переменную, чтобы имя было тем, которое вы искали.** - -То есть, у вас в коде `leftBorderWidth`, а вы ее переименовываете на `borderLeftWidth`. +То есть, в коде `leftBorderWidth`, а мы её переименуем на ту, которую искали: `borderLeftWidth`. Зачем? Дело в том, что в следующий раз, когда вы захотите что-то поправить, то вы будете искать по тому же самому имени. Соответственно, это сэкономит вам время. -Кроме того, поскольку именно это имя переменной пришло вам в голову -- скорее всего, оно больше соответствует хранимым там данным, чем то, которое вы придумали изначально. Исключения бывают, но в любом случае -- такое несовпадение -- это повод задуматься. +Есть причина и поважнее. Поскольку именно это имя переменной пришло в голову -- скорее всего, оно больше соответствует хранимым там данным, чем то, которое было мы придумали изначально. Исключения бывают, но в любом случае -- такое несовпадение -- это повод задуматься. + +Чтобы удобно переименовывать переменную, нужно использовать [хороший редактор JavaScript](/editors), тогда этот процесс будет очень простым и быстрым. [smart header="Если коротко..."] Смысл имени переменной -- это "имя на коробке", по которому мы сможем максимально быстро находить нужные нам данные. diff --git a/1-js/2-first-steps/7-types-intro/article.md b/1-js/2-first-steps/7-types-intro/article.md index 5bb17032..6f7a242c 100644 --- a/1-js/2-first-steps/7-types-intro/article.md +++ b/1-js/2-first-steps/7-types-intro/article.md @@ -57,6 +57,7 @@ str = 'Одинарные кавычки тоже подойдут'; Как правило, такой тип используется для хранения значения типа да/нет, например: ```js +//+ no-beautify var checked = true; // поле формы помечено галочкой checked = false; // поле формы не содержит галочки ``` @@ -84,7 +85,7 @@ var age = null; ```js //+ run var x; -alert(x); // выведет "undefined" +alert( x ); // выведет "undefined" ``` Можно присвоить `undefined` и в явном виде, хотя это делается редко: @@ -94,7 +95,7 @@ alert(x); // выведет "undefined" var x = 123; x = undefined; -alert(x); // "undefined" +alert( x ); // "undefined" ``` В явном виде `undefined` обычно не присваивают, так как это противоречит его смыслу. Для записи в переменную "пустого" или "неизвестного" значения используется `null`. diff --git a/1-js/2-first-steps/8-operators/1-increment-order/solution.md b/1-js/2-first-steps/8-operators/1-increment-order/solution.md index de103276..053e8d8d 100644 --- a/1-js/2-first-steps/8-operators/1-increment-order/solution.md +++ b/1-js/2-first-steps/8-operators/1-increment-order/solution.md @@ -1,7 +1,7 @@ # Разъяснения ```js -//+ run +//+ run no-beautify var a = 1, b = 1, c, d; // префиксная форма сначала увеличивает a до 2, а потом возвращает diff --git a/1-js/2-first-steps/8-operators/1-increment-order/task.md b/1-js/2-first-steps/8-operators/1-increment-order/task.md index 6489a2af..180d28eb 100644 --- a/1-js/2-first-steps/8-operators/1-increment-order/task.md +++ b/1-js/2-first-steps/8-operators/1-increment-order/task.md @@ -5,7 +5,7 @@ Посмотрите, понятно ли вам, почему код ниже работает именно так? ```js -//+ run +//+ run no-beautify var a = 1, b = 1, c, d; c = ++a; alert(c); // 2 diff --git a/1-js/2-first-steps/8-operators/article.md b/1-js/2-first-steps/8-operators/article.md index 3a8b7b69..fa8c1f59 100644 --- a/1-js/2-first-steps/8-operators/article.md +++ b/1-js/2-first-steps/8-operators/article.md @@ -24,14 +24,14 @@ var x = 1; *!* x = -x; */!* -alert( x ); // -1, применили унарный минус +alert( x ); // -1, применили унарный минус ```
  • *Бинарным* называется оператор, который применяется к двум операндам. Тот же минус существует и в бинарной форме: ```js -//+ run +//+ run no-beautify var x = 1, y = 3; alert( y - x ); // 2, бинарный минус ``` @@ -47,7 +47,7 @@ alert( y - x ); // 2, бинарный минус ```js var a = "моя" + "строка"; -alert(a); // моястрока +alert( a ); // моястрока ``` Иначе говорят, что "плюс производит конкатенацию (сложение) строк". @@ -71,7 +71,7 @@ alert( 2 + '1' ); // "21" ```js //+ run alert( 2 - '1' ); // 1 -alert( 6 / '2'); // 3 +alert( 6 / '2' ); // 3 ``` @@ -109,7 +109,7 @@ alert( apples + oranges ); // "23", так как бинарный плюс ск var apples = "2"; var oranges = "3"; -alert( +apples + +oranges); // 5, число, оба операнда предварительно преобразованы в числа +alert( +apples + +oranges ); // 5, число, оба операнда предварительно преобразованы в числа ``` С точки зрения математики такое изобилие плюсов может показаться странным. С точки зрения программирования -- никаких разночтений: сначала выполнятся унарные плюсы, приведут строки к числам, а затем -- бинарный `'+'` их сложит. @@ -152,7 +152,7 @@ alert( +apples + +oranges); // 5, число, оба операнда предв ```js var x = 2 * 2 + 1; -alert(x); // 5 +alert( x ); // 5 ``` **Возможно присваивание по цепочке:** @@ -165,9 +165,9 @@ var a, b, c; a = b = c = 2 + 2; */!* -alert(a); // 4 -alert(b); // 4 -alert(c); // 4 +alert( a ); // 4 +alert( b ); // 4 +alert( c ); // 4 ``` Такое присваивание работает справа-налево, то есть сначала вычислятся самое правое выражение `2+2`, присвоится в `c`, затем выполнится `b = c` и, наконец, `a = b`. @@ -186,8 +186,8 @@ var b = 2; var c = 3 - (a = b + 1); */!* -alert(a); // 3 -alert(c); // 0 +alert( a ); // 3 +alert( c ); // 0 ``` В примере выше результатом `(a = b + 1)` является значение, которое записывается в `a` (т.е. `3`). Оно используется для вычисления `c`. @@ -208,9 +208,9 @@ alert(c); // 0 ```js //+ run -alert(5 % 2); // 1, остаток от деления 5 на 2 -alert(8 % 3); // 2, остаток от деления 8 на 3 -alert(6 % 3); // 0, остаток от деления 6 на 3 +alert( 5 % 2 ); // 1, остаток от деления 5 на 2 +alert( 8 % 3 ); // 2, остаток от деления 8 на 3 +alert( 6 % 3 ); // 0, остаток от деления 6 на 3 ``` @@ -223,7 +223,7 @@ alert(6 % 3); // 0, остаток от деления 6 на 3
  • **Инкремент** `++` увеличивает на 1: ```js -//+ run +//+ run no-beautify var i = 2; i++; // более короткая запись для i = i + 1. alert(i); // 3 @@ -233,7 +233,7 @@ alert(i); // 3
  • **Декремент** `--` уменьшает на 1: ```js -//+ run +//+ run no-beautify var i = 2; i--; // более короткая запись для i = i - 1. alert(i); // 1 @@ -283,9 +283,9 @@ alert(a); // *!*1*/!* ```js //+ run var i = 0; -i++; -++i; -alert(i); // 2 +i++; +++i; +alert( i ); // 2 ```
    • @@ -366,7 +366,7 @@ i++; ```js var n = 2; -n = n + 5; +n = n + 5; n = n * 2; ``` @@ -378,7 +378,7 @@ var n = 2; n += 5; // теперь n=7 (работает как n = n + 5) n *= 2; // теперь n=14 (работает как n = n * 2) -alert(n); // 14 +alert( n ); // 14 ``` Так можно сделать для операторов `+,-,*,/` и бинарных `<<,>>,>>>,&,|,^`. @@ -388,9 +388,9 @@ alert(n); // 14 ```js //+ run var n = 2; -n *= 3 + 5; +n *= 3 + 5; -alert(n); // 16 (n = 2 * 8) +alert( n ); // 16 (n = 2 * 8) ``` @@ -406,7 +406,7 @@ alert(n); // 16 (n = 2 * 8) a = (5, 6); */!* -alert(a); +alert( a ); ``` Запятая позволяет перечислять выражения, разделяя их запятой `','`. Каждое из них -- вычисляется и отбрасывается, за исключением последнего, которое возвращается. diff --git a/1-js/2-first-steps/9-comparison/article.md b/1-js/2-first-steps/9-comparison/article.md index 92570cf8..2440ef6c 100644 --- a/1-js/2-first-steps/9-comparison/article.md +++ b/1-js/2-first-steps/9-comparison/article.md @@ -65,7 +65,7 @@ alert( 'Б' > 'А' ); // true ```js //+ run -alert('а' > 'Я'); // true, строчные буквы больше прописных +alert( 'а' > 'Я' ); // true, строчные буквы больше прописных ``` Для корректного сравнения символы должны быть в одинаковом регистре. @@ -137,7 +137,7 @@ alert( +"2" > +"14" ); // false, теперь правильно alert( '2' > 1 ); // true, сравнивается как 2 > 1 alert( '01' == 1 ); // true, сравнивается как 1 == 1 alert( false == 0 ); // true, false становится числом 0 -alert( true == 1); // true, так как true становится числом 1. +alert( true == 1 ); // true, так как true становится числом 1. ``` Тема преобразований типов будет продолжена далее, в главе [](/types-conversion). @@ -148,7 +148,7 @@ alert( true == 1); // true, так как true становится числом ```js //+ run -alert(0 == false); // true +alert( 0 == false ); // true ``` Та же ситуация с пустой строкой: @@ -156,7 +156,7 @@ alert(0 == false); // true ```js //+ run -alert('' == false); // true +alert( '' == false ); // true ``` Это естественное следствие того, что операнды разных типов преобразовались к числу. Пустая строка, как и `false`, при преобразовании к числу дают `0`. @@ -169,7 +169,7 @@ alert('' == false); // true ```js //+ run -alert(0 === false); // false, т.к. типы различны +alert( 0 === false ); // false, т.к. типы различны ``` Строгое сравнение предпочтительно, если мы хотим быть уверены, что "сюрпризов" не будет. @@ -195,8 +195,8 @@ alert(0 === false); // false, т.к. типы различны ```js //+ run -alert(null > 0); // false -alert(null == 0); // false +alert( null > 0 ); // false +alert( null == 0 ); // false ``` Итак, мы получили, что `null` не больше и не равен нулю. А теперь... @@ -220,9 +220,9 @@ alert(null >= 0); // *!*true*/!* ```js //+ run -alert(undefined > 0); // false (1) -alert(undefined < 0); // false (2) -alert(undefined == 0); // false (3) +alert( undefined > 0 ); // false (1) +alert( undefined < 0 ); // false (2) +alert( undefined == 0 ); // false (3) ``` ```js -var calculator = { - ... ваш код... +var calculator = { + ...ваш код... } calculator.read(); diff --git a/1-js/6-objects-more/1-object-methods/8-chain-calls/solution.md b/1-js/6-objects-more/1-object-methods/8-chain-calls/solution.md index d412c95e..8d89b88e 100644 --- a/1-js/6-objects-more/1-object-methods/8-chain-calls/solution.md +++ b/1-js/6-objects-more/1-object-methods/8-chain-calls/solution.md @@ -4,20 +4,20 @@ //+ run var ladder = { step: 0, - up: function() { - this.step++; + up: function() { + this.step++; return this; }, - down: function() { - this.step--; + down: function() { + this.step--; return this; }, - showStep: function() { - alert(this.step); + showStep: function() { + alert( this.step ); return this; } } -ladder.up().up().down().up().down().showStep(); // 1 +ladder.up().up().down().up().down().showStep(); // 1 ``` diff --git a/1-js/6-objects-more/1-object-methods/8-chain-calls/task.md b/1-js/6-objects-more/1-object-methods/8-chain-calls/task.md index 0fa9218a..fb2a512b 100644 --- a/1-js/6-objects-more/1-object-methods/8-chain-calls/task.md +++ b/1-js/6-objects-more/1-object-methods/8-chain-calls/task.md @@ -7,14 +7,14 @@ ```js var ladder = { step: 0, - up: function() { // вверх по лестнице + up: function() { // вверх по лестнице this.step++; }, - down: function() { // вниз по лестнице + down: function() { // вниз по лестнице this.step--; }, showStep: function() { // вывести текущую ступеньку - alert(this.step); + alert( this.step ); } }; ``` @@ -31,7 +31,7 @@ ladder.showStep(); // 1 Модифицируйте код методов объекта, чтобы вызовы можно было делать цепочкой, вот так: ```js -ladder.up().up().down().up().down().showStep(); // 1 +ladder.up().up().down().up().down().showStep(); // 1 ``` Такой подход называется "чейнинг" (chaining) и используется, например, во фреймворке jQuery. diff --git a/1-js/6-objects-more/1-object-methods/article.md b/1-js/6-objects-more/1-object-methods/article.md index 4741b3bc..4a70f595 100644 --- a/1-js/6-objects-more/1-object-methods/article.md +++ b/1-js/6-objects-more/1-object-methods/article.md @@ -16,7 +16,7 @@ var user = { // метод */!* sayHi: function() { - alert('Привет!'); + alert( 'Привет!' ); } }; @@ -101,7 +101,7 @@ admin.sayHi(); // упс! внутри sayHi обращение по старо Через `this` метод может не только обратиться к любому свойству объекта, но и передать куда-то ссылку на сам объект целиком: ```js -//+ run +//+ run no-beautify var user = { name: 'Василий', @@ -138,7 +138,7 @@ function sayHi() { **Если одну и ту же функцию запускать в контексте разных объектов, она будет получать разный `this`:** ```js -//+ run +//+ run no-beautify var user = { firstName: "Вася" }; var admin = { firstName: "Админ" }; @@ -169,8 +169,8 @@ admin['g'](); // Админ (не важно, доступ к объекту ч ```js //+ run -function func() { - alert(this); // выведет [object Window] или [object global] +function func() { + alert( this ); // выведет [object Window] или [object global] } func(); @@ -182,9 +182,9 @@ func(); ```js //+ run -function func() { +function func() { "use strict"; - alert(this); // выведет undefined (кроме IE9-) + alert( this ); // выведет undefined (кроме IE9-) } func(); @@ -199,7 +199,7 @@ func(); Любой более хитрый вызов приведёт к потере контекста, например: ```js -//+ run +//+ run no-beautify var user = { name: "Вася", hi: function() { alert(this.name); }, diff --git a/1-js/6-objects-more/2-object-conversion/1-array-equals-string/solution.md b/1-js/6-objects-more/2-object-conversion/1-array-equals-string/solution.md index a0c488b5..b7a70199 100644 --- a/1-js/6-objects-more/2-object-conversion/1-array-equals-string/solution.md +++ b/1-js/6-objects-more/2-object-conversion/1-array-equals-string/solution.md @@ -9,7 +9,7 @@ P.S. ```js //+ run -alert( ['x','y'] == 'x,y' ); // true +alert( ['x', 'y'] == 'x,y' ); // true alert( [] == '' ); // true ``` diff --git a/1-js/6-objects-more/2-object-conversion/2-tostring-valueof/task.md b/1-js/6-objects-more/2-object-conversion/2-tostring-valueof/task.md index 2785680a..86bd17cb 100644 --- a/1-js/6-objects-more/2-object-conversion/2-tostring-valueof/task.md +++ b/1-js/6-objects-more/2-object-conversion/2-tostring-valueof/task.md @@ -8,17 +8,17 @@ ```js var foo = { - toString: function () { - return 'foo'; - }, - valueOf: function () { - return 2; - } + toString: function() { + return 'foo'; + }, + valueOf: function() { + return 2; + } }; -alert(foo); -alert(foo + 1); -alert(foo + "3"); +alert( foo ); +alert( foo + 1 ); +alert( foo + "3" ); ``` Подумайте, прежде чем ответить. \ No newline at end of file diff --git a/1-js/6-objects-more/2-object-conversion/3-compare-empty-arrays/task.md b/1-js/6-objects-more/2-object-conversion/3-compare-empty-arrays/task.md index 3883d1ef..6945834b 100644 --- a/1-js/6-objects-more/2-object-conversion/3-compare-empty-arrays/task.md +++ b/1-js/6-objects-more/2-object-conversion/3-compare-empty-arrays/task.md @@ -6,7 +6,7 @@ ```js //+ run -alert( [] == [] ); // false +alert( [] == [] ); // false alert( [] == ![] ); // true ``` diff --git a/1-js/6-objects-more/2-object-conversion/4-object-types-conversion-questions/solution.md b/1-js/6-objects-more/2-object-conversion/4-object-types-conversion-questions/solution.md index 687ed94a..3d7c6689 100644 --- a/1-js/6-objects-more/2-object-conversion/4-object-types-conversion-questions/solution.md +++ b/1-js/6-objects-more/2-object-conversion/4-object-types-conversion-questions/solution.md @@ -1,6 +1,7 @@ ```js +//+ no-beautify new Date(0) - 0 = 0 // (1) new Array(1)[0] + "" = "undefined" // (2) ({})[0]
 = undefined // (3) @@ -24,6 +25,7 @@ new Array(1)[0] + "" = "undefined" // (2) Если это непонятно, то посмотрите на такой пример: ```js +//+ no-beautify alert( [1,[0],2][1] ); ``` diff --git a/1-js/6-objects-more/2-object-conversion/4-object-types-conversion-questions/task.md b/1-js/6-objects-more/2-object-conversion/4-object-types-conversion-questions/task.md index e85a68bc..85f767a5 100644 --- a/1-js/6-objects-more/2-object-conversion/4-object-types-conversion-questions/task.md +++ b/1-js/6-objects-more/2-object-conversion/4-object-types-conversion-questions/task.md @@ -5,6 +5,7 @@ Подумайте, какой результат будет у выражений ниже. Когда закончите -- сверьтесь с решением. ```js +//+ no-beautify new Date(0) - 0 new Array(1)[0] + "" ({})[0]
 diff --git a/1-js/6-objects-more/2-object-conversion/5-sum-many-brackets/solution.md b/1-js/6-objects-more/2-object-conversion/5-sum-many-brackets/solution.md index c670bd4d..4b36c185 100644 --- a/1-js/6-objects-more/2-object-conversion/5-sum-many-brackets/solution.md +++ b/1-js/6-objects-more/2-object-conversion/5-sum-many-brackets/solution.md @@ -13,23 +13,25 @@ ```js //+ run function sum(a) { - + var currentSum = a; - + function f(b) { currentSum += b; return f; } - - f.toString = function() { return currentSum; }; - + + f.toString = function() { + return currentSum; + }; + return f; } -alert( sum(1)(2) ); // 3 -alert( sum(5)(-1)(2) ); // 6 -alert( sum(6)(-1)(-2)(-3) ); // 0 -alert( sum(0)(1)(2)(3)(4)(5) ); // 15 +alert( sum(1)(2) ); // 3 +alert( sum(5)(-1)(2) ); // 6 +alert( sum(6)(-1)(-2)(-3) ); // 0 +alert( sum(0)(1)(2)(3)(4)(5) ); // 15 ``` При внимательном взгляде на решение легко заметить, что функция `sum` срабатывает только один раз. Она возвращает функцию `f`. diff --git a/1-js/6-objects-more/2-object-conversion/article.md b/1-js/6-objects-more/2-object-conversion/article.md index c5340406..9e52cbdd 100644 --- a/1-js/6-objects-more/2-object-conversion/article.md +++ b/1-js/6-objects-more/2-object-conversion/article.md @@ -22,8 +22,8 @@ ```js //+ run -if ( {} && [] ) { - alert("Все объекты - true!"); // alert сработает +if ({} && []) { + alert( "Все объекты - true!" ); // alert сработает } ``` @@ -33,11 +33,11 @@ if ( {} && [] ) { ```js //+ run -var user = { - firstName: 'Василий' +var user = { + firstName: 'Василий' }; -alert(user); // [object Object] +alert( user ); // [object Object] ``` Как видно, содержимое объекта не вывелось. Это потому, что стандартным строковым представлением пользовательского объекта является строка `"[object Object]"`. @@ -68,10 +68,12 @@ alert( user ); // Пользователь Василий ```js //+ run var obj = { - toString: function() { return 123; } + toString: function() { + return 123; + } }; -alert(obj); // 123 +alert( obj ); // 123 ``` Поэтому мы и называем его здесь *"строковое преобразование"*, а не "преобразование к строке". @@ -81,9 +83,9 @@ alert(obj); // 123 ```js //+ run -alert( [1,2] ); // toString для массивов выводит список элементов "1,2" +alert( [1, 2] ); // toString для массивов выводит список элементов "1,2" alert( new Date ); // toString для дат выводит дату в виде строки -alert( function() { } ); // toString для функции выводит её код +alert( function() {} ); // toString для функции выводит её код ``` ## Численное преобразование @@ -134,11 +136,13 @@ alert( +new Date() ); // valueOf: кол-во миллисекунд, проше ```js //+ run -var obj = { - valueOf: function() { return 1; } +var obj = { + valueOf: function() { + return 1; + } }; -alert(obj == true); // true +alert( obj == true ); // true ``` Объект `obj` был сначала преобразован в примитив, используя численное преобразование, получилось `1 == true`. @@ -149,25 +153,31 @@ alert(obj == true); // true ```js //+ run -var obj = { - valueOf: function() { return 1; } +var obj = { + valueOf: function() { + return 1; + } }; -alert(obj + "test"); // 1test +alert( obj + "test" ); // 1test ``` Или вот, для разности объектов: ```js //+ run -var a = { - valueOf: function() { return "1"; } +var a = { + valueOf: function() { + return "1"; + } }; -var b = { - valueOf: function() { return "2"; } +var b = { + valueOf: function() { + return "2"; + } }; -alert(a - b); // "1" - "2" = -1 +alert( a - b ); // "1" - "2" = -1 ``` [warn header="Исключение: `Date`"] @@ -194,9 +204,9 @@ alert( +new Date ); // число миллисекунд ```js //+ run -var value = new Boolean(false); -if ( value ) { - alert(true); // сработает! +var value = new Boolean(false); +if (value) { + alert( true ); // сработает! } ``` @@ -204,14 +214,14 @@ if ( value ) { ```js //+ run -var value = new Boolean(false); +var value = new Boolean(false); *!* -alert(value); // выводит false, все ок.. +alert( value ); // выводит false, все ок.. */!* -if ( value ) { - alert(true); // ..но тогда почему выполняется alert в if ?!? +if (value) { + alert( true ); // ..но тогда почему выполняется alert в if ?!? } ``` @@ -236,6 +246,7 @@ if ( value ) { Заметим, для полноты картины, что некоторые тесты знаний в интернет предлагают вопросы типа: ```js +//+ no-beautify {}[0] // чему равно? {} + {} // а так? ``` @@ -252,6 +263,7 @@ if ( value ) { А если команду изъять, то будет пустой блок `{}`, который ничего не делает. Два примера выше как раз содержат пустой блок в начале, который ничего не делает. Иначе говоря: ```js +//+ no-beautify {}[0] // то же что и: [0] {} + {} // то же что и: + {} ``` diff --git a/1-js/6-objects-more/3-constructor-new/1-two-functions-one-object/solution.md b/1-js/6-objects-more/3-constructor-new/1-two-functions-one-object/solution.md index 2dcc843b..5b27cec2 100644 --- a/1-js/6-objects-more/3-constructor-new/1-two-functions-one-object/solution.md +++ b/1-js/6-objects-more/3-constructor-new/1-two-functions-one-object/solution.md @@ -5,7 +5,7 @@ Например, они могут вернуть один и тот же объект `obj`, определённый снаружи: ```js -//+ run +//+ run no-beautify var obj = {}; function A() { return obj; } diff --git a/1-js/6-objects-more/3-constructor-new/1-two-functions-one-object/task.md b/1-js/6-objects-more/3-constructor-new/1-two-functions-one-object/task.md index a70741db..72c4e8eb 100644 --- a/1-js/6-objects-more/3-constructor-new/1-two-functions-one-object/task.md +++ b/1-js/6-objects-more/3-constructor-new/1-two-functions-one-object/task.md @@ -5,6 +5,7 @@ Возможны ли такие функции `A` и `B` в примере ниже, что соответствующие объекты `a,b` равны (см. код ниже)? ```js +//+ no-beautify function A() { ... } function B() { ... } diff --git a/1-js/6-objects-more/3-constructor-new/2-calculator-constructor/solution.md b/1-js/6-objects-more/3-constructor-new/2-calculator-constructor/solution.md index 41051702..a78010d9 100644 --- a/1-js/6-objects-more/3-constructor-new/2-calculator-constructor/solution.md +++ b/1-js/6-objects-more/3-constructor-new/2-calculator-constructor/solution.md @@ -5,7 +5,7 @@ function Calculator() { this.read = function() { - this.a = +prompt('a?', 0); + this.a = +prompt('a?', 0); this.b = +prompt('b?', 0); }; diff --git a/1-js/6-objects-more/3-constructor-new/4-calculator-extendable/solution.md b/1-js/6-objects-more/3-constructor-new/4-calculator-extendable/solution.md index 80b6a8a0..3e5f26e5 100644 --- a/1-js/6-objects-more/3-constructor-new/4-calculator-extendable/solution.md +++ b/1-js/6-objects-more/3-constructor-new/4-calculator-extendable/solution.md @@ -20,7 +20,7 @@ function Calculator() { op = split[1], b = +split[2] - if(!methods[op] || isNaN(a) || isNaN(b)) { + if (!methods[op] || isNaN(a) || isNaN(b)) { return NaN; } @@ -45,7 +45,7 @@ calc.addMethod("**", function(a, b) { }); var result = calc.calculate("2 ** 3"); -alert(result); // 8 +alert( result ); // 8 ```