beautify 1st part of the tutorial
This commit is contained in:
Ilya Kantor
parent
e3dd2cedc0
commit
6444024a9d
327 changed files with 2358 additions and 1986 deletions
|
|
@ -4,7 +4,7 @@
|
|||
<li>При операциях, когда необходимо получить окончательный результат -- округлять до 2го знака после запятой. Все, что дальше -- ошибка округления:
|
||||
|
||||
```js
|
||||
//+ run
|
||||
//+ run no-beautify
|
||||
var price1 = 0.1, price2 = 0.2;
|
||||
alert( +(price1 + price2).toFixed(2) );
|
||||
```
|
||||
|
|
|
|||
|
|
@ -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 );
|
||||
}
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
```js
|
||||
var i = 0;
|
||||
while(i != 10) {
|
||||
while (i != 10) {
|
||||
i += 0.2;
|
||||
}
|
||||
```
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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, не совпадает!
|
||||
*/!*
|
||||
```
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,6 +4,6 @@
|
|||
//+ run
|
||||
var max = 10;
|
||||
|
||||
alert( Math.random()*max );
|
||||
alert( Math.random() * max );
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -2,8 +2,9 @@
|
|||
|
||||
```js
|
||||
//+ run
|
||||
var min=5, max = 10;
|
||||
var min = 5,
|
||||
max = 10;
|
||||
|
||||
alert( min + Math.random()*(max-min) );
|
||||
alert( min + Math.random() * (max - min) );
|
||||
```
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
```js
|
||||
//+ run
|
||||
function randomInteger(min, max) {
|
||||
var rand = min + Math.random()*(max-min)
|
||||
var rand = min + Math.random() * (max - min)
|
||||
rand = Math.round(rand);
|
||||
return rand;
|
||||
}
|
||||
|
|
@ -20,6 +20,7 @@ alert( randomInteger(1, 3) );
|
|||
Это происходит из-за того, что `Math.round()` получает разнообразные случайные числа из интервала от `1` до `3`, но при округлении до ближайшего целого получится, что:
|
||||
|
||||
```js
|
||||
//+ no-beautify
|
||||
значения из диапазона 1 ... 1.49999.. станут 1
|
||||
значения из диапазона 1.5 ... 2.49999.. станут 2
|
||||
значения из диапазона 2.5 ... 2.99999.. станут 3
|
||||
|
|
@ -35,10 +36,10 @@ alert( randomInteger(1, 3) );
|
|||
//+ run
|
||||
*!*
|
||||
function randomInteger(min, max) {
|
||||
var rand = min - 0.5 + Math.random()*(max-min+1)
|
||||
rand = Math.round(rand);
|
||||
return rand;
|
||||
}
|
||||
var rand = min - 0.5 + Math.random() * (max - min + 1)
|
||||
rand = Math.round(rand);
|
||||
return rand;
|
||||
}
|
||||
*/!*
|
||||
|
||||
alert( randomInteger(5, 10) );
|
||||
|
|
@ -55,6 +56,7 @@ alert( randomInteger(5, 10) );
|
|||
Тогда `Math.floor()` округлит их так:
|
||||
|
||||
```js
|
||||
//+ no-beautify
|
||||
1 ... 1.999+ станет 1
|
||||
2 ... 2.999+ станет 2
|
||||
3 ... 3.999+ станет 3
|
||||
|
|
@ -67,10 +69,10 @@ alert( randomInteger(5, 10) );
|
|||
//+ run
|
||||
*!*
|
||||
function randomInteger(min, max) {
|
||||
var rand = min + Math.random() * (max+1-min);
|
||||
rand = Math.floor(rand);
|
||||
return rand;
|
||||
}
|
||||
var rand = min + Math.random() * (max + 1 - min);
|
||||
rand = Math.floor(rand);
|
||||
return rand;
|
||||
}
|
||||
*/!*
|
||||
|
||||
alert( randomInteger(5, 10) );
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ alert( 010 ); // 8 в восьмеричной системе
|
|||
```js
|
||||
//+ run
|
||||
// еще пример научной формы: 3 с 5 нулями
|
||||
alert( 3e5 ); // 300000
|
||||
alert( 3e5 ); // 300000
|
||||
```
|
||||
|
||||
Если количество нулей отрицательно, то число сдвигается вправо за десятичную точку, так что получается десятичная дробь:
|
||||
|
|
@ -44,8 +44,8 @@ alert( 3e-5 ); // 0.00003 <-- 5 нулей, включая начальный
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert(1/0); // Infinity
|
||||
alert(12345/0); // Infinity
|
||||
alert( 1 / 0 ); // Infinity
|
||||
alert( 12345 / 0 ); // Infinity
|
||||
```
|
||||
|
||||
**`Infinity` -- особенное численное значение, которое ведет себя в точности как математическая бесконечность `∞`.**
|
||||
|
|
@ -56,8 +56,8 @@ alert(12345/0); // Infinity
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert(Infinity > 1234567890); // true
|
||||
alert(Infinity + 5 == Infinity); // true
|
||||
alert( Infinity > 1234567890 ); // true
|
||||
alert( Infinity + 5 == Infinity ); // true
|
||||
```
|
||||
|
||||
**Бесконечность можно присвоить и в явном виде: `var x = Infinity`.**
|
||||
|
|
@ -84,7 +84,7 @@ alert( 1e500 ); // Infinity
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert( 0 / 0 ); // NaN
|
||||
alert( 0 / 0 ); // NaN
|
||||
```
|
||||
|
||||
Значение `NaN` используется для обозначения математической ошибки и обладает следующими свойствами:
|
||||
|
|
@ -96,8 +96,8 @@ alert( 0 / 0 ); // NaN
|
|||
|
||||
```js
|
||||
//+ run
|
||||
if (NaN == NaN) alert("=="); // Ни один вызов
|
||||
if (NaN === NaN) alert("==="); // не сработает
|
||||
if (NaN == NaN) alert( "==" ); // Ни один вызов
|
||||
if (NaN === NaN) alert( "===" ); // не сработает
|
||||
```
|
||||
|
||||
</li>
|
||||
|
|
@ -105,7 +105,7 @@ if (NaN === NaN) alert("==="); // не сработает
|
|||
|
||||
```js
|
||||
//+ run
|
||||
var n = 0/0;
|
||||
var n = 0 / 0;
|
||||
|
||||
alert( isNaN(n) ); // true
|
||||
```
|
||||
|
|
@ -115,9 +115,9 @@ alert( isNaN(n) ); // true
|
|||
|
||||
```js
|
||||
//+ run
|
||||
var n = 0/0;
|
||||
var n = 0 / 0;
|
||||
|
||||
if (n !== n) alert('n = NaN!');
|
||||
if (n !== n) alert( 'n = NaN!' );
|
||||
```
|
||||
|
||||
Это работает, но для наглядности лучше использовать `isNaN(n)`.
|
||||
|
|
@ -156,7 +156,7 @@ var value = prompt("Введите Infinity", 'Infinity');
|
|||
var number = +value;
|
||||
*/!*
|
||||
|
||||
alert(number); // Infinity, плюс преобразовал строку "Infinity" к такому "числу"
|
||||
alert( number ); // Infinity, плюс преобразовал строку "Infinity" к такому "числу"
|
||||
```
|
||||
|
||||
Обычно если мы хотим от посетителя получить число, то `Infinity` или `NaN` нам не подходят. Для того, чтобы отличить "обычные" числа от таких специальных значений, существует функция `isFinite`.
|
||||
|
|
@ -178,23 +178,23 @@ alert( isFinite(NaN) ); // false
|
|||
|
||||
```js
|
||||
//+ run
|
||||
var s = "12.34";
|
||||
alert( +s ); // 12.34
|
||||
var s = "12.34";
|
||||
alert( +s ); // 12.34
|
||||
```
|
||||
|
||||
При этом, если строка не является в точности числом, то результат будет `NaN`:
|
||||
|
||||
```js
|
||||
//+ run
|
||||
alert( +"12test" ); // NaN
|
||||
alert( +"12test" ); // NaN
|
||||
```
|
||||
|
||||
Единственное исключение -- пробельные символы в начале и в конце строки, которые игнорируются:
|
||||
|
||||
```js
|
||||
//+ run
|
||||
alert( +" -12"); // -12
|
||||
alert( +" \n34 \n"); // 34, перевод строки \n является пробельным символом
|
||||
alert( +" -12" ); // -12
|
||||
alert( +" \n34 \n" ); // 34, перевод строки \n является пробельным символом
|
||||
alert( +"" ); // 0, пустая строка становится нулем
|
||||
alert( +"1 2" ); // NaN, пробел посередине числа - ошибка
|
||||
```
|
||||
|
|
@ -203,7 +203,7 @@ alert( +"1 2" ); // NaN, пробел посередине числа - ошиб
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert( '12.34' / "-2" ); // -6.17
|
||||
alert( '12.34' / "-2" ); // -6.17
|
||||
```
|
||||
|
||||
## Мягкое преобразование: parseInt и parseFloat
|
||||
|
|
@ -214,7 +214,7 @@ alert( '12.34' / "-2" ); // -6.17
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert( +"12px" ) // NaN
|
||||
alert(+"12px") // NaN
|
||||
```
|
||||
|
||||
Для удобного чтения таких значений существует функция `parseInt`:
|
||||
|
|
@ -230,8 +230,8 @@ alert( parseInt('12px') ); // 12
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert( parseInt('12px') ) // 12, ошибка на символе 'p'
|
||||
alert( parseFloat('12.3.4') ) // 12.3, ошибка на второй точке
|
||||
alert(parseInt('12px')) // 12, ошибка на символе 'p'
|
||||
alert(parseFloat('12.3.4')) // 12.3, ошибка на второй точке
|
||||
```
|
||||
|
||||
Конечно, существуют ситуации, когда `parseInt/parseFloat` возвращают `NaN`. Это происходит при ошибке на первом же символе:
|
||||
|
|
@ -253,9 +253,9 @@ alert( parseInt('a123') ); // NaN
|
|||
var x = prompt("Введите значение", "-11.5");
|
||||
|
||||
if (isNaN(x)) {
|
||||
alert("Строка преобразовалась в NaN. Не число");
|
||||
alert( "Строка преобразовалась в NaN. Не число" );
|
||||
} else {
|
||||
alert("Число");
|
||||
alert( "Число" );
|
||||
}
|
||||
```
|
||||
|
||||
|
|
@ -349,7 +349,7 @@ alert( n.toString(36) ); // kf12oi
|
|||
</dl>
|
||||
|
||||
```js
|
||||
//+ run
|
||||
//+ run no-beautify
|
||||
alert( Math.floor(3.1) ); // 3
|
||||
alert( Math.ceil(3.1) ); // 4
|
||||
alert( Math.round(3.1) ); // 3
|
||||
|
|
@ -362,15 +362,15 @@ alert( Math.round(3.1) ); // 3
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert( ~~12.3 ); // 12
|
||||
alert( ~~12.3 ); // 12
|
||||
```
|
||||
|
||||
Любая побитовая операция такого рода подойдет, например XOR (исключающее ИЛИ, `"^"`) с нулем:
|
||||
|
||||
```js
|
||||
//+ run
|
||||
alert( 12.3 ^ 0 ); // 12
|
||||
alert( 1.2 + 1.3 ^ 0); // 2, приоритет ^ меньше, чем +
|
||||
alert( 12.3 ^ 0 ); // 12
|
||||
alert( 1.2 + 1.3 ^ 0 ); // 2, приоритет ^ меньше, чем +
|
||||
```
|
||||
|
||||
Это удобно в первую очередь тем, что легко читается и не заставляет ставить дополнительные скобки как `Math.floor(...)`:
|
||||
|
|
@ -388,7 +388,7 @@ var x = a * b / c ^ 0; // читается как "a * b / c и округлит
|
|||
```js
|
||||
//+ run
|
||||
var n = 3.456;
|
||||
alert( Math.round( n * 100 ) / 100 ); // 3.456 -> 345.6 -> 346 -> 3.46
|
||||
alert( Math.round(n * 100) / 100 ); // 3.456 -> 345.6 -> 346 -> 3.46
|
||||
```
|
||||
|
||||
Таким образом можно округлять число и вверх и вниз.
|
||||
|
|
@ -448,7 +448,7 @@ alert( Math.round(price * 10) / 10 ); // 6.4
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert(0.1 + 0.2 == 0.3);
|
||||
alert( 0.1 + 0.2 == 0.3 );
|
||||
```
|
||||
|
||||
Запустили? Если нет -- все же сделайте это.
|
||||
|
|
@ -459,14 +459,14 @@ alert(0.1 + 0.2 == 0.3);
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert(0.1 + 0.2); // 0.30000000000000004
|
||||
alert( 0.1 + 0.2 ); // 0.30000000000000004
|
||||
```
|
||||
|
||||
Как видите, произошла небольшая вычислительная ошибка, результат сложения `0.1 + 0.2` немного больше, чем `0.3`.
|
||||
|
||||
```js
|
||||
//+ run
|
||||
alert(0.1 + 0.2 > 0.3); // true
|
||||
alert( 0.1 + 0.2 > 0.3 ); // true
|
||||
```
|
||||
|
||||
Всё дело в том, что в стандарте IEEE 754 на число выделяется ровно 8 байт(=64 бита), не больше и не меньше.
|
||||
|
|
@ -477,7 +477,7 @@ alert(0.1 + 0.2 > 0.3); // true
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert( 0.1.toFixed(20) ); // 0.10000000000000000555
|
||||
alert( 0.1.toFixed(20) ); // 0.10000000000000000555
|
||||
```
|
||||
|
||||
Когда мы складываем `0.1` и `0.2`, то две неточности складываются, получаем незначительную, но всё же ошибку в вычислениях.
|
||||
|
|
@ -490,7 +490,7 @@ alert( 0.1.toFixed(20) ); // 0.10000000000000000555
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert( (0.1*10 + 0.2*10) / 10 ); // 0.3
|
||||
alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
|
||||
```
|
||||
|
||||
Это работает, т.к. числа `0.1*10 = 1` и `0.2*10 = 2` могут быть точно представлены в двоичной системе.
|
||||
|
|
@ -513,7 +513,7 @@ alert( +result.toFixed(10) ); // 0.3
|
|||
|
||||
```js
|
||||
//+ run
|
||||
alert(9999999999999999); // выведет 10000000000000000
|
||||
alert( 9999999999999999 ); // выведет 10000000000000000
|
||||
```
|
||||
|
||||
Причина та же -- потеря точности.
|
||||
|
|
@ -581,7 +581,7 @@ JavaScript предоставляет базовые тригонометрич
|
|||
//+ run
|
||||
var number = 123456789;
|
||||
|
||||
alert( number.toLocaleString() ); // 123 456 789
|
||||
alert( number.toLocaleString() ); // 123 456 789
|
||||
```
|
||||
|
||||
Его поддерживают все современные браузеры, кроме IE10- (для которых нужно подключить библиотеку [Intl.JS](https://github.com/andyearnshaw/Intl.js/)). Он также умеет форматировать валюту и проценты. Более подробно про устройство этого метода можно будет узнать в статье [](/intl), когда это вам понадобится.
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue