jeena/en.javascript.info
1
0
Fork 0
Code Issues Pull requests Projects Packages Wiki Activity Actions

beautify 1st part of the tutorial

Browse source
This commit is contained in:
Ilya Kantor 2015-03-10 12:36:58 +03:00
parent e3dd2cedc0
commit 6444024a9d
327 changed files with 2358 additions and 1986 deletions
Download patch file Download diff file Expand all files Collapse all files

9
1-js/2-first-steps/1-hello-world/1-hello-alert/solution.md
View file

@ -4,16 +4,19 @@
<!--+ run -->
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
</head>
<body>
<script>
alert('Я - JavaScript!');
</script>
<script>
alert( 'Я - JavaScript!' );
</script>
</body>
</html>
```

7
1-js/2-first-steps/1-hello-world/article.md
View file

@ -16,23 +16,25 @@
<!--+ run height=100 -->
<!DOCTYPE HTML>
<html>
<head>
<!-- Тег meta для указания кодировки -->
<meta charset="utf-8">
</head>
<body>
<p>Начало документа...</p>
*!*
<script>
alert('Привет, Мир!');
alert( 'Привет, Мир!' );
</script>
*/!*
<p>...Конец документа</p>
</body>
</html>
```
@ -88,6 +90,7 @@
Выглядит это примерно так:
```html
<!--+ no-beautify -->
<script type="text/javascript"><!--
...
//--></script>

2
1-js/2-first-steps/10-bitwise-operators/4-bit-rounding/task.md
View file

@ -6,7 +6,7 @@
```js
//+ run
alert( 123456789 ^ 0 ); // 123456789
alert( 123456789 ^ 0 ); // 123456789
alert( 12345678912345 ^ 0 ); // 1942903641
```

40
1-js/2-first-steps/10-bitwise-operators/article.md
View file

@ -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` даст <code>2</code>:
```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( 'найдено!' );
}
```

13
1-js/2-first-steps/11-uibasic/1-simple-page/solution.md
View file

@ -3,7 +3,7 @@ JS-код:
```js
//+ demo run
var name = prompt("Ваше имя?", "");
alert(name);
alert( name );
```
Полная страница:
@ -11,17 +11,20 @@ alert(name);
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
</head>
<body>
<script>
var name = prompt("Ваше имя?", "");
alert(name);
</script>
<script>
var name = prompt("Ваше имя?", "");
alert( name );
</script>
</body>
</html>
```

5
1-js/2-first-steps/11-uibasic/article.md
View file

@ -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 );
```
## Особенности встроенных функций

2
1-js/2-first-steps/12-ifelse/1-if-zero-string/solution.md
View file

@ -7,7 +7,7 @@
```js
//+ run
if ("0") {
alert('Привет');
alert( 'Привет' );
}
```

2
1-js/2-first-steps/12-ifelse/1-if-zero-string/task.md
View file

@ -6,7 +6,7 @@
```js
if ("0") {
alert('Привет');
alert( 'Привет' );
}
```

8
1-js/2-first-steps/12-ifelse/3-sign/solution.md
View file

@ -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 );
}
```

18
1-js/2-first-steps/12-ifelse/4-check-login/solution.md
View file

@ -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( 'Я вас не знаю' );
}
```

32
1-js/2-first-steps/12-ifelse/article.md
View file

@ -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?', '');
*!*

2
1-js/2-first-steps/13-logical-ops/6-check-if-out-range/solution.md
View file

@ -1,7 +1,7 @@
Первый вариант:
```js
if ( !(age >= 14 && age <= 90) )
if (!(age >= 14 && age <= 90))
```
Второй вариант:

6
1-js/2-first-steps/13-logical-ops/7-if-question/solution.md
View file

@ -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( 'третье' );
```

6
1-js/2-first-steps/13-logical-ops/7-if-question/task.md
View file

@ -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( 'третье' );
```

73
1-js/2-first-steps/13-logical-ops/article.md
View file

@ -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
```

13
1-js/2-first-steps/14-types-conversion/1-primitive-conversions-questions/solution.md
View file

@ -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

11
1-js/2-first-steps/14-types-conversion/1-primitive-conversions-questions/task.md
View file

@ -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


26
1-js/2-first-steps/14-types-conversion/article.md
View file

@ -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
```
</li>
@ -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!" );
}
```

6
1-js/2-first-steps/15-while-for/1-loop-last-value/solution.md
View file

@ -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

4
1-js/2-first-steps/15-while-for/1-loop-last-value/task.md
View file

@ -7,8 +7,8 @@
```js
var i = 3;
while(i) {
alert(i--);
while (i) {
alert( i-- );
}
```

4
1-js/2-first-steps/15-while-for/2-which-value-while/solution.md
View file

@ -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`.

4
1-js/2-first-steps/15-while-for/2-which-value-while/task.md
View file

@ -8,7 +8,7 @@
```js
var i = 0;
while (++i < 5) alert(i);
while (++i < 5) alert( i );
```
</li>
@ -16,7 +16,7 @@ while (++i < 5) alert(i);
```js
var i = 0;
while (i++ < 5) alert(i);
while (i++ < 5) alert( i );
```
</li>

4
1-js/2-first-steps/15-while-for/3-which-value-for/solution.md
View file

@ -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`:

4
1-js/2-first-steps/15-while-for/3-which-value-for/task.md
View file

@ -7,14 +7,14 @@
<li>Постфиксная форма:
```js
for(var i=0; i<5; i++) alert(i);
for (var i = 0; i < 5; i++) alert( i );
```
</li>
<li>Префиксная форма:
```js
for(var i=0; i<5; ++i) alert(i);
for (var i = 0; i < 5; ++i) alert( i );
```
</li>

4
1-js/2-first-steps/15-while-for/4-for-even/solution.md
View file

@ -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 );
}
}
```

2
1-js/2-first-steps/15-while-for/5-replace-for-while/solution.md
View file

@ -4,7 +4,7 @@
//+ run
var i = 0;
while (i < 3) {
alert("номер " + i + "!");
alert( "номер " + i + "!" );
i++;
}
```

2
1-js/2-first-steps/15-while-for/5-replace-for-while/task.md
View file

@ -7,7 +7,7 @@
```js
//+ run
for (var i = 0; i < 3; i++) {
alert("номер " + i + "!");
alert( "номер " + i + "!" );
}
```

2
1-js/2-first-steps/15-while-for/6-repeat-until-correct/solution.md
View file

@ -6,7 +6,7 @@ var num;
do {
num = prompt("Введите число больше 100?", 0);
} while(num <= 100 && num != null);
} while (num <= 100 && num != null);
```
Цикл `do..while` повторяется, пока верны две проверки:

20
1-js/2-first-steps/15-while-for/7-list-primes/solution.md
View file

@ -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<i; j++) {
if ( i % j == 0) continue nextPrime;
for (var j = 2; j < i; j++) {
if (i % j == 0) continue nextPrime;
}
alert( i ); // простое
}
alert(i); // простое
}
```
Конечно же, его можно оптимизировать с точки зрения производительности. Например, проверять все `j` не от `2` до `i`, а от `2` до квадратного корня из `i`. А для очень больших чисел -- существуют более эффективные специализированные алгоритмы проверки простоты числа, например [квадратичное решето](http://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%BD%D0%BE%D0%B3%D0%BE_%D1%80%D0%B5%D1%88%D0%B5%D1%82%D0%B0) и [решето числового поля](http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%89%D0%B8%D0%B9_%D0%BC%D0%B5%D1%82%D0%BE%D0%B4_%D1%80%D0%B5%D1%88%D0%B5%D1%82%D0%B0_%D1%87%D0%B8%D1%81%D0%BB%D0%BE%D0%B2%D0%BE%D0%B3%D0%BE_%D0%BF%D0%BE%D0%BB%D1%8F).

45
1-js/2-first-steps/15-while-for/article.md
View file

@ -24,7 +24,7 @@ while (условие) {
//+ run
var i = 0;
while (i < 3) {
alert(i);
alert( i );
i++;
}
```
@ -49,7 +49,7 @@ var i = 3;
*!*
while (i) { // при i=0 значение в скобках будет false и цикл остановится
*/!*
alert(i);
alert( i );
i--;
}
```
@ -72,7 +72,7 @@ do {
//+ run
var i = 0;
do {
alert(i);
alert( i );
i++;
} while (i < 3);
```
@ -86,7 +86,7 @@ do {
```js
for (начало; условие; шаг) {
// ... тело цикла ...
// ... тело цикла ...
}
```
@ -96,8 +96,8 @@ for (начало; условие; шаг) {
//+ run
var i;
for (i=0; i<3; i++) {
alert(i);
for (i = 0; i < 3; i++) {
alert( i );
}
```
@ -125,7 +125,7 @@ for (i=0; i<3; i++) {
В цикле также можно определить переменную:
```js
//+ run
//+ run no-beautify
for (*!*var*/!* i=0; i<3; i++) {
alert(i); // 0, 1, 2
}
@ -144,8 +144,8 @@ for (*!*var*/!* i=0; i<3; i++) {
//+ run
var i = 0;
for (; i<3; i++) {
alert(i); // 0, 1, 2
for (; i < 3; i++) {
alert( i ); // 0, 1, 2
}
```
@ -155,16 +155,16 @@ for (; i<3; i++) {
//+ run
var i = 0;
for (; i<3;) {
alert(i);
// цикл превратился в аналог while (i<3)
for (; i < 3;) {
alert( i );
// цикл превратился в аналог while (i<3)
}
```
А можно и вообще убрать все, получив бесконечный цикл:
```js
for (;;) {
for (;;) {
// будет выполняться вечно
}
```
@ -187,8 +187,8 @@ for (;;) {
```js
var sum = 0;
while(true) {
while (true) {
var value = +prompt("Введите число", '');
*!*
@ -198,7 +198,7 @@ while(true) {
sum += value;
}
alert('Сумма: ' + sum);
alert( 'Сумма: ' + sum );
```
Директива `break` в строке `(*)`, если посетитель ничего не ввёл, полностью прекращает выполнение цикла и передаёт управление на строку за его телом, то есть на `alert`.
@ -216,7 +216,7 @@ alert('Сумма: ' + sum);
Например, цикл ниже использует `continue`, чтобы не выводить четные значения:
```js
//+ run
//+ run no-beautify
for (var i = 0; i < 10; i++) {
*!*if (i % 2 == 0) continue;*/!*
@ -233,9 +233,9 @@ for (var i = 0; i < 10; i++) {
```js
for (var i = 0; i < 10; i++) {
if (i % 2) {
alert(i);
if (i % 2) {
alert( i );
}
}
@ -274,6 +274,7 @@ if (условие) {
Поэтому такой код приведёт к ошибке:
```js
//+ no-beautify
(i > 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++) { ... }
```

1
1-js/2-first-steps/16-switch/1-rewrite-switch-if-else/solution.md
View file

@ -3,6 +3,7 @@
В реальном случае, скорее всего, подойдёт обычное сравнение `'=='`.
```js
//+ no-beautify
if(browser == 'IE') {
alert('О, да у вас IE!');
} else if (browser == 'Chrome'

8
1-js/2-first-steps/16-switch/1-rewrite-switch-if-else/task.md
View file

@ -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( 'Мы надеемся, что и в вашем браузере все ок!' );
}
```

8
1-js/2-first-steps/16-switch/2-rewrite-if-switch/solution.md
View file

@ -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;
*/!*

8
1-js/2-first-steps/16-switch/2-rewrite-if-switch/task.md
View file

@ -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' );
}
```

41
1-js/2-first-steps/16-switch/article.md
View file

@ -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)

2
1-js/2-first-steps/17-function-basics/4-pow/solution.md
View file

@ -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;
}

6
1-js/2-first-steps/17-function-basics/4-pow/task.md
View file

@ -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)`.

61
1-js/2-first-steps/17-function-basics/article.md
View file

@ -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`, которая будет возвращать дискриминант квадратного уравнения по формуле <code>b<sup>2</sup> - 4ac</code>:
```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, "создает" форму

66
1-js/2-first-steps/18-function-declaration-expression/article.md
View file

@ -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();
<li>Дальше, во время выполнения, объявления 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() { ... }

6
1-js/2-first-steps/19-recursion/1-sum-to/solution.md
View file

@ -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) );

1
1-js/2-first-steps/19-recursion/1-sum-to/task.md
View file

@ -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

4
1-js/2-first-steps/19-recursion/2-factorial/solution.md
View file

@ -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

10
1-js/2-first-steps/19-recursion/2-factorial/task.md
View file

@ -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!`, используя рекурсивный вызов.

13
1-js/2-first-steps/19-recursion/3-fibonacci-numbers/solution.md
View file

@ -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`.

1
1-js/2-first-steps/19-recursion/3-fibonacci-numbers/task.md
View file

@ -11,6 +11,7 @@
Напишите функцию `fib(n)`, которая возвращает `n-е` число Фибоначчи. Пример работы:
```js
//+ no-beautify
function fib(n) { /* ваш код */ }
alert( fib(3) ); // 2

32
1-js/2-first-steps/19-recursion/article.md
View file

@ -22,7 +22,7 @@
Её можно представить как совокупность более простого действия и более простой задачи того же типа вот так:
```js
pow(x, n) = x * pow(x, n-1)
pow(x, n) = x * pow(x, n - 1)
```
То есть, <code>x<sup>n</sup> = x * x<sup>n-1</sup></code>.
@ -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<n; i++) {
for (var i = 1; i < n; i++) {
result *= x;
}
return result;

2
1-js/2-first-steps/2-external-script/3-async-defer-inline-first/solution.md
View file

@ -4,7 +4,7 @@
```html
<script>
alert("обычный скрипт");
alert( "обычный скрипт" );
</script>
```

2
1-js/2-first-steps/2-external-script/3-async-defer-inline-first/task.md
View file

@ -11,7 +11,7 @@
<script async src="big.js"></script>
<script defer async>
alert("обычный скрипт");
alert( "обычный скрипт" );
</script>
```

11
1-js/2-first-steps/2-external-script/article.md
View file

@ -53,7 +53,7 @@
```html
<script src="file.js"></script>
<script>
alert(1);
alert( 1 );
</script>
```
@ -69,24 +69,27 @@
<!--+ run height=100 -->
<!DOCTYPE HTML>
<html>
<head>
<meta charset="utf-8">
</head>
<body>
<p>Начинаем считать:</p>
*!*
<script>
alert('Первый кролик!');
alert('Второй кролик!');
alert('Третий кролик!');
alert( 'Первый кролик!' );
alert( 'Второй кролик!' );
alert( 'Третий кролик!' );
</script>
*/!*
<p>Кролики посчитаны!</p>
</body>
</html>
```

4
1-js/2-first-steps/20-named-function-expression/1-nfe-check/solution.md
View file

@ -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; });

2
1-js/2-first-steps/20-named-function-expression/1-nfe-check/task.md
View file

@ -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);

21
1-js/2-first-steps/20-named-function-expression/article.md
View file

@ -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 );
```
Все остальные браузеры полностью поддерживают именованные функциональные выражения.

39
1-js/2-first-steps/21-javascript-specials/article.md
View file

@ -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 = "Петя";
<li>Есть 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
```
</li>
@ -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
<li>Функция без `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

26
1-js/2-first-steps/3-structure/article.md
View file

@ -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( 'Мир' ); // Второе сообщение выводим отдельно
```
*Многострочные комментарии* начинаются слешем-звездочкой <code>"/&#42;"</code> и заканчиваются звездочкой-слэшем <code>"&#42;/"</code>, вот так:
@ -108,8 +108,8 @@ alert('Мир'); // Второе сообщение выводим отдель
/* Пример с двумя сообщениями.
Это - многострочный комментарий.
*/
alert('Привет');
alert('Мир');
alert( 'Привет' );
alert( 'Мир' );
```
Все содержимое комментария игнорируется. Если поместить код внутрь <code>/&#42; ... &#42;/</code> или после `//` -- он не выполнится.
@ -117,9 +117,9 @@ alert('Мир');
```js
//+ run
/* Закомментировали код
alert('Привет');
alert( 'Привет' );
*/
alert('Мир');
alert( 'Мир' );
```
[smart header="Используйте горячие клавиши!"]
@ -130,7 +130,7 @@ alert('Мир');
В этом коде будет ошибка:
```js
//+ run
//+ run no-beautify
/*
/* вложенный комментарий ?!? */
*/

4
1-js/2-first-steps/5-variables/1-hello-variables/solution.md
View file

@ -4,10 +4,10 @@
//+ run
var admin, name; // две переменных через запятую
name = "Василий";
name = "Василий";
admin = name;
alert(admin); // "Василий"
alert( admin ); // "Василий"
```

28
1-js/2-first-steps/5-variables/article.md
View file

@ -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 ); // не сработает
</script>
```
@ -230,7 +232,7 @@ var COLOR_BLUE = "#00F";
var COLOR_ORANGE = "#FF7F00";
var color = COLOR_ORANGE;
alert(color); // #FF7F00
alert( color ); // #FF7F00
```
Технически, константа является обычной переменной, то есть её *можно* изменить. Но мы *договариваемся* этого не делать.

20
1-js/2-first-steps/6-variable-names/article.md
View file

@ -10,7 +10,9 @@
Что такое это "развитие"? Это когда я вчера написал код, а сегодня (или спустя неделю) прихожу и хочу его поменять. Например, вывести сообщение не так, а эдак... Обработать товары по-другому, добавить функционал.. А где у меня там сообщение хранится? А где товар?...
**Гораздо проще найти нужные данные, если они правильно помечены, то есть когда переменная названа *правильно*.**
Гораздо проще найти нужные данные, если они правильно помечены, то есть когда переменная названа *правильно*.
## Правила именования
<ul>
<li>**Правило 1.**
@ -28,7 +30,7 @@ var ssilka;
Подойдут:
```js
var myGoods;
var myGoods;
var price;
var link;
```
@ -81,19 +83,19 @@ var border_left_width;
</li>
</ul>
Позвольте поделиться одним небольшим секретом, который позволит улучшить ваши названия переменных и сэкономит вам время.
Позвольте поделиться одним небольшим секретом, который очень прост, но позволит улучшить названия переменных и сэкономит время.
Бывает так, что вы написали код, через некоторое время к нему возвращаетесь, и вам надо что-то поправить. Например, изменить какую-то рамку `border`...
Бывает так, что, написав код, мы через некоторое время к нему возвращаемся, надо что-то поправить. И мы примерно помним, что переменная, в которой хранится нужное вам значение, называется... Ну, скажем, `borderLeftWidth`. Мы ищем в её в коде, не находим, но, разобравшись, обнаруживаем, что на самом деле переменная называлась вот так: `leftBorderWidth`.
...И вы помните, что переменная, в которой хранится нужное вам значение, называется примерно так: `borderLeftWidth`. Вы ищете ее в коде, не находите, разбираетесь, и обнаруживаете, что на самом деле переменная называлась вот так: `leftBorderWidth`. После чего вносите нужные правки.
**Если мы ищем переменную с одним именем, а находим -- с другим, то зачастую самый лучший ход -- это *переименовать* переменную, чтобы имя было тем, которое вы искали.**
**Если вы искали переменную с одним именем, а нашли -- с другим, то самый лучший ход -- это *переименовать* переменную, чтобы имя было тем, которое вы искали.**
То есть, у вас в коде `leftBorderWidth`, а вы ее переименовываете на `borderLeftWidth`.
То есть, в коде `leftBorderWidth`, а мы её переименуем на ту, которую искали: `borderLeftWidth`.
Зачем? Дело в том, что в следующий раз, когда вы захотите что-то поправить, то вы будете искать по тому же самому имени. Соответственно, это сэкономит вам время.
Кроме того, поскольку именно это имя переменной пришло вам в голову -- скорее всего, оно больше соответствует хранимым там данным, чем то, которое вы придумали изначально. Исключения бывают, но в любом случае -- такое несовпадение -- это повод задуматься.
Есть причина и поважнее. Поскольку именно это имя переменной пришло в голову -- скорее всего, оно больше соответствует хранимым там данным, чем то, которое было мы придумали изначально. Исключения бывают, но в любом случае -- такое несовпадение -- это повод задуматься.
Чтобы удобно переименовывать переменную, нужно использовать [хороший редактор JavaScript](/editors), тогда этот процесс будет очень простым и быстрым.
[smart header="Если коротко..."]
Смысл имени переменной -- это "имя на коробке", по которому мы сможем максимально быстро находить нужные нам данные.

5
1-js/2-first-steps/7-types-intro/article.md
View file

@ -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`.

2
1-js/2-first-steps/8-operators/1-increment-order/solution.md
View file

@ -1,7 +1,7 @@
# Разъяснения
```js
//+ run
//+ run no-beautify
var a = 1, b = 1, c, d;
// префиксная форма сначала увеличивает a до 2, а потом возвращает

2
1-js/2-first-steps/8-operators/1-increment-order/task.md
View file

@ -5,7 +5,7 @@
Посмотрите, понятно ли вам, почему код ниже работает именно так?
```js
//+ run
//+ run no-beautify
var a = 1, b = 1, c, d;
c = ++a; alert(c); // 2

48
1-js/2-first-steps/8-operators/article.md
View file

@ -24,14 +24,14 @@ var x = 1;
*!*
x = -x;
*/!*
alert( x ); // -1, применили унарный минус
alert( x ); // -1, применили унарный минус
```
</li>
<li>*Бинарным* называется оператор, который применяется к двум операндам. Тот же минус существует и в бинарной форме:
```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
<li>**Инкремент** `++` увеличивает на 1:
```js
//+ run
//+ run no-beautify
var i = 2;
i++; // более короткая запись для i = i + 1.
alert(i); // 3
@ -233,7 +233,7 @@ alert(i); // 3
<li>**Декремент** `--` уменьшает на 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
```
</li>
@ -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 );
```
Запятая позволяет перечислять выражения, разделяя их запятой `','`. Каждое из них -- вычисляется и отбрасывается, за исключением последнего, которое возвращается.

20
1-js/2-first-steps/9-comparison/article.md
View file

@ -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)
```
<ul>

2
1-js/3-writing-js/1-debugging-chrome/article.md
View file

@ -185,7 +185,7 @@ function pow(x, n) {
```js
//+ run
// результат будет виден в консоли
for(var i=0; i<5; i++) {
for (var i = 0; i < 5; i++) {
console.log("значение", i);
}
```

11
1-js/3-writing-js/2-coding-style/1-style-errors/solution.md
View file

@ -3,6 +3,7 @@
Вы могли заметить следующие недостатки, сверху-вниз:
```js
//+ no-beautify
function pow(x,n) // <- отсутствует пробел между аргументами
{ // <- фигурная скобка на отдельной строке
var result=1; // <- нет пробелов вокруг знака =
@ -27,13 +28,13 @@ else // <- можно на одной строке } else {
Исправленный вариант:
```js
function pow(x, n) {
function pow(x, n) {
var result = 1;
for(var i = 0; i < n; i++) {
result *=x;
for (var i = 0; i < n; i++) {
result *= x;
}
return result;
}
@ -41,7 +42,7 @@ var x = prompt("x?", "");
var n = prompt("n?", "");
if (n < 0) {
alert('Степень ' + n +
alert('Степень ' + n +
'не поддерживается, введите целую степень, большую 0');
} else {
alert( pow(x, n) );

1
1-js/3-writing-js/2-coding-style/1-style-errors/task.md
View file

@ -5,6 +5,7 @@
Какие недостатки вы видите в стиле этого примера?
```js
//+ no-beautify
function pow(x,n)
{
var result=1;

34
1-js/3-writing-js/2-coding-style/article.md
View file

@ -12,7 +12,7 @@
<!--
```js
function pow(x, n) {
var result = 1;
var result = 1;
for (var i = 0; i < n; i++) {
result *= x;
@ -25,8 +25,8 @@ var x = prompt("x?", "");
var n = prompt("n?", "");
if (n < 0) {
alert('Степень ' + n +
'не поддерживается, введите целую степень, большую 0');
alert('Степень ' + n +
'не поддерживается, введите целую степень, большую 0');
} else {
alert( pow(x, n) );
}
@ -41,6 +41,7 @@ if (n < 0) {
<!--
```js
//+ no-beautify
if (n < 0) {alert('Степень ' + n + ' не поддерживается');}
@ -79,6 +80,7 @@ if (n < 0) {
Например, выровнять аргументы относительно открывающей скобки:
```js
//+ no-beautify
show("Строки" +
" выровнены" +
" строго" +
@ -91,15 +93,14 @@ show("Строки" +
```js
function pow(x, n) {
var result = 1;
var result = 1;
// <--
for (var i = 0; i < n; i++) {
result *=x;
result *= x;
}
// <--
return result;
}
```
Вставляйте дополнительный перевод строки туда, где это сделает код более читаемым. Не должно быть более 9 строк кода подряд без вертикального отступа.
@ -133,7 +134,7 @@ function pow(x, n) {
Вместо:
```js
for (var i=0; i<10; i++) {
for (var i = 0; i < 10; i++) {
if (i подходит) {
... // <- уровень вложенности 2
}
@ -158,7 +159,7 @@ function isEven(n) { // проверка чётности
if (n % 2 == 0) {
return true;
*!*
} else {
} else {
return false;
}
*/!*
@ -172,9 +173,9 @@ function isEven(n) { // проверка чётности
if (n % 2 == 0) {
return true;
}
*!*
return false;
return false;
*/!*
}
```
@ -187,7 +188,7 @@ function isEven(n) { // проверка чётности
```js
function isEven(n) { // проверка чётности
return !(n % 2);
return !(n % 2);
}
```
@ -209,14 +210,13 @@ function isEven(n) { // проверка чётности
```js
function showPrimes(n) {
nextPrime:
for (var i=2; i<n; i++) {
nextPrime: for (var i = 2; i < n; i++) {
for (var j=2; j<i; j++) {
if ( i % j == 0) continue nextPrime;
for (var j = 2; j < i; j++) {
if (i % j == 0) continue nextPrime;
}
alert(i); // простое
alert( i ); // простое
}
}
```

4
1-js/3-writing-js/3-write-unmain-code/article.md
View file

@ -62,7 +62,7 @@ div.append('<span/>');
```html
<div>
<img/>
<img/>
</div>
```
@ -92,7 +92,7 @@ div.append('<span/>');
```js
// код из jQuery
i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
```
Разработчик, встретивший эту строку и попытавшийся понять, чему же всё-таки равно `i`, скорее всего придёт к вам за разъяснениями. Смело скажите ему, что короче -- это всегда лучше. Посвятите и его в пути ниндзя. Не забудьте вручить [Дао дэ цзин](http://lib.ru/POECHIN/lao1.txt).

4
1-js/3-writing-js/4-testing/1-pow-nan-spec/solution.md
View file

@ -6,9 +6,9 @@ function pow(x, n) {
if (n < 0) return NaN;
if (Math.round(n) != n) return NaN;
*/!*
var result = 1;
for(var i=0; i<n; i++) {
for (var i = 0; i < n; i++) {
result *= x;
}
return result;

9
1-js/3-writing-js/4-testing/2-pow-test-0/solution.md
View file

@ -2,7 +2,7 @@
```js
it("любое число в степени 0 равно 1", function() {
assert.equal( pow(123, 0), 1);
assert.equal(pow(123, 0), 1);
});
```
@ -14,12 +14,12 @@ it("любое число в степени 0 равно 1", function() {
describe("любое число, кроме нуля, в степени 0 равно 1", function() {
function makeTest(x) {
it("при возведении " + x + " в степень 0 результат: 1", function() {
assert.equal( pow(x, 0), 1);
it("при возведении " + x + " в степень 0 результат: 1", function() {
assert.equal(pow(x, 0), 1);
});
}
for(var x = -5; x <= 5; x+=2) {
for (var x = -5; x <= 5; x += 2) {
makeTest(x);
}
@ -29,6 +29,7 @@ describe("любое число, кроме нуля, в степени 0 рав
И не забудем добавить отдельный тест для нуля:
```js
//+ no-beautify
...
it("ноль в нулевой степени даёт NaN", function() {
assert( isNaN(pow(0,0), "0 в степени 0 не NaN");

6
1-js/3-writing-js/4-testing/3-pow-test-wrong/solution.md
View file

@ -11,15 +11,15 @@
```js
describe("Возводит x в степень n", function() {
it("5 в степени 1 равно 5", function() {
assert.equal( pow(5, 1), 5 );
assert.equal(pow(5, 1), 5);
});
it("5 в степени 2 равно 25", function() {
assert.equal( pow(5, 2), 25 );
assert.equal(pow(5, 2), 25);
});
it("5 в степени 3 равно 125", function() {
assert.equal( pow(5, 3), 25 );
assert.equal(pow(5, 3), 25);
});
});
```

6
1-js/3-writing-js/4-testing/3-pow-test-wrong/task.md
View file

@ -9,13 +9,13 @@ it("Возводит x в степень n", function() {
var x = 5;
var result = x;
assert.equal( pow(x, 1), result );
assert.equal(pow(x, 1), result);
var result *= x;
assert.equal( pow(x, 2), result );
assert.equal(pow(x, 2), result);
var result *= x;
assert.equal( pow(x, 3), result );
assert.equal(pow(x, 3), result);
});
```

49
1-js/3-writing-js/4-testing/article.md
View file

@ -42,8 +42,8 @@ BDD -- это не просто тесты. Это гораздо больше.
```js
describe("pow", function() {
it("возводит в n-ю степень", function() {
assert.equal( pow(2, 3), 8);
it("возводит в n-ю степень", function() {
assert.equal(pow(2, 3), 8);
});
});
@ -121,7 +121,7 @@ describe("pow", function() {
```js
function pow() {
return 8; // :) мы - мошенники!
return 8; // :) мы - мошенники!
}
```
@ -149,10 +149,10 @@ function pow() {
```js
describe("pow", function() {
it("возводит в n-ю степень", function() {
assert.equal( pow(2, 3), 8);
it("возводит в n-ю степень", function() {
assert.equal(pow(2, 3), 8);
*!*
assert.equal( pow(3, 4), 81);
assert.equal(pow(3, 4), 81);
*/!*
});
@ -165,12 +165,12 @@ describe("pow", function() {
```js
describe("pow", function() {
it("при возведении 2 в 3ю степень результат 8", function() {
assert.equal( pow(2, 3), 8);
it("при возведении 2 в 3ю степень результат 8", function() {
assert.equal(pow(2, 3), 8);
});
it("при возведении 3 в 4ю степень равен 81", function() {
assert.equal( pow(3, 4), 81);
assert.equal(pow(3, 4), 81);
});
});
@ -204,10 +204,10 @@ describe("pow", function() {
function pow(x, n) {
var result = 1;
for(var i = 0; i < n; i++) {
for (var i = 0; i < n; i++) {
result *= x;
}
return result;
}
```
@ -218,13 +218,13 @@ function pow(x, n) {
describe("pow", function() {
function makeTest(x) {
var expected = x*x*x;
it("при возведении " + x + " в степень 3 результат: " + expected, function() {
assert.equal( pow(x, 3), expected);
var expected = x * x * x;
it("при возведении " + x + " в степень 3 результат: " + expected, function() {
assert.equal(pow(x, 3), expected);
});
}
for(var x = 1; x <= 5; x++) {
for (var x = 1; x <= 5; x++) {
makeTest(x);
}
@ -249,20 +249,20 @@ describe("pow", function() {
*/!*
function makeTest(x) {
var expected = x*x*x;
it("при возведении " + x + " в степень 3 результат: " + expected, function() {
assert.equal( pow(x, 3), expected);
var expected = x * x * x;
it("при возведении " + x + " в степень 3 результат: " + expected, function() {
assert.equal(pow(x, 3), expected);
});
}
for(var x = 1; x <= 5; x++) {
for (var x = 1; x <= 5; x++) {
makeTest(x);
}
*!*
});
*/!*
// ... дальнейшие тесты it и подблоки describe ...
});
```
@ -279,6 +279,7 @@ describe("pow", function() {
Например:
```js
//+ no-beautify
describe("Тест", function() {
before(function() { alert("Начало тестов"); });
@ -328,13 +329,13 @@ describe("pow", function() {
it("при возведении в отрицательную степень результат NaN", function() {
*!*
assert( isNaN( pow(2, -1) ) );
assert(isNaN(pow(2, -1)));
*/!*
});
it("при возведении в дробную степень результат NaN", function() {
*!*
assert( isNaN( pow(2, 1.5) ) );
assert(isNaN(pow(2, 1.5)));
*/!*
});
@ -385,13 +386,13 @@ describe("pow", function() {
it("при возведении в отрицательную степень результат NaN", function() {
*!*
assert( isNaN( pow(2, -1) ), "pow(2, -1) не NaN" );
assert(isNaN(pow(2, -1)), "pow(2, -1) не NaN");
*/!*
});
it("при возведении в дробную степень результат NaN", function() {
*!*
assert( isNaN( pow(2, 1.5) ), "pow(2, 1.5) не NaN" );
assert(isNaN(pow(2, 1.5)), "pow(2, 1.5) не NaN");
*/!*
});

8
1-js/4-data-structures/1-properties-and-methods/article.md
View file

@ -19,7 +19,7 @@ alert( "Привет, мир!".length ); // 12
```js
//+ run
var str = "Привет, мир!";
var str = "Привет, мир!";
alert( str.length ); // 12
```
@ -94,8 +94,8 @@ alert( 12.34.toFixed(1) ); // 12.3
...Но если число целое, то будет проблема:
```js
//+ run
alert( 12.toFixed(1) ); // ошибка!
//+ run no-beautify
alert(12.toFixed(1)); // ошибка!
```
Ошибка произойдёт потому, что JavaScript ожидает десятичную дробь после точки.
@ -115,4 +115,4 @@ alert( 12..toFixed(1) ); // 12.0
Почти все значения в JavaScript, кроме разве что `null` и `undefined` имеют их и предоставляют через них разный функционал.
Далее мы подробно разберём основные свойства и методы структур данных в JavaScript.
Далее мы подробно разберём основные свойства и методы структур данных в JavaScript.

2
1-js/4-data-structures/10-arguments-pseudoarray/1-check-arguments-undefined/solution.md
View file

@ -3,7 +3,7 @@
```js
//+ run
function f(x) {
alert(arguments.length ? 1 : 0);
alert( arguments.length ? 1 : 0 );
}
f(undefined);

2
1-js/4-data-structures/10-arguments-pseudoarray/1-check-arguments-undefined/task.md
View file

@ -5,7 +5,7 @@
Как в функции отличить отсутствующий аргумент от `undefined`?
```js
function f(x) {
function f(x) {
// ..ваш код..
// выведите 1, если первый аргумент есть, и 0 - если нет
}

2
1-js/4-data-structures/10-arguments-pseudoarray/2-sum-arguments/solution.md
View file

@ -5,7 +5,7 @@
function sum() {
var result = 0;
for(var i=0; i<arguments.length; i++) {
for (var i = 0; i < arguments.length; i++) {
result += arguments[i];
}

2
1-js/4-data-structures/10-arguments-pseudoarray/2-sum-arguments/task.md
View file

@ -8,7 +8,7 @@
sum() = 0
sum(1) = 1
sum(1, 2) = 3
sum(1, 2 ,3) = 6
sum(1, 2, 3) = 6
sum(1, 2, 3, 4) = 10
```

66
1-js/4-data-structures/10-arguments-pseudoarray/article.md
View file

@ -6,7 +6,7 @@
Например:
```js
//+ run
//+ run no-beautify
function go(a,b) {
alert("a="+a+", b="+b);
}
@ -25,13 +25,13 @@ function log(a) {
...
}
function log(a,b,c) {
function log(a, b, c) {
...
}
*!*
log(a); // вызовется первая функция
log(a,b,c); // вызовется вторая функция
log(a, b, c); // вызовется вторая функция
*/!*
```
@ -57,12 +57,12 @@ log(a,b,c); // вызовется вторая функция
```js
//+ run
function sayHi() {
for (var i=0; i<arguments.length; i++) {
alert("Привет, " + arguments[i]);
for (var i = 0; i < arguments.length; i++) {
alert( "Привет, " + arguments[i] );
}
}
sayHi("Винни", "Пятачок"); // 'Привет, Винни', 'Привет, Пятачок'
sayHi("Винни", "Пятачок"); // 'Привет, Винни', 'Привет, Пятачок'
```
Все параметры находятся в `arguments`, даже если они есть в списке. Код выше сработал бы также, будь функция объявлена `sayHi(a,b,c)`.
@ -80,8 +80,8 @@ sayHi("Винни", "Пятачок"); // 'Привет, Винни', 'Прив
//+ run
function f(x) {
arguments[0] = 5; // меняет переменную x
alert(x); // 5
}
alert( x ); // 5
}
f(1);
```
@ -91,9 +91,9 @@ f(1);
```js
//+ run
function f(x) {
x = 5;
alert(arguments[0]); // 5, обновленный x
}
x = 5;
alert( arguments[0] ); // 5, обновленный x
}
f(1);
```
@ -106,8 +106,8 @@ function f(x) {
"use strict"; // для браузеров с поддержкой строгого режима
arguments[0] = 5;
alert(x); // не 5, а 1! Переменная "отвязана" от arguments
}
alert( x ); // не 5, а 1! Переменная "отвязана" от arguments
}
f(1);
```
@ -137,7 +137,7 @@ sayHi(1);
```js
//+ run
var args = [];
for(var i=0; i<arguments.length; i++) {
for (var i = 0; i < arguments.length; i++) {
args[i] = arguments[i];
}
```
@ -169,7 +169,7 @@ var vasya = {
surname: 'Петров'
};
var user = {
var user = {
isAdmin: false,
isEmailConfirmed: true
};
@ -180,11 +180,11 @@ var student = {
// добавить к vasya свойства из user и student
*!*
copy(vasya, user, student);
copy(vasya, user, student);
*/!*
alert(vasya.isAdmin); // false
alert(vasya.university); // My university
alert( vasya.isAdmin ); // false
alert( vasya.university ); // My university
```
</li>
@ -207,7 +207,7 @@ var userClone = copy({}, user);
function copy() {
var dst = arguments[0];
for (var i=1; i<arguments.length; i++) {
for (var i = 1; i < arguments.length; i++) {
var arg = arguments[i];
for (var key in arg) {
dst[key] = arg[key];
@ -225,7 +225,7 @@ function copy() {
function copy(dst) {
*/!*
// остальные аргументы остаются безымянными
for (var i=1; i<arguments.length; i++) {
for (var i = 1; i < arguments.length; i++) {
var arg = arguments[i];
for (var key in arg) {
dst[key] = arg[key];
@ -248,7 +248,7 @@ function copy(dst) {
function showWarning(width, height, title, contents) {
width = width || 200; // если не указана width, то width = 200
height = height || 100; // если нет height, то height = 100
title = title || "Предупреждение";
title = title || "Предупреждение";
//...
}
@ -260,9 +260,9 @@ function showWarning(width, height, title, contents) {
```js
function showWarning(width, height, title, contents) {
if (width !== undefined) width = 200;
if (width !== undefined) width = 200;
if (height !== undefined) height = 100;
if (title !== undefined) title = "Предупреждение";
if (title !== undefined) title = "Предупреждение";
//...
}
@ -282,9 +282,9 @@ function showWarning(width, height, title, contents) {
```js
function showWarning(options) {
var width = options.width || 200; // по умолчанию
var width = options.width || 200; // по умолчанию
var height = options.height || 100;
var title = options.title || "Предупреждение";
// ...
@ -296,7 +296,7 @@ showWarning({
Вызвать такую функцию очень легко. Достаточно передать объект аргументов, указав в нем только нужные:
```js
showWarning({
showWarning({
contents: "Вы вызвали функцию" // и всё понятно!
});
```
@ -304,7 +304,7 @@ showWarning({
Сравним это с передачей аргументов через список:
```js
showWarning(null, null, "Предупреждение!");
showWarning(null, null, "Предупреждение!");
// мысль программиста "а что это за null, null в начале? ох, надо глядеть описание функции"
```
@ -315,13 +315,13 @@ showWarning(null, null, "Предупреждение!");
```js
var opts = {
width: 400,
height: 200,
height: 200,
contents: "Текст"
};
showWarning(opts);
opts.contents = "Другой текст";
opts.contents = "Другой текст";
*!*
showWarning(opts); // вызвать с новым текстом, без копирования других аргументов
@ -391,17 +391,17 @@ var factorial = function(n) {
f1();
function f1() {
alert(arguments.callee.caller); // null, меня вызвали из глобального кода
alert( arguments.callee.caller ); // null, меня вызвали из глобального кода
f2();
}
function f2() {
alert(arguments.callee.caller); // f1, функция, из которой меня вызвали
alert( arguments.callee.caller ); // f1, функция, из которой меня вызвали
f3();
}
function f3() {
alert(arguments.callee.caller); // f2, функция, из которой меня вызвали
alert( arguments.callee.caller ); // f2, функция, из которой меня вызвали
}
```

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

@ -5,6 +5,6 @@
```js
//+ run
var d = new Date(2012, 1, 20, 3, 12);
alert(d);
alert( d );
```

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

@ -5,12 +5,12 @@
```js
//+ run
function getWeekDay(date) {
var days = ['вс','пн','вт','ср','чт','пт','сб'] ;
var days = ['вс', 'пн', 'вт', 'ср', 'чт', 'пт', 'сб'];
return days[ date.getDay() ];
return days[date.getDay()];
}
var date = new Date(2014,0,3); // 3 января 2014
alert( getWeekDay(date) ); // 'пт'
var date = new Date(2014, 0, 3); // 3 января 2014
alert( getWeekDay(date) ); // 'пт'
```

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

@ -7,6 +7,7 @@
Например:
```js
//+ no-beautify
var date = new Date(2012,0,3); // 3 января 2012
alert( getWeekDay(date) ); // Должно вывести 'вт'
```

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

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

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

@ -7,6 +7,7 @@
День нужно возвратить в европейской нумерации, т.е. понедельник имеет номер 1, вторник номер 2, ..., воскресенье - номер 7.
```js
//+ no-beautify
var date = new Date(2012, 0, 3); // 3 янв 2012
alert( getLocalDay(date) ); // вторник, выведет 2
```

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

@ -2,8 +2,8 @@
```js
function getDateAgo(date, days) {
date.setDate( date.getDate() - days );
return date.getDate();
date.setDate(date.getDate() - days);
return date.getDate();
}
```
@ -15,9 +15,9 @@ function getDateAgo(date, days) {
//+ run
function getDateAgo(date, days) {
var dateCopy = new Date(date);
dateCopy.setDate( date.getDate() - days );
return dateCopy.getDate();
dateCopy.setDate(date.getDate() - days);
return dateCopy.getDate();
}
var date = new Date(2015, 0, 2);

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

@ -3,7 +3,7 @@
```js
//+ run
function getLastDayOfMonth(year, month) {
var date = new Date(year, month+1, 0);
var date = new Date(year, month + 1, 0);
return date.getDate();
}

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

@ -21,8 +21,8 @@ alert( getSecondsToday() );
```js
//+ run
function getSecondsToday(){
var d = new Date();
return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
function getSecondsToday() {
var d = new Date();
return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
};
```

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

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

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

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

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

@ -15,12 +15,12 @@
```js
function formatDate(date) { /* ваш код */ }
alert( formatDate( new Date(new Date - 1) ) ); // "только что"
alert( formatDate(new Date(new Date - 1)) ); // "только что"
alert( formatDate( new Date(new Date - 30*1000) ) ); // "30 сек. назад"
alert( formatDate(new Date(new Date - 30 * 1000)) ); // "30 сек. назад"
alert( formatDate( new Date(new Date- 5*60*1000) ) ); // "5 мин. назад"
alert( formatDate(new Date(new Date - 5 * 60 * 1000)) ); // "5 мин. назад"
alert( formatDate( new Date(new Date - 86400*1000) ) ); // вчерашняя дата в формате "дд.мм.гг чч:мм"
alert( formatDate(new Date(new Date - 86400 * 1000)) ); // вчерашняя дата в формате "дд.мм.гг чч:мм"
```

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

@ -13,7 +13,7 @@
```js
//+ run
var now = new Date();
alert(now);
alert( now );
```
</dd>
@ -23,7 +23,7 @@ alert(now);
```js
//+ run
// 24 часа после 01.01.1970 GMT+0
var Jan02_1970 = new Date(3600*24*1000);
var Jan02_1970 = new Date(3600 * 24 * 1000);
alert( Jan02_1970 );
```
@ -50,8 +50,8 @@ new Date(2011, 0, 1); // то же самое, часы/секунды по ум
```js
//+ run
var date = new Date(2011, 0, 1, 2, 3, 4, 567);
alert(date); // 1.01.2011, 02:03:04.567
var date = new Date(2011, 0, 1, 2, 3, 4, 567);
alert( date ); // 1.01.2011, 02:03:04.567
```
</dd>
@ -94,11 +94,11 @@ alert(date); // 1.01.2011, 02:03:04.567
var date = new Date();
// час в текущей временной зоне
alert( date.getHours() );
alert( date.getHours() );
// сколько сейчас времени в Лондоне?
// час в зоне GMT+0
alert( date.getUTCHours() );
alert( date.getUTCHours() );
```
Кроме описанных выше, существуют два специальных метода без UTC-варианта:
@ -111,7 +111,7 @@ alert( date.getUTCHours() );
```js
//+ run
alert( new Date().getTimezoneOffset() ); // Для GMT-1 выведет 60
alert( new Date().getTimezoneOffset() ); // Для GMT-1 выведет 60
```
</dd>
@ -141,11 +141,11 @@ alert( new Date().getTimezoneOffset() ); // Для GMT-1 выведет 60
//+ run
var today = new Date;
today.setHours(0);
today.setHours(0);
alert( today ); // сегодня, но час изменён на 0
today.setHours(0, 0, 0, 0);
alert (today ); // сегодня, ровно 00:00:00.
today.setHours(0, 0, 0, 0);
alert( today ); // сегодня, ровно 00:00:00.
```
### Автоисправление даты
@ -166,10 +166,10 @@ alert(d); // ... это 1 февраля 2013!
//+ run
var d = new Date(2011, 1, 28);
*!*
d.setDate( d.getDate() + 2 );
d.setDate(d.getDate() + 2);
*/!*
alert(d); // 2 марта, 2011
alert( d ); // 2 марта, 2011
```
Также это используют для получения даты, отдаленной от имеющейся на нужный промежуток времени. Например, получим дату на 70 секунд большую текущей:
@ -177,9 +177,9 @@ alert(d); // 2 марта, 2011
```js
//+ run
var d = new Date();
d.setSeconds( d.getSeconds()+70);
d.setSeconds(d.getSeconds() + 70);
alert(d); // выведет корректную дату
alert( d ); // выведет корректную дату
```
Можно установить и нулевые, и даже отрицательные компоненты. Например:
@ -189,10 +189,10 @@ alert(d); // выведет корректную дату
var d = new Date;
d.setDate(1); // поставить первое число месяца
alert(d);
alert( d );
d.setDate(0); // нулевого числа нет, будет последнее число предыдущего месяца
alert(d);
alert( d );
```
@ -202,7 +202,7 @@ alert(d);
var d = new Date;
d.setDate(-1); // предпоследнее число предыдущего месяца
alert(d);
alert( d );
```
### Преобразование к числу, разность дат
@ -211,7 +211,7 @@ alert(d);
```js
//+ run
alert( +new Date ) // +date то же самое, что: +date.valueOf()
alert(+new Date) // +date то же самое, что: +date.valueOf()
```
**Важный побочный эффект: даты можно вычитать, результат вычитания объектов `Date` -- их временная разница, в миллисекундах**.
@ -223,13 +223,13 @@ alert( +new Date ) // +date то же самое, что: +date.valueOf()
var start = new Date; // засекли время
// что-то сделать
for (var i=0; i<100000; i++) {
var doSomething = i*i*i;
for (var i = 0; i < 100000; i++) {
var doSomething = i * i * i;
}
var end = new Date; // конец измерения
alert("Цикл занял " + (end-start) + " ms");
alert( "Цикл занял " + (end - start) + " ms" );
```
### Бенчмаркинг
@ -242,11 +242,11 @@ alert("Цикл занял " + (end-start) + " ms");
```js
function walkIn(arr) {
for(var key in arr) arr[i]++
for (var key in arr) arr[i]++
}
function walkLength(arr) {
for(var i=0; i<arr.length; i++) arr[i]++;
for (var i = 0; i < arr.length; i++) arr[i]++;
}
```
@ -259,19 +259,24 @@ function walkLength(arr) {
```js
//+ run
var arr = [];
for(var i=0; i<1000; i++) arr[i] = 0;
for (var i = 0; i < 1000; i++) arr[i] = 0;
function walkIn(arr) { for(var key in arr) arr[i]++; }
function walkLength(arr) { for(var i=0; i<arr.length; i++) arr[i]++; }
function walkIn(arr) {
for (var key in arr) arr[i]++;
}
function walkLength(arr) {
for (var i = 0; i < arr.length; i++) arr[i]++;
}
function bench(f) {
var date = new Date();
for (var i=0; i<10000; i++) f(arr);
for (var i = 0; i < 10000; i++) f(arr);
return new Date() - date;
}
alert('Время walkIn: ' + bench(walkIn) + 'мс');
alert('Время walkLength: ' + bench(walkLength) + 'мс');
alert( 'Время walkIn: ' + bench(walkIn) + 'мс' );
alert( 'Время walkLength: ' + bench(walkLength) + 'мс' );
```
Теперь представим себе, что во время первого бенчмаркинга `bench(walkIn)` компьютер что-то делал параллельно важное (вдруг) и это занимало ресурсы, а во время второго -- перестал. Реальная ситуация? Конечно реальна, особенно на современных ОС, где много процессов одновременно.
@ -281,28 +286,34 @@ alert('Время walkLength: ' + bench(walkLength) + 'мс');
```js
//+ run
var arr = [];
for(var i=0; i<1000; i++) arr[i] = 0;
for (var i = 0; i < 1000; i++) arr[i] = 0;
function walkIn(arr) { for(var key in arr) arr[i]++; }
function walkLength(arr) { for(var i=0; i<arr.length; i++) arr[i]++; }
function walkIn(arr) {
for (var key in arr) arr[i]++;
}
function walkLength(arr) {
for (var i = 0; i < arr.length; i++) arr[i]++;
}
function bench(f) {
var date = new Date();
for (var i=0; i<1000; i++) f(arr);
for (var i = 0; i < 1000; i++) f(arr);
return new Date() - date;
}
*!*
// bench для каждого теста запустим много раз, чередуя
var timeIn = 0, timeLength = 0;
for(var i=0; i<100; i++) {
var timeIn = 0,
timeLength = 0;
for (var i = 0; i < 100; i++) {
timeIn += bench(walkIn);
timeLength += bench(walkLength);
}
*/!*
alert('Время walkIn: ' + timeIn + 'мс');
alert('Время walkLength: ' +timeLength + 'мс');
alert( 'Время walkIn: ' + timeIn + 'мс' );
alert( 'Время walkLength: ' + timeLength + 'мс' );
```
[smart header="Более точное время с `performance.now()`"]
@ -328,13 +339,18 @@ alert('Время walkLength: ' +timeLength + 'мс');
```js
//+ run
var arr = [];
for(var i=0; i<1000; i++) arr[i] = 0;
for (var i = 0; i < 1000; i++) arr[i] = 0;
function walkIn(arr) { for(var key in arr) arr[i]++; }
function walkLength(arr) { for(var i=0; i<arr.length; i++) arr[i]++; }
function walkIn(arr) {
for (var key in arr) arr[i]++;
}
function walkLength(arr) {
for (var i = 0; i < arr.length; i++) arr[i]++;
}
function bench(f) {
for (var i=0; i<10000; i++) f(arr);
for (var i = 0; i < 10000; i++) f(arr);
}
console.time("All Benchmarks");
@ -452,7 +468,7 @@ alert( d.toISOString() ); // вывод, похожий на '2011-01-26T13:51:5
//+ run
var msUTC = Date.parse('2012-01-26T13:51:50.417Z'); // зона UTC
alert(msUTC); // 1327571510417 (число миллисекунд)
alert( msUTC ); // 1327571510417 (число миллисекунд)
```
С таймзоной `-07:00 GMT`:
@ -461,7 +477,7 @@ alert(msUTC); // 1327571510417 (число миллисекунд)
//+ run
var ms = Date.parse('2012-01-26T13:51:50.417-07:00');
alert(ms); // 1327611110417 (число миллисекунд)
alert( ms ); // 1327611110417 (число миллисекунд)
```
@ -474,7 +490,7 @@ alert(ms); // 1327611110417 (число миллисекунд)
//+ run
var ms = Date.parse("January 26, 2011 13:51:50");
alert(ms);
alert( ms );
```
Вы также можете почитать о старых форматах IE в документации к методу <a href="http://msdn.microsoft.com/en-us/library/k4w173wk%28v=vs.85%29.aspx">MSDN Date.parse</a>.

30
1-js/4-data-structures/12-typeof-duck-typing/1-format-date-polymorphic/solution.md
View file

@ -4,10 +4,10 @@
```js
//+ run
alert(typeof 123); // "number"
alert(typeof "строка"); // "string"
alert(typeof new Date()); // "object"
alert(typeof []); // "object"
alert( typeof 123 ); // "number"
alert( typeof "строка" ); // "string"
alert( typeof new Date() ); // "object"
alert( typeof [] ); // "object"
```
Оператор `typeof` не умеет различать разные типы объектов, они для него все на одно лицо: `"object"`. Поэтому он не сможет отличить `Date` от `Array`.
@ -21,12 +21,12 @@ alert(typeof []); // "object"
function formatDate(date) {
if (typeof date == 'number') {
// перевести секунды в миллисекунды и преобразовать к Date
date = new Date(date*1000);
} else if(typeof date == 'string') {
date = new Date(date * 1000);
} else if (typeof date == 'string') {
// разобрать строку и преобразовать к Date
date = date.split('-');
date = new Date(date[0], date[1]-1, date[2]);
} else if ( date.length ) { // есть длина, но не строка - значит массив
date = new Date(date[0], date[1] - 1, date[2]);
} else if (date.length) { // есть длина, но не строка - значит массив
date = new Date(date[0], date[1], date[2]);
}
// преобразования для поддержки полиморфизма завершены,
@ -35,21 +35,21 @@ function formatDate(date) {
var day = date.getDate();
if (day < 10) day = '0' + day;
var month = date.getMonth()+1;
var month = date.getMonth() + 1;
if (month < 10) month = '0' + month;
// взять 2 последние цифры года
var year = date.getFullYear() % 100;
var year = date.getFullYear() % 100;
if (year < 10) year = '0' + year;
var formattedDate = day + '.' + month + '.' + year;
return formattedDate;
}
alert( formatDate( '2011-10-02' ) ); // 02.10.11
alert( formatDate( 1234567890 ) ); // 14.02.09
alert( formatDate( [2014,0,1] ) ); // 01.01.14
alert( formatDate( new Date(2014,0,1) ) ); // 01.01.14
alert( formatDate('2011-10-02') ); // 02.10.11
alert( formatDate(1234567890) ); // 14.02.09
alert( formatDate([2014, 0, 1]) ); // 01.01.14
alert( formatDate(new Date(2014, 0, 1)) ); // 01.01.14
```

8
1-js/4-data-structures/12-typeof-duck-typing/1-format-date-polymorphic/task.md
View file

@ -18,9 +18,9 @@
```js
function formatDate(date) { /* ваш код */ }
alert( formatDate( '2011-10-02' ) ); // 02.10.11
alert( formatDate( 1234567890 ) ); // 14.02.09
alert( formatDate( [2014,0,1] ) ); // 01.01.14
alert( formatDate( new Date(2014,0,1) ) ); // 01.01.14
alert( formatDate('2011-10-02') ); // 02.10.11
alert( formatDate(1234567890) ); // 14.02.09
alert( formatDate([2014, 0, 1]) ); // 01.01.14
alert( formatDate(new Date(2014, 0, 1)) ); // 01.01.14
```

18
1-js/4-data-structures/12-typeof-duck-typing/article.md
View file

@ -36,8 +36,8 @@
```js
typeof undefined // "undefined"
typeof 0 // "number"
typeof 0 // "number"
typeof true // "boolean"
typeof "foo" // "string"
@ -45,7 +45,7 @@ typeof "foo" // "string"
typeof {} // "object"
*!*
typeof null // "object"
typeof null // "object"
*/!*
function f() { /* ... */ }
@ -63,7 +63,7 @@ typeof f // "function"
```js
//+ run
var x = null;
x.prop = 1; // ошибка, т.к. нельзя присвоить свойство примитиву
x.prop = 1; // ошибка, т.к. нельзя присвоить свойство примитиву
```
</li>
@ -98,7 +98,7 @@ alert( typeof new Date ); // 'object'
var something = [1, 2, 3];
if (something.splice) {
alert('Это утка! То есть, массив!');
alert( 'Это утка! То есть, массив!' );
}
```
@ -111,7 +111,7 @@ if (something.splice) {
var x = new Date();
if (x.getTime) {
alert('Дата!');
alert( 'Дата!' );
}
```
@ -130,7 +130,7 @@ function sayHi(who) {
if (who.forEach) { // проверка на массив (или что-то похожее)
who.forEach(sayHi);
} else {
alert('Привет, ' + who);
alert( 'Привет, ' + who );
}
}
@ -138,10 +138,10 @@ function sayHi(who) {
sayHi("Вася"); // Привет, Вася
// Вызов с массивом
sayHi( ["Саша", "Петя"] ); // Привет, Саша... Петя
sayHi(["Саша", "Петя"]); // Привет, Саша... Петя
// Вызов с вложенными массивами
sayHi( ["Саша", "Петя", ["Маша", "Юля"] ] ); // Привет Саша..Петя..Маша..Юля
sayHi(["Саша", "Петя", ["Маша", "Юля"]]); // Привет Саша..Петя..Маша..Юля
```
Здесь вместо `splice` проверяется наличие `forEach`. Так надёжнее, поскольку именно его мы собираемся использовать.

2
1-js/4-data-structures/2-number/3-sum-prices/solution.md
View file

@ -4,7 +4,7 @@
<li>При операциях, когда необходимо получить окончательный результат -- округлять до 2го знака после запятой. Все, что дальше -- ошибка округления:
```js
//+ run
//+ run no-beautify
var price1 = 0.1, price2 = 0.2;
alert( +(price1 + price2).toFixed(2) );
```

4
1-js/4-data-structures/2-number/4-endless-loop-error/solution.md
View file

@ -5,9 +5,9 @@
```js
//+ run
var i = 0;
while(i < 11) {
while (i < 11) {
i += 0.2;
if (i>9.8 && i<10.2) alert(i);
if (i > 9.8 && i < 10.2) alert( i );
}
```

2
1-js/4-data-structures/2-number/4-endless-loop-error/task.md
View file

@ -6,7 +6,7 @@
```js
var i = 0;
while(i != 10) {
while (i != 10) {
i += 0.2;
}
```

2
1-js/4-data-structures/2-number/5-get-decimal/solution.md
View file

@ -72,7 +72,7 @@ function getDecimal(num) {
var str = "" + num;
var zeroPos = str.indexOf(".");
if (zeroPos == -1) return 0;
str = str.slice( zeroPos );
str = str.slice(zeroPos);
return +str;
}

14
1-js/4-data-structures/2-number/6-formula-binet/solution.md
View file

@ -5,13 +5,15 @@
function fibBinet(n) {
var phi = (1 + Math.sqrt(5)) / 2;
// используем Math.round для округления до ближайшего целого
return Math.round( Math.pow(phi, n) / Math.sqrt(5) );
return Math.round(Math.pow(phi, n) / Math.sqrt(5));
}
function fib(n){
var a=1, b=0, x;
for(i=0; i<n; i++) {
x = a+b;
function fib(n) {
var a = 1,
b = 0,
x;
for (i = 0; i < n; i++) {
x = a + b;
a = b
b = x;
}
@ -21,7 +23,7 @@ function fib(n){
alert( fibBinet(2) ); // 1, равно fib(2)
alert( fibBinet(8) ); // 21, равно fib(8)
*!*
alert( fibBinet(77)); // 5527939700884755
alert( fibBinet(77) ); // 5527939700884755
alert( fib(77) ); // 5527939700884757, не совпадает!
*/!*
```

10
1-js/4-data-structures/2-number/6-formula-binet/task.md
View file

@ -9,10 +9,12 @@
Код для их вычисления (из задачи [](/task/fibonacci-numbers)):
```js
function fib(n){
var a=1, b=0, x;
for(i=0; i<n; i++) {
x = a+b;
function fib(n) {
var a = 1,
b = 0,
x;
for (i = 0; i < n; i++) {
x = a + b;
a = b
b = x;
}

2
1-js/4-data-structures/2-number/7-random-0-max/solution.md
View file

@ -4,6 +4,6 @@
//+ run
var max = 10;
alert( Math.random()*max );
alert( Math.random() * max );
```

Some files were not shown because too many files have changed in this diff Show more