Часто обчислення дають результати, які відповідають межам потрібних діапазонів. В результаті потрібно здійснювати JavaScript округленнядо певного значення.
Навіщо округляти числа?
JavaScript не зберігає цілі числа, оскільки їх значення представлені у вигляді цифр з плаваючою точкою. Багато дробів не можуть бути представлені числом з певною кінцевою кількістю знаків після коми, тому JavaScript може генерувати результати на кшталт наведеного нижче:
0.1 * 0.2; > 0.020000000000000004
На практиці це не матиме жодного значення, оскільки йдеться про похибку у 2 квінтиліонні. Але це може вплинути на результат при роботі з числами, які представляють значення валют, відсотків або розмір файлу. Тому потрібно зробити або до певного знаку після коми.
Округлення десяткових чисел
Щоб обрізати десяткове число, використовуються методи toFixed() або toPrecision() . Вони обидва приймають один аргумент, який визначає кількість значущих і знаків після коми, які мають бути включені до результату:
- якщо для toFixed() аргумент не визначено, значення за умовчанням дорівнює 0, тобто без знаків після коми; максимальне значення аргументу дорівнює 20;
- якщо для toPrecision() аргумент не заданий, число не змінюється.
var randNum = 6.25; randNum.toFixed(); > "6" Math.PI.toPrecision(1); > "3" var randNum = 87.335; randNum.toFixed(2); > "87.33" var randNum = 87.337; randNum.toPrecision(3); > "87.3"
Примітка
І toFixed() , і toPrecision повертають округлене рядкове уявлення результату, а чи не число. Це означає, що додаток rounded до randNum в результаті дасть конкатенацію рядків, а не одне число:
console.log(randNum + rounded); > "6.256"
Якщо потрібно отримати в результаті JavaScript округлення до сотих число, використовуйте parseFloat() :
var randNum = 6.25; var rounded = parseFloat(randNum.toFixed(1)); console.log(rounded); > 6.3
toFixed() і toPrecision() також є корисними методами для усічення великої кількості знаків після коми. Це зручно при роботі з числами, що становлять грошові одиниці:
var wholeNum = 1 var dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"
Зверніть увагу, що якщо в числі більше знаків, ніж вказано параметром точності, топерерахунок буде видавати результат у науковому форматі:
var num = 123.435 num.toPrecision(2); > "1.2e+2"
Як уникнути помилок при заокругленні десяткових дробів
У деяких випадках доFixed і toPrecision здійснюють JavaScript округлення 5 у менший бік, а не до більшого:
var numTest = 1.005; numTest.toFixed(2); > 1;
Результатом наведеного вище прикладу має бути 1.01, а не 1. Якщо потрібно уникнути цієї помилки, я рекомендую використати експоненційні числа:
function round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )
Застосування:
round(1.005,2); > 1.01
Якщо потрібно ще надійніше рішення, ніж округлення, воно доступне на MDN.
Округлення за допомогою епсілону
Альтернативний метод JavaScript округлення до десятихбув введений в ES6 ( також відомому, як JavaScript 2015). « Машинний епсілон» забезпечує розумну межу похибки при порівнянні двох чисел з плаваючою комою. Без округлення, порівняння можуть дати результати, подібні до таких:
0.1 + 0.2 === 0.3 > false
Math.EPSILON може бути використаний у функції для отримання коректного порівняння:
function epsEqu(x, y) ( return Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
Функція приймає два аргументи: один містить обчислення, другий очікуваний (округлений) результат. Вона повертає порівняння цих двох параметрів:
epsEqu(0.1 + 0.2, 0.3) > true
Усі сучасні браузери підтримують математичні функції ES6. Але якщо необхідно забезпечити підтримку в старих браузерах, потрібно використовувати поліфіли.
Усічення десяткових чисел
Усі методи, представлені раніше, виконують JavaScript округлення до десятих. Щоб усікти позитивне число до двох знаків після коми, помножити його на 100 , усікти знову, а потім отриманий результат розділити на 100 , потрібно:
function truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
Якщо потрібно щось гнучкіше, можна скористатися побітовим оператором:
function truncated(num, decimalPlaces) ( var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Використання:
var randInt = 35.874993; truncated(randInt,3); > 35.874
Округлення до найближчого числа
Щоб здійснити JavaScript округлення до цілого, використовується Math.round() :
Math.round(4.3) > 4 Math.round(4.5) > 5
Зверніть увагу, що " половинні значення«, такі як .5, округляються вгору.
Округлення вниз до найближчого цілого числа
Якщо ви хочете округляти у менший бік, використовуйте метод Math.floor() :
Math.floor(42.23); > 42 Math.floor(36.93); > 36
Округлення "вниз" має один напрямок для всіх чисел, у тому числі і для негативних. Це можна уявити, як хмарочос з нескінченною кількістю поверхів, у тому числі і нижче за рівень фундаменту ( які представляють негативні числа). Якщо ви знаходитесь в ліфті між підвальними поверхами 2 та 3 ( що відповідає значенню -2.5), Math.floor доставить вас на поверх -3 :
Math.floor(-2.5); > -3
Якщо потрібно уникнути цього, використовуйте JavaScript Math округлення за допомогою Math.trunc() , який підтримується у всіх сучасних браузерах (крім IE / Edge):
Math.trunc(-41.43); > -41
MDN також надає поліфіл з трьох рядків для забезпечення підтримки Math.trunc у старих браузерах та IE / Edge.
Округлення вгору до найближчого цілого числа
Якщо ви хочете заокруглити десяткові числа вгору, використовуйте Math.ceil . Дія цього методу також можна уявити, як нескінченний ліфт: Math.ceil завжди везе вас "вгору", незалежно від того, чи є число негативним або позитивним:
Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36.93); -36
Округлення до найближчого кратного числа
Якщо потрібно округлити значення до найближчого числа, кратного 5 , створіть функцію, яка ділить число на 5 округляє його, а потім множить результат на те ж значення:
function roundTo5(num) ( return Math.round(num/5)*5; )
Використання:
roundTo5(11); > 10
Якщо потрібно виконати JavaScript округлення до двох знаків, можна передавати функції як початкове число, так і кратність:
function roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Щоб використовувати функцію, увімкніть у її виклик округлене число та кратність:
var initialNumber = 11; var multiple = 10; roundToMultiple(initialNumber, multiple); > 10;
Щоб заокруглити значення тільки у більшу або меншу сторону, замініть у функції round на ceil або floor.
Прив'язка до діапазону
Іноді потрібно отримати значення х, яке має знаходитись у межах певного діапазону. Наприклад, потрібно значення від 1 до 100, але ми отримуємо значення 123. Щоб виправити це, можна використовувати min() ( повертає найменше із чисел) та max ( повертає максимально допустиме число).
Використання:
var lowBound = 1; var highBound = 100; var numInput = 123; var clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;
Можна створити функцію або розширення класу Number.
Це дозволяє виправити відповідь @ MarkElliot, щоб він працював і для негативних чисел:
Var div = Math.trunc(y/x); var rem = y % x;
Зауважте, що методи Math мають перевагу перед побітовими операторами, що вони працюють з числами більше 2 31 .
JavaScript обчислює праворуч підлогу негативних чисел і залишок нецілих чисел, слідуючи математичним визначенням для них.
FLOOR визначається як "найбільше ціле число, менше, ніж параметр", таким чином:
- позитивні числа: FLOOR(X) = ціла частина X;
- негативні числа: FLOOR (X) = ціла частина X мінус 1 (бо вона повинна бути SMALLER, ніж параметр, тобто більш негативний!)
REMAINDER визначається як «залишилося» поділу (евклідова арифметика). Коли дивіденд не є цілим числом, фактор зазвичай також не є цілим числом, тобто немає залишку, але якщо фактор змушений бути цілим числом (і це те, що відбувається, коли хтось намагається отримати залишок або модуль число з плаваючою комою ), очевидно, буде неціле «залишене».
JavaScript обчислює все так, як очікувалося, тому програміст повинен бути обережним, щоб ставити правильні питання (і люди повинні бути обережні, щоб відповісти на те, що задано!) Перше питання Ярина був НЕ «що таке цілісний поділ X на Y», замість цього: «Ціле число разів, коли це ціле число ЙДЕ В інше». Для позитивних чисел відповідь той самий для обох, але не для негативних чисел, тому що цілий поділ (дивіденд на дільник) буде -1 менше, ніж число (ділитель) «переходить в інше» (дивіденд). Іншими словами, FLOOR поверне правильну відповідь для цілого поділу негативного числа, але Ярин не запитав про це!
gammax правильно відповів, цей код працює за завданням Ярина. З іншого боку, Самуїл помиляється, він не робив математики, я думаю, або він бачив би, що це дійсно працює (також він не сказав, що було дільником його прикладу, але я сподіваюся, що це було 3):
Залишок = X% Y = -100% 3 = -1
GoesInto = (X - Remainder) / Y = (-100 - -1) / 3 = -99 / 3 = -33
До речі, я тестував код на Firefox 27.0.1, він працював, як очікувалося, з позитивними та негативними числами, а також з нецілими значеннями як для дивідендів, так і для дільників. Приклад:
100.34/3.57: GoesInto = -28, Remainder = -0.3800000000000079
Так, я помітив, що там є проблема з високою точністю, але я не встиг її перевірити (я не знаю, чи є проблема з Firefox, Windows 7 або FPU мого процесора). Однак для питання Ярина, яке включає лише цілі числа, код гаммакса працює відмінно.
Ви можете використовувати функцію parseInt для отримання усіченого результату.
ParseInt(a/b)
Щоб отримати залишок, використовуйте оператор mod:
parseInt мають деякі підводні камені з рядками, щоб уникнути використання параметра radix з базою 10
ParseInt("09", 10)
У деяких випадках рядкове представлення числа може бути науковою нотацією, в цьому випадку parseInt призведе до неправильного результату.
ParseInt(100000000000000000000000000000000, 10) // 1e+32
Цей виклик дасть результат 1.
Обчислення кількості сторінок може бути виконано за один крок: Math.ceil (x/y)
Якщо ви просто ділитесь з двома повноваженнями, ви можете використовувати побітові оператори:
Export function divideBy2(num) ( return ; ) export function divideBy4(num) ( return ; ) export function divideBy8(num) ( return ; )
(Перше – це приватне, друге – інше)
Це завжди буде усікати до нуля. Не впевнений, що вже надто пізно, але тут говориться:
Function intdiv(dividend, divisor) ( divisor = divisor - divisor % 1; if (divisor == 0) throw new Error("division by zero"); dividend = dividend - dividend % 1; var rem = dividend % divisor; return ( remainder: rem, quotient: (dividend - rem) / divisor );
Я не експерт у побітових операторах, але ще один спосіб отримати ціле число:
Var num = ~~(a/b);
Це буде нормально працювати і для негативних чисел, а Math.floor() буде обертатися в неправильному напрямку.
Це також здається правильним:
Var num = (a/b) >> 0;
Math.floor(operation) повертає округлене значення операції.
Приклад 1-го питання:
Var x = 5; var y = 10.4; var z = Math.floor(x + y); console.log(z);
Префікс:
Приклад 2-го питання:
Var x = 14; var y = 5; var z = Math.floor (x% y); console.log(x);
Префікс:
Для деякого числа y та деякого дивізора x обчислити фактор (quotient) та залишок (remainder) як:
Var quotient = Math.floor(y/x); var remainder = y%x;
Дуже часто обчислення JavaScript дають не зовсім ті результати, які ми хочемо. Зрозуміло, ми можемо робити з числами будь-що - округлювати у більшу чи меншу сторону, встановлювати діапазони, відсікати непотрібні числа до певної кількості знаків після коми, все залежить від того, що ви хочете зробити надалі з цим числом.Навіщо потрібне округлення?
Одним із цікавих аспектів JavaScript є те, що він насправді не зберігає цілі числа, ми відразу ж працюємо з числами з плаваючою точкою. Це, у поєднанні з тим фактом, що багато дробових значень не можуть бути виражені кінцевим числом знаків після коми, в JavaScript ми можемо отримати такі результати:0.1 * 0.2;
> 0.020000000000000004
0.3 - 0.1
> 0.19999999999999998
Для практичних цілей ця неточність не має жодного значення, у нашому випадку ми говоримо про помилку в квінтильйонних частках, проте когось це може розчарувати. Ми можемо отримати трохи дивний результат і при роботі з числами, які є значеннями валют, відсотків або розмірів файлу. Для того, щоб виправити ці неточності, нам якраз і необхідно вміти округляти результати, достатньо встановити десяткову точність.
Округлення чисел має практичне застосування, ми можемо маніпулювати числом у певному діапазоні, наприклад, хочемо округлити значення до найближчого цілого числа, а не працювати лише з десятковою частиною.
Округлення десяткових чисел
Для того, щоб відсікти десяткове число, використовуйте tofixed або метод toPrecision . Обидва вони приймають єдиний аргумент, який визначає, відповідно, скільки значущих цифр (тобто загальна кількість цифр, що використовуються в числі) або знаків після коми (кількість після десяткової точки) повинен включати результат:- Якщо аргумент не визначений для toFixed(), то за умовчанням він дорівнюватиме нулю, що означає 0 знаків після коми, аргумент має максимальне значення, що дорівнює 20.
- Якщо аргумент не заданий дляперегляду, число залишається незайманим
Обидва методи toFixed() і toPrecision() повертають рядкове представлення результату, а чи не число. Це означає, що при підсумовуванні округленого значення з randNum буде здійснено конкатенацію рядків, а не суму чисел:
Let randNum = 6.25; let rounded = randNum.toFixed(); // "6" console.log(randNum + rounded); > "6.256"
Якщо ви хочете, щоб результат мав числовий тип даних, вам необхідно буде застосувати parseFloat:
Let randNum = 6.25; let rounded = parseFloat(randNum.toFixed(1)); console.log(rounded); > 6.3
Зверніть увагу, що значення 5 округлені, за винятком поодиноких випадків.
Методи toFixed() і toPrecision() є корисними, бо вони можуть не тільки відсікати дробову частину, а й доповнювати знаки після коми, що зручно під час роботи з валютою:
Let wholeNum = 1 let dollarsCents = wholeNum.toFixed(2); console.log(dollarsCents); > "1.00"
Варто зауважити, що допереживання буде давати результат в експоненційному записі, якщо число цілих чисел більше, ніж сама сама точність:
Let num = 123.435 num.toPrecision(2); > "1.2e+2"
Як уникнути помилок округлення з десятковими числами
У деяких випадках, тоfixed і toPrecision округляє значення 5 у меншу сторону, а у більшу:Let numTest = 1005; numTest.toFixed(2); > "1.00"
Результат розрахунку повинен був бути 1.01, а не 1. Якщо ви хочете уникнути подібну помилку, ми можемо використовувати рішення, запропоноване Jack L Moore , яке використовує експоненційні числа для розрахунку:
Function round(value, decimals) ( return Number(Math.round(value+"e"+decimals)+"e-"+decimals); )
Тепер:
Round (1.005,2); > 1.01
Якщо ви хочете більш надійне рішення, ніж рішення наведене вище, ви можете перейти на MDN .
Машинне епсілон округлення
Альтернативний метод заокруглення десяткових чисел було введено в ES6. Машинне епсілон округлення забезпечує розумну межу похибки при порівнянні двох чисел з плаваючою точкою. Без округлення, порівняння можуть дати результати, подібні до таких:0.1 + 0.2 === 0.3 > false
Ми використовуємо Math.EPSILON у нашій функції для отримання коректного порівняння:
Function epsEqu(x, y) ( return Math.abs(x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y));
}
Функція приймає два аргументи: перший – поточний розрахунок, другий – очікуваний результат. Вона повертає порівняння двох:
EpsEqu(0.1 + 0.2, 0.3) > true
Всі сучасні браузери вже підтримують ES6 математичних функцій, але якщо ви хочете отримати підтримку в таких браузерах, як IE 11, використовуйте polyfills .
Відсікання дробової частини
Усі методи, наведені вище вміють округлювати до десяткових чисел. Для того, щоб просто відсікти число до двох знаків після коми, необхідно спочатку помножити його на 100, а потім отриманий результат уже розділити на 100:Function truncated(num) ( return Math.trunc(num * 100) / 100; ) truncated(3.1416) > 3.14
Якщо ви хочете пристосувати метод під будь-яку кількість знаків після коми, ви можете скористатися подвійним побитовим запереченням:
Function truncated(num, decimalPlaces) ( let numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter; )
Тепер:
Let randInt = 35.874993; truncated(randInt,3); > 35.874
Округлення до найближчого числа
Для того, щоб округлити десяткове число до найближчого числа у більшу або меншу сторону, залежно від того, до чого ми найближче, використовуйте Math.round():Math.round(4.3) > 4 Math.round(4.5) > 5
Зверніть увагу, що «половина значення», 0.5 округляється у велику сторону за правилами математики.
Округлення до меншого до найближчого цілого числа
Якщо ви хочете завжди округляти у менший бік, використовуйте Math.floor:Math.floor(42.23); > 42 Math.floor(36.93); > 36
Зауважте, що округлення в меншу сторону працює для всіх чисел, у тому числі і для негативних. Уявіть хмарочос із нескінченною кількістю поверхів, у тому числі з поверхами нижнього рівня (що представляє негативні числа). Якщо ви знаходитесь в ліфті на нижньому рівні між 2 і 3 (що являє собою значення -2.5), Math.floor доставить вас до -3:
Math.floor(-2.5); > -3
Але якщо ви хочете уникнути подібної ситуації, використовуйте Math.trunc, який підтримується у всіх сучасних браузерах (крім IE/Edge):
Math.trunc(-41.43); > -41
На MDN ви знайдете polyfill, який забезпечить підтримку Math.trunc у браузерах та IE/Edge.
Округлення до більшого до найближчого цілого числа
З іншого боку, якщо вам потрібно завжди округляти у велику сторону, використовуйте Math.ceil. Знову ж таки, згадуємо нескінченний ліфт: Math.ceil завжди йтиме «вгору», незалежно від того, чи є число негативне чи ні:Math.ceil(42.23); > 43 Math.ceil(36.93); > 37 Math.ceil(-36.93); > -36
Округлення до більшого/меншого необхідного числа
Якщо ми хочемо, щоб округлити до найближчого числа, кратного 5, найпростіший спосіб створити функцію, яка ділить число на 5, округляє його, а потім множить його на ту саму суму:Function roundTo5(num) ( return Math.round(num/5)*5; )
Тепер:
RoundTo5(11); > 10
Якщо ви хочете округляти до кратних свого значення, ми використовуємо більш загальну функцію, передаючи в неї початкове значення і кратне:
Function roundToMultiple(num, multiple) ( return Math.round(num/multiple)*multiple; )
Тепер:
Let initialNumber = 11; let multiple = 10; roundToMultiple(initialNumber, multiple); > 10;
Фіксування числа в діапазоні
Є багато випадків, коли ми хочемо отримати значення x, що лежить в межах діапазону. Наприклад, нам може знадобитися значення від 1 до 100, але при цьому ми отримали значення 123. Для того щоб виправити це, ми можемо використовувати мінімальне (повертає найменше з набору чисел) і максимальне (повертає найбільше з будь-якої множини чисел). У нашому прикладі діапазон від 1 до 100:Let lowBound = 1; let highBound = 100; let numInput = 123; let clamped = Math.max(lowBound, Math.min(numInput, highBound)); console.log(clamped); > 100;
Знову ж таки, ми можемо перевикористовувати операцію і обернути все це в функцію, скористаємося рішенням, запропонованим Daniel X. Moore :
Number.prototype.clamp = function(min, max) ( return Math.min(Math.max(this, min), max); );
Тепер:
NumInput.clamp(lowBound, highBound); > 100;
Гаусове округлення
Гаусове округлення, також відоме як банківське округлення, полягає в тому, що округлення для цього випадку відбувається до найближчого парного. Цей метод округлення працює без статистичної похибки. Найкраще рішення було запропоновано Tim Down:Function gaussRound(num, decimalPlaces) ( let d = decimalPlaces || 0, m = Math.pow(10, d), n = +(d ? num * m: num).toFixed(8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f > 0.5 - e && f< 0.5 + e) ?
((i % 2 == 0) ? i: i + 1) : Math.round(n);
return d ? r / m: r;
}
Тепер:
GaussRound(2.5) > 2 gaussRound(3.5) > 4 gaussRound(2.57,1) > 2.6
Десятковий знак у CSS:
Так як JavaScript часто використовується для створення позиційного перетворення HTML-елементів, ви можете поставити питання, що станеться, якщо ми cгенеруємо десяткові значення для наших елементів:
#box (width: 63.667731993px; )
Хороша новина полягає в тому, що сучасні браузери враховуватимуть десяткові значення у блочній моделі, у тому числі у процентних чи піксельних одиницях виміру.
Сортування
Дуже часто нам доводиться сортувати якісь елементи, наприклад, у нас є масив ігрових рекордів, при цьому вони повинні бути організовані за зменшенням рангу гравців. На жаль, стандартний метод sort() має деякі дивовижні обмеження: він добре працює з англійськими словами, що часто вживаються, але відразу ж ламається при зустрічі з числами, унікальними символами або словами у верхньому регістрі.Сортування за абеткою
Здавалося б, сортування масиву за алфавітом має бути найпростішим завданням:Let fruit = ["butternut squash", "apricot", "cantaloupe"]; fruit.sort(); > "apricot", "butternut squash", "cantaloupe"]
Тим не менш, ми стикаємося з проблемою, як тільки один з елементів знаходиться у верхньому регістрі:
Let fruit = ["butternut squash", "apricot", "Cantalope"]; fruit.sort(); > "Cantaloupe", "apricot", "butternut squash"]
Це пов'язано з тим, що, за замовчуванням, сортувальник порівнює перший символ, представлений в Unicode . Unicode - це унікальний код будь-якого символу, незалежно від платформи, незалежно від програми, незалежно від мови. Наприклад, якщо по кодовій таблиці символ «a» має значення U+0061 (у шістнадцятковій системі 0x61), тоді як символ «C» має код U+0043 (0x43), який йде раніше в Unicode-таблиці, ніж символ "a".
Щоб відсортувати масив, який може містити змішані регістри перших букв, нам необхідно або перетворити всі елементи тимчасово в нижній регістр, або визначити порядок сортування за допомогою методу localeCompare() з деякими аргументами. Як правило, для такого випадку, краще відразу створити функцію для багаторазового використання:
Function alphaSort(arr) ( arr.sort(function (a, b) ( return a.localeCompare(b, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash "Apricot", "Cantaloupe"]; alphaSort(fruit) >
Якщо ви хочете отримати масив відсортований у зворотному алфавітному порядку, просто поміняйте позиціями а та b у функції:
Function alphaSort(arr) ( arr.sort(function (a, b) ( return b.localeCompare(a, "en", ("sensitivity": "base")); )); ) let fruit = ["butternut squash "Apricot", "Cantaloupe"]; alphaSort(fruit) > ["Cantaloupe", "butternut squash", "apricot"]
Тут варто звернути увагу, що localeCompare використовується з аргументами, ще треба пам'ятати, що він підтримується IE11+, для більш старих версій IE ми можемо використовувати його без аргументів, і в нижньому регістрі:
Function caseSort(arr) ( arr.sort(function (a, b) ( return a.toLowerCase().localeCompare(b.toLowerCase()); )); ) let fruit = ["butternut squash", "apricot", "Cantaloupe"]; caseSort(fruit) > ["apricot", "butternut squash", "Cantaloupe"]
Числове сортування
Все це не стосується того прикладу, про який ми говорили вище про масив ігрових рекордів. З деякими числовими масивами сортування працює просто ідеально, але в якийсь момент результат може бути непередбачуваним:Let highScores = ; highScores.sort(); >
Справа в тому, що метод sort() здійснює лексикографічне порівняння: а це означає, що числа будуть перетворені в рядок і порівняння будуть знову проводитися шляхом зіставлення першого символу цього рядка в порядку символів Unicode-таблиці. Тому нам знову необхідно визначити свій порядок сортування:
Let highScores = ; highScores.sort(function(a,b) ( return a - b; )); >
Знову ж таки, для сортування чисел у зворотному порядку, поміняйте позиціями a та b у функції.
Сортування JSON-подібної структури
І нарешті, якщо у нас є JSON-подібна структура даних, представлена як масив ігрових рекордів:Let scores = [ ( "name": "Daniel", "score": 21768 ), ( "name": "Michael", "score": 33579 ), ( "name": "Alison", "score": 38395 )];
В ES6+, ви можете використовувати стрілочні функції:
Scores.sort((a, b) => b.score - a.score));
Для старих браузерів, які не мають такої підтримки:
Scores.sort(function(a, b) (return a.score - b.score));
Як бачите, сортування JavaScript це досить не очевидна річ, я сподіваюся, що ці приклади полегшать як-небудь життя.
Робота зі статечними функціями
Зведення в ступінь - операція, що визначається як результат багаторазового множення натурального числа на себе, квадратний корінь з числа a - число, що дає a при зведенні в квадрат. Цими функціями ми могли користуватися постійно у повсякденному житті під час уроків математики, зокрема під час обчислення площ, обсягів і навіть при фізичному моделюванні.У JavaScript статечна функція представлена як Math.pow(), в новому стандарті ES7 був представлений новий оператор зведення в ступінь - "* *".
Зведення в ступінь
Для того, щоб звести число в n-ий ступінь, використовуйте функцію Math.pow(), де перший аргумент це число, яке буде зведено в ступінь, другий аргумент це показник ступеня:Math.pow(3,2) > 9
Така форма запису означає 3 у квадраті, або 3 × 3, що призводить до результату 9. Можна навести ще приклад, звичайно:
Math.pow (5,3); > 125
Тобто, 5 у кубі, або 5×5×5, дорівнює 125.
ECMAScript 7 - це наступна версія JavaScript, в принципі, ми можемо використовувати новий запропонований оператор зведення в ступінь - * *, така форма запису може бути наочнішою:
3 ** 2
> 9
На даний момент підтримка цього оператора досить обмежена, тому його не рекомендується використовувати.
Ступенева функція може стати в нагоді в різних ситуаціях. Простий приклад, обчислення кількості секунд за годину: Math.pow (60,2).
Квадратний та кубічний корінь
Math.sqrt() і Math.cbrt() протилежні функції Math.pow(). Як пам'ятаємо, квадратний корінь у складі a - число, дає a під час зведення квадрат.Math.sqrt(9) > 3
У той же час кубічний корінь із числа a - число, що дає a при зведенні куб.
Math.cbrt(125) > 5
Math.cbrt() був введений у специфікацію JavaScript зовсім недавно, і тому підтримується лише у сучасних браузерах: Chrome 38+, Firefox та Opera 25+ та Safari 7.1+. Ви помітите, що Internet Explorer відсутня у цьому списку, однак на MDN ви знайдете поліфіл.
Приклади
Звичайно, ми можемо використовувати не цілі значення в одній з цих функцій:Math.pow (1.25, 2); > 1.5625 Math.cbrt(56.57) > 3.8387991760286138
Зверніть увагу, що це цілком працює і при використанні негативних значеннях аргументів:
Math.pow(-5,2) > 25 Math.pow(10,-2) > 0.01
Тим не менш, для квадратного кореня це не працюватиме:
Math.sqrt(-9) > NaN
З математичного аналізу ми знаємо, що під уявним числом розуміють квадратне коріння з негативних чисел. І це може призвести до ще однієї техніки роботи з комплексними числами, але це вже інша історія.
Ви можете використовувати дробові значення в Math.pow(), щоб знайти квадратні та кубічні корені чисел. Квадратний корінь використовує показник 0.5:
Math.pow (5, 0.5); // = Math.sqrt(5) = 5 ** (1/2) > 2.23606797749979
Однак, через примхи з плаваючою точкою, ви не можете точно припустити правильний результат:
Math.pow(2.23606797749979,2) > 5.000000000000001
У таких ситуаціях, вам доведеться вдаватися до відсікання знаків у числа або округлення до будь-якого значення.
Деякі з незрозумілих причин у JavaScript плутають функцію Math.pow() з Math.exp() , яка є експоненційною функцією для чисел, загалом. Примітка: в англійській мові «показник ступеня» перекладається як «exponent», тому це скоріше стосується англомовних, хоча існують і альтернативні назви показника ступеня, такі як index, power.
Математичні константи
Робота з математикою JavaScript полегшується за рахунок низки вбудованих констант. Ці константи є властивостями об'єкта Math. Варто звернути увагу на те, що константи пишуться у верхньому регістрі, а не CamelCase нотації.Math.abs, parseInt, parseFloat
Робота з числами в JavaScript може бути набагато складнішою, ніж здається. Отримані значення не завжди потрапляють всередину очікуваних діапазонів, іноді результат може виявитися зовсім не тим, що ми очікували.Math.abs()
Метод Math.abs() повертає абсолютне значення числа, що нагадує нам аналогічну математичну функцію модуля числа a.Let newVal = -57.64; Math.abs(newVal); > 57.64
Math.abs(0) завжди повертає нуль, але якщо поставити знак мінус перед функцією Math.abs(NUM) ми завжди будемо негативне значення.
Math.abs(0); > -0
parseInt()
Ми знаємо, що JavaScript розуміє, що "15" це рядок, а не число і, наприклад, при розборі CSS-властивостей засобами JavaScript, або отримавши якесь значення з непідготовленого масиву, наші результати можуть вийти непередбачуваними. Ми могли отримати на вхід рядок, представлений як «17px», і для нас це не є рідкістю. Питання полягає в тому, як перетворити цей рядок на фактичне значення і використовувати його в подальших розрахунках.Синтаксис: parseInt(string, radix);
Функція parseInt перетворює перший переданий їй аргумент на рядковий тип, інтерпретує його і повертає ціле число або значення NaN. Результат (якщо не NaN) є цілим числом і є першим аргументом (string), що розглядається як число у зазначеній системі числення (radix). Наприклад, підстава 10 вказує на перетворення з десяткового числа, 8 - вісімкового, 16 - шістнадцяткового і так далі. Якщо основа більша за 10, то для позначення цифр більше 9 використовуються літери. Наприклад, для шістнадцяткових чисел (основа 16) використовуються літери від A до F.
Розглянемо приклад роботи з CSS-властивостями, де, умовно кажучи, ми можемо отримати таке значення:
Let elem = document.body; let centerPoint = window.getComputedStyle(elem).transformOrigin; > "454px 2087.19px"
Ми можемо розділити значення пробілів:
Let centers = centerPoint.split(" "); > ["454px", "2087.19px"]
Однак, кожен елемент все ще є рядок, ми можемо позбавитися цього застосувавши нашу функцію:
Let centerX = parseInt(centers, 10); > 454 let centerY = parseInt(centers, 10); > 2087
Як бачите, другим аргументом ми вказуємо систему числення, в яку буде перетворено число, цей параметр необов'язковий, але його рекомендується використовувати, якщо ви не знаєте, який рядок надійде на вхід.
parseFloat()
З прикладу вище, ви напевно помітили, що parseInt відкидає дрібну частину. У нашому випадку, parseFloat вміє працювати з числами з плаваючою точкою. Знову ж таки, це може бути корисним при розборі CSS та інших завданнях, особливо при роботі з плаваючою точкою у відсотках.Синтаксис: parseFloat(string)
Let FP = "33.33333%"; console.log(parseFloat(FP)); > 33.33333
Зверніть увагу, що синтаксис parseFloat не має другого аргументу.
Ми розуміємо, що parseInt() і parseFloat() є надзвичайно корисними функціями, важливо враховувати, що й тут не обійтися без помилок, тому необхідно перевіряти діапазон очікуваних значень і, зрештою, аналізувати результат, щоб гарантувати, що отримані значення вірні.
Надіслати анонімно
У цій частині наших занять ми познайомимося з об'єктом Номеряк із контейнером числового типу даних. Його власне об'єктна сутність сьогодні буде порушена дуже поверхово.
Так само, як об'єкт Stringмістить рядки тексту, об'єкт Номермістить числа. Як і рядки, числа, які ми створюємо, атоматично стають екземплярами об'єкта.
Тип даних Number
Числа в JavaScript бувають двох видів: цілі і з плаваючою точкою (поділів на безліч типів, як в інших мовах integer, long, short, double тут немає). Числа з плаваючою точкою мають цілу та дробову частини, розділені точкою (незалежно від національних налаштувань).
Ці два види чисел не є самостійними типами і не потребують спеціальної конверсії між собою. Якщо, наприклад, 32.5 ми помножимо на 0.4 , то відразу отримаємо ціле число 13 , а не дріб 13.0 , яку потрібно конвертувати в ціле чисельне значення (як часто-густо в інших мовах).
Створення об'єкта Number
Як і рядок, число зазвичай створюють як екземпляр об'єкта Номер, простим призначенням (на відміну від рядка, лапок не потрібно).
var myNum = 21;Але можна створити і новий об'єкт за допомогою конструктора:
var myNum = new Number; myNum = 21;Переважна більшість випадків це зайве і навіть шкідливо. Коректні приклади подібної роботи з об'єктами ми розглянемо у 4-й частині.
Подання чисел
Експонентна форма
Числа можна представляти як у звичайній, так і в експоненційній формі, наприклад:
2e6 // без пробілів!Це означає: 2 × 10 6
Якщо ми виведемо таке число через метод документа write(), то отримаємо розгорнуте число у звичайному поданні.
Document. write(14e12);
Результат:
Основні системи числення
Числа можна також представляти як у десятковій, так і в шістнадцятковій та вісімковій системах.
Цілічисла у десятковій формі не повинні починатися з нуля, тому що нуль є префіксом для десяткових систем. Просто 0 префікс для вісімкових значень, а 0xдля шістнадцяткових.
Наприклад, 075 Це восьмеричне уявлення десяткового числа 61 , а 0x75шістнадцяткове уявлення десяткового числа 117 .
Для вісімкових значень використовуються цифри від 0 до 7 для шістнадцяткових цифро-літерний ряд 0123456789ABCDEF. Літери можна використовувати у будь-якому регістрі.
В арифметичних виразах можна використовувати будь-які форми чисел, але результат буде представлений десятковим числом.
Подання чисел в інших системах
Говорячи про об'єкт String, ми стосувалися методу toString(), який конвертує будь-який об'єкт у рядок. При конвертації чисел у рядки бажано вказати як аргумент систему числення.
Зверніть увагу
Початкове число потрібно укласти в дужки
(число). toString(Система)
системаможе приймати будь-які значення від 2 до 36.
(157 ).toString(2 ); // Двійкове уявлення 157, одно (53 ).toString(27 ); // екзотичне 27-річне уявлення 53, одно
Але ці отримані вирази є рядками. Щоб зробити їх реальними числами у зазначених системах числення, потрібний результат методу toString(система)конвертувати назад до числа. Робиться це не методом, а функцією ядра Number(об'єкт). Про функції ядра ми поговоримо в одному з найближчих уроків, а поки зверніть увагу на синтаксис, він схожий на виклик функції:
var a = 1546; var b = a. toString(2); var c = Номер(b);Або відразу, «два в одному»:
var a = 1546; var b = Номер(a. toString(2 ));Примітка
Якщо вихідне число призначене на змінну, то її не треба брати в дужки при виклику методу toString() .
Властивості об'єкта Number
Загальні об'єктні властивості constructor і prototype ми торкнемося в уроці про об'єкт Object, а зараз звернемося до специфічних властивостей об'єкту Номер.
Ці властивості тільки для читаннятобто ми не можемо їх змінювати.
MAX_VALUE
Максимальне число, доступне для обробки JavaScript.
Подивимося, що це за число таке:
var e = Number. MAX_VALUE document. write(e)Результат:
1.7976931348623157e+308
Плюс у даному випадку не знак додавання, а позитивний ступінь, тобто 1.7976931348623157 × 10 308
Примітка
Зазвичай демонструю результати з допомогою реально написаних скриптів. Але дуже багато обчислень дробових чисел можуть гальмувати завантаження сторінки, і більшість результатів у цьому уроці написані, так би мовити, «від руки».
MIN_VALUE
А це відповідно мінімальне значення. Досліджуємо його.
var f = Number. MIN_VALUE document. write(f)Результат:
Тобто 5 × 10 -324
Нечислове значення, з яким ми зустрічалися.
Ця властивість повертає JavaScript, коли числова операція чомусь видає нечисловий результат.
NEGATIVE_INFINITY, POSITIVE_INFINITY
Колись вважали приблизно так: «один оленя, два оленя, багато оленя».
JavaScript вважає трохи більш «просунуто»: «один оленя, два оленя, три оленя, ... 1.7976931348623157 × 10 308 оленя, багато оленя».
Це позамежне «багато» виражається властивістю POSITIVE_INFINITY.
При зворотному процесі розподілі одиниці («одного оленя») на дрібні-дрібні шматочки найдрібнішим ліченим шматочком виявиться 5 × 10 -324 частина. Все, що менше, це вже NEGATIVE_INFINITY.
Методи об'єкта Number
Примітка: так само, як і в методі toString(), у всіх інших методах вихідне число потрібно укласти в дужки, якщо воно представлено явно (а не у вигляді змінної).
доExponential()
Повертає рядок, що становить число в експоненційному вигляді, з однією цифрою перед десятковою точкою.
Синтаксис:
число. доExponential(кількістьЗнаків)
Аргумент кількістьЗнаківзадає точність округлення після десяткової точки. Якщо аргумент опущений, кількість цифр після десяткової точки дорівнює кількості цифр, необхідних представлення значення.
Приклад:
var myFullNumber = 4659872156831598853654127 ; document. write(myFullNumber.toExponential(4))Результат:
toFixed()
Повертає рядок, що представляє число з фіксованою точкою, заокруглене до кількості десяткових знаків, вказаних у аргументі.
Синтаксис:
число. toFixed(кількістьЗнаків)
Приклади:
var myDecimal1 = 46.59872156831598853654127; var myDecimal2 = 46; document. write(myDecimal1.toFixed(1)) document. write("") Document. write(myDecimal2.toFixed(3))
Результати:
Цей метод іноді буває дуже корисним. Наприклад, громіздку функцію з минулого уроку можна тепер уявити так:
function anyRootPlus(x, y) (var srcnum = Math. exp(Math. log(x) / y); var result = (srcnum). toFixed(3); return result; )А тепер вставимо її у форму і протестуємо:
Щоправда, тепер і цілі числа будуть із трьома нулями після крапки. Але, знаючи поведінку чисел і рядків, вміючи працювати з умовними операторами та конверсією типів, не так вже й складно зробити необхідний числовий «дизайн».
toLocaleString()
Перетворює числовий об'єкт у рядкове значення з урахуванням національних налаштувань для десяткових роздільників та роздільників між тисячами. За основу береться національна валюта, тому у російському варіанті всі, навіть цілі, числа представлені з двома знаками після коми (копійками):
var myDrob = 25.327; var myMnogo = 25635120; var myRoubl = 35; /* зробимо більше, щоб краще розглянути коми */ document. write(""
+ myDrob. toLocaleString() + "" ); document. write(""
+ myMnogo. toLocaleString() + "" ); document. write(""
+ myRoubl. toLocaleString() + "" );Результати:
toPrecision()
Повертає рядок, що становить число із заданою загальною кількістю значущих цифр.
Синтаксис:
число. toPrecision(количЦифр)
Аргумент:
количЦифркількість цифр у рядку, що відображається. Якщо задана кількість більша за кількість у вихідному числі, відображаються десяткові нулі.
Document. write((354 ).toPrecision(8 ))
Результат:
Методи toPrecision()і toLocaleString()спільно не працюють, Для «російського дизайну» чисел будь-якої точності потрібно написати власну функцію. Написану функцію можна зробити додатковим методом об'єкту Номер, щось подібне ми вже робили з об'єктом Date(). Детальніше в уроці про об'єкт Object.
toString()
Ну цей метод ми вже детально розібрали на початку уроку.
Створюємо власний метод
А зараз ми створимо той самий метод, який відображатиме число з будь-якою кількістю десяткових знаків із пробілами між тисячними розрядами та з комою як десятковий роздільник.
Для цього нам буде потрібна досить хитромудра функція, яка займатиметься перетворенням рядків і масивів, отриманих з екземпляра об'єкта Номер.
Оголосимо метод:
Number.prototype.toRussianString = toRussianString
Перш ніж приступимо до побудови функції, сформулюємо завдання.
Спочатку нам потрібно уявити число як рядок і витягти з нього цілу частину, дробову частину та точку-розділювач.
Потім розставити в цілій частині необхідні прогалини, округлити дробову частину до кількості символів, яку можна вказати як аргумент функції (і способу), і поміняти крапку на кому.
Почнемо функцію з оголошення необхідних змінних.
function toRussianString(prec) ( /* змінні для перетворення рядків */ var a = "" , b = "" c, d, e;Забігаючи вперед, скажу, що десяткова частина внаслідок наших рядкових пертурбацій втрачає свою «дрібну» сутність, і працювати з нею належить як ще з одним цілим числом. Для роботи з нею скористаємося методом toPrecision(), і аргумент нашої функції (а заразом і нашого методу) задає значення саме для методу toPrecision(). Мінімальний параметр цього методу - одиниця. А для нашої функції може знадобитися нуль (при округленні до цілого числа). І при цьому правильне округлення має спрацювати ще до того, як ми почнемо розчленовувати об'єкт. Тому відразу ж при оголошенні змінних обійдемо цей підводний камінь:
/* змінна, що конвертує в рядок заданий екземпляр об'єкта */ if (prec == 0) var str = this. toFixed(0 ).toStringtoString(10 );Продовжуємо оголошення змінних.
/* змінна для значення, що повертається */ var nr1; /* змінні для частин «розчленування» */ var intpart, fractpaft, precpart, divider, dot = str. lastIndexOf("." ); /* лічильник */ var i;Змінна dotзнаходить позицію точки у рядку вказаного числа. За цією позицією відсікаємо цілу частину ( intpart). Якщо число ціле і точки немає, її позиція буде меншою за нуль. В цьому випадку і роздільник ( divider), та дробова частина ( fractpart) мають бути порожніми рядками. В іншому випадку на роздільник призначається кома, а дробова частина відсікається для подальшої роботи:
if (dot< 0 ) { intpart = str; fractpart = "" ; divider = "" ;) else (intpart=str. substring(0, dot); fractpart = str. substring(dot + 1, str. length); divider = "," ;}Працюємо з цілою частиною. Пробіли потрібні лише в тому випадку, якщо в ній більше 3 символів:
if (intpart. length > 3 ) {Тепер розкладемо наступний «пасьянс» (все це відбувається всередині умовного оператора):
Пройдемо циклом по трійках у зворотному порядку.
Спочатку зберемо їх у змінну aбез будь-яких додавань, просто для того, щоб обчислити довжину підрядки, що утворився. Адже якщо загальна кількість цифр не ділилася на 3, то зліва залишився хвостик з 1 або 2 цифр, і тепер ми можемо висловити і його у вигляді підрядка, відібравши від довжини всього рядка довжину підрядка з «трійками» (змінна c). І поставимо перед ним нерозривну прогалину (яку потім будемо прибирати). Навіщо? Оскільки групи з трьох цифр зчитувалися у зворотному порядку, цей початковий хвостик потрібно помістити до кінця ряду. Тобто, якщо у нас було число, припустимо, 36748521, нам потрібно побудувати 521 748 36, ставлячи перед кожною групою нерозривну прогалину, щоб був роздільник для масиву (адже нам треба перевернути їх назад, а це можна зробити за допомогою методу масиву reverse()).
В останній інструкції циклу ми розставимо у трійках і запишемо результат у змінну b.
for (i=intpart. length-3; i>=0; i-=3) /* збираємо трійки */(a = a + intpart. substr(i, 3); /* знаходимо лівий "хвостик" */ c = " " + intpart. substr(0, intpart. length-a. length); /* Розставляємо в трійках роздільники */ b = b + " " + intpart. substr(i, 3);)При складанні рядків b + cми отримуємо рядок, який потрібно перетворити на масив, а потім цей масив перевернути і знову конвертувати в рядок (це все записується в змінну d).
D = (b+c). split(" " ).reverse().toString().replace(/,/g, " " );
Масив перетворюється на рядок разом із комами-розділювачами, вони нам не потрібні. Тому в цій же інструкції видаляємо їх за допомогою регулярного виразу /, / g, де /,/ створення регулярного вираження для коми, а g«прапорець», який показує, що потрібно замінити всі зразки виразу (просто кажучи всі коми), які зустрінуться в рядку. Замінюємо їх на ті самі нерозривні прогалини.
(Докладно про регулярні висловлювання буде розказано в останній частині посібника.)
А тепер потрібно ще щось почистити (всередині того ж умовного оператора if (intpart.length > 3)).
Справа в тому, що або на початку, або в кінці нашого рядка виявиться зайва нерозривна пробіл, що складається з шести символів: "&", "n", "b", "s", "p" і ";". Тому очистимо сміття та запишемо результат у змінну e:
if (d. substring(0 , 1 ) == "&" ) e = d. substring(6, d. length-6); else e = d. substring(0, d. length-6 );Ось тепер ми можемо із чистою совістю закрити весь умовний оператор та написати альтернативний варіант для короткого числа, яке не потрібно розбивати на «трійки».
) else e = intpart;Отже, змінна eзберігає цілу частину числа, а ми займемося десятковою.
Увага! Коли ми працюємо з дробовою частиною (з якою тепер потрібно поводитися як з цілою), ми повинні пам'ятати, що при prec == 0функція «заартачиться», тому відразу «заб'ємо заглушку»:
if (prec! = 0) (Тепер можна спокійно працювати. Але є ще кілька «камінців», які ми зараз обійдемо.
По-перше, якщо дробова частина у нас, припустимо, 41 , а ми задаємо округлення до 3 знаків, то метод toPrecision, приймаючи нашу дрібну частину за ціле число, виведе 41.0 , Тобто треба прибирати крапку.
По-друге, якщо дробова частина вихідного числа виявиться більше 3 знаків, то метод toPrecisionпочне видавати результат у експоненційній формі. Із цим теж доведеться поборотися.
Тому ми «чиститимемо» результат через три змінні: precpart, precpart1і precpart2.
Precpart = (Number (fractpart)). toPrecision(Prec)). toString(10 )
Тепер «чистимо»:
/* якщо дробова частина є */ if (fractpart != "") ( /* шукаємо та усуваємо крапку */ precpart1 = precpart. replace(".", "") /* проаєряємо, чи немає там експоненти, */ var plus = precpart1.lastIndexOf("e"); /* і якщо вона є, */ if (plus > 0) /* Висмикуємо з коренем, */ precpart2 = precpart1. substring(0, plus); /* в іншому випадку */ else /* нічого не міняємо */ precpart2 = precpart1 /* якщо дробової частини немає, */ else /* то виводимо нулі і знову ж таки позбавляємося точки */ precpart2 = "," + Prepart. replace("." , "" )Оскільки ми на початку вказували, що за відсутності дробової частини у вихідному числі коми немає, то цей випадок нам потрібно її знову поставити.
) else ( /* тобто якщо все-таки prec дорівнює нулю, просто виводимо порожні рядки */ precpart2 = "" ; divider = "" ; }І фінальний акорд:
Nr1 = e + divider + precpart2; return nr1; )
Вся функція повністю:
function toRussianString(prec) ( var a = "" , b = "" c, d, e; if (prec == 0) var str = this. toFixed(0 ).toString(10); else var str = this. toString(10); var nr1; var intpart, fractpaft, precpart, divider, dot = str. lastIndexOf("." ); var i; if (dot< 0 ) { intpart = str; fractpart = "" ; divider = "" ;) else (intpart=str. substring(0, dot); fractpart = str. substring(dot + 1, str. length); divider = "," ;) if (intpart. length> 3) ( for (i=intpart.) length-3; i>=0; i-=3) (a = a + intpart. substr(i, 3); c = " " + intpart. substr(0, intpart. length-a. length); b = b + " " + intpart. substr(i, 3);) d = (b + c). split(" " ).reverse().toString().replace(/,/g, " " ); if (d. substring(0 , 1 ) == "&" ) e = d. substring(6, d. length-6); else e = d. substring(0, d. length-6); ) else e = intpart; if (prec! = 0) (precpart = (Number (fractpart)). toPrecision(Prec)). toString(10) if (fractpart! = "") (precpart1 = precpart. replace(".", "") var plus = precpart1.lastIndexOf("e"); if (plus > 0) precpart2 = precpart1. substring(0, plus); else precpart2 = precpart1 ) else precpart2 = "," + Prepart. replace("." , "" ) ) else ( precpart2 = "" ; divider = "" ; ) nr1 = e + divider + precpart2; return nr1; )Тепер цю функцію можна викликати методом.
Var myNumber = 2569843359.6583521 document. write(MyNumber. toRussianString(3 ))
Результат:
Можете помістити конструктор методу та функцію в бібліотеку - тобто файл.js, який можна викликати з коду web-сторінок. У міру написання методів до різних об'єктів можна розсортувати методи бібліотечних файлів для цих об'єктів і користуватися додатковими методами.
