Неявне перетворення типів даних у JavaScript. Перетворення типів даних на JavaScript. Методи JavaScript перетворення рядків у числа

У JavaScript значення досить вільно (явно і неявно) можуть бути перетворені з одного типу на інший. Наприклад, якщо якийсь оператор очікує отримати значення певного типу, а йому передається значення іншого типу, інтерпретатор автоматично спробує виконати перетворення до потрібного типу:

Console.log(10 + "машин"); // "10 машин". Число неявно перетворюється на рядок console.log("7" * "4"); // 28. Обидва рядки неявно перетворюються на числа

Неявне перетворення- це коли інтерпретатор автоматично виконує перетворення типів, т. е. без участі програміста. Явне перетворення- це коли перетворення виконує програміст. Явне перетворення інакше називають наведенням типів:

Console.log("7" * "4"); // 28. Неявне перетворення console.log(Number("7") * Number("4")); // 28. Явне перетворення

У таблиці нижче описується, як JavaScript виконується перетворення значень з одного типу в інший. Порожні осередки відповідають ситуаціям, коли перетворення не потрібне:

Значення	Перетворення на:
	Рядок	Число	Бульово	Об'єкт
undefined null	"undefined" "null"	NaN 0	false false	помилка typeError помилка typeError
true false	"true" "false"	1 0		new Boolean(true) new Boolean(false)
"" (порожня стрічка) "1.2" "one" "-10" "+10" "011" "0xff"		0 1.2 NaN -10 10 11 255	false true true true true true true	new String("") new String("1.2") new String("one") new String("-10") new String("+10") new String("011") new String("0xff")
0 -0 NaN Infinity -Infinity 3	"0" "0" "NaN" "Infinity" "-Infinity" "3"		false false false true true true	new Number(0) new Number(-0) new Number(NaN) new Number(Infinity) new Number(-Infinity) new Number(3)
() (будь-який об'єкт) (Порожній масив) (1 числовий елемент) arr (будь-який інший масив) function()() (будь-яка функція)	див. Перетворення об'єктів "" "9" див. Перетворення об'єктів див. Перетворення об'єктів	див. Перетворення об'єктів 0 9 NaN NaN	true true true true true

Для явного перетворення на прості типи використовуються такі функції: Boolean() , Number() , String() . При неявному перетворення інтерпретатор використовує самі функції, що використовуються для явного перетворення.

Для явного перетворення можна використовувати оператори замість функції. Наприклад, якщо один з операндів оператора + є рядком, інший операнд також перетворюється на рядок. Унарний оператор + перетворює свій операнд на число. Унарний оператор! перетворює операнд на логічне значення та інвертує його. Все це спричинило появу наступних своєрідних способів перетворення типів, які можна зустріти на практиці:

X + "" // Те саме, що і String (x) + x // Те саме, що і Number (x). Можна також зустріти x - 0 !! х // Те саме, що і Boolean (x)

Перетворення у числа

Функція Number() перетворює значення за такими правилами:

• Логічні значення true і false перетворюються на 1 і 0 відповідно.
• Числа повертаються без зміни.
• Значення null перетворюється на 0 .
• Значення undefined перетворюється на NaN.

Для рядків діють спеціальні правила:

• Якщо рядок містить лише цифри з початковим знаком + або - або без знака, він завжди перетворюється на ціле десяткове число. Початкові нулі ігноруються, наприклад "0011" перетворюється на 11.
• Якщо рядок є числом з плаваючою точкою з початковим знаком + або - або без знака, він перетворюється на відповідне число з плаваючою точкою (початкові нулі також ігноруються).
• Якщо рядок є числом у шістнадцятковому форматі, він перетворюється на відповідне ціле десяткове число.
• Якщо рядок порожній, він перетворюється на 0 .
• Якщо рядок містить щось відмінне від попередніх варіантів, він перетворюється на NaN .
• Для об'єктів викликається метод valueOf() , а значення, що їм повертається, автоматично перетворюється за попередніми правилами. Якщо це перетворення дає в результаті NaN, викликається метод toString() і застосовуються правила перетворення рядків у числа.

Унарні оператори + і - працюють за тими самими правилами, як і функція Number() .

Перетворення на булеві значення

Функція Boolean() перетворює значення на його логічний еквівалент:

• Наступні значення в результаті перетворення дають значення false: undefined, null, 0, -0, NaN, "".
• Значення false повертається без зміни.
• Всі інші значення внаслідок перетворення дають значення true.

Перетворення на рядки

Функція String() перетворює значення за такими правилами:

• Для всіх значень, крім null і undefined, автоматично викликається метод toString() і повертається рядкове подання значення.
• Для значення null повертається рядок "null".
• Для значення undefined повертається рядок "undefined".

Перетворення простих типів на об'єкти

Для перетворення простих значень на об'єкти використовуються конструктори Boolean() , Number() , String() :

Var oNum = New Number(3); var oStr = new String("1.2"); var oBool = новий Boolean(true); alert(typeof oNum); // "object" alert (type of oStr); // "object" alert (type of oBool); // "object"

Перетворення об'єктів у прості значення

Всі об'єкти успадковують два методи перетворення: toString() та valueOf() .

Метод toString() повертає рядкову виставу об'єкта. За умовчанням він нічого цікавого не повертає:

Alert((x: 1).toString()); // ""

Деякі типи мають більш спеціалізовані версії методу toString(). Наприклад, метод toString() у масиву перетворює всі його елементи в рядки і потім об'єднує їх в один рядок, вставляючи коми між ними:

Alert(.toString()); // "1,2,3"

Завдання методу valueOf() визначено не так чітко: передбачається, що він повинен перетворити об'єкт у його просте значення, якщо таке значення існує. Об'єкти за своєю сутністю є складовими значеннями, і більшість об'єктів не можуть бути представлені у вигляді єдиного простого значення, тому за умовчанням метод valueOf() повертає не просте значення, а посилання на нього:

Alert(typeof(x:2).valueOf()); // "object"

При перетворенні об'єкта в рядок інтерпретатор JavaScript виконує такі дії:

• Якщо об'єкт має метод toString(), інтерпретатор викликає його. Якщо він повертає просте значення, інтерпретатор перетворює значення на рядок (якщо воно не є рядком) і повертає результат перетворення.
• Якщо об'єкт не має методу toString() або цей метод не повертає просте значення, інтерпретатор перевіряє наявність методу valueOf() . Якщо цей метод визначено, інтерпретатор викликає його. Якщо він повертає просте значення, інтерпретатор перетворює це значення на рядок (якщо воно не є рядком) і повертає результат перетворення.

При перетворенні об'єкта в число інтерпретатор виконує ті ж дії, але першим намагається застосувати метод valueOf() :

• Якщо об'єкт має метод valueOf() , що повертає просте значення, інтерпретатор перетворює (при необхідності) це значення на число і повертає результат.
• Якщо об'єкт немає методу valueOf() або цей метод не повертає просте значення, то інтерпретатор перевіряє наявність методу toString() . Якщо об'єкт має метод toString() , що повертає просте значення, інтерпретатор виконує перетворення та повертає отримане значення.
• В іншому випадку інтерпретатор робить висновок, що ні toString() ні valueOf() не дозволяють отримати просте значення і збуджує помилку TypeError .

Методи toString() і valueOf() доступні для читання та запису, тому їх можна перевизначити і явно вказати, що буде повертатися під час перетворення:

Var obj = (); obj.toString = function() ( return "об'єкт"; ); alert("Це" + obj); // "Це об'єкт"

Немає різниці в тому, якого типу змінна використовується у виразі. Якщо математичне вираз, всі його змінні автоматично будуть інтерпретовані як числові. Якщо обробляються рядки, всі «учасники» висловлювання розглядаються як рядки. Однак завдання перетворення на JavaScript "рядок у число" існує у значно ширшому контексті.

Методи JavaScript перетворення рядків у числа

Арсенал методів перетворення рядків у числа не великий, але достатній у всіх простих випадках. Тут JavaScript (для початківців особливо) - це шлях від простого до складного на практичних прикладах.

Вам буде цікаво:

У прикладі описано чотири різні рядки. У першому блоці виводу тип кожної змінної функції типувизначається як string. Потім кожен рядок дуже просто перетворюється на число. У другому блоці виведення видно зміни у змінних після перетворення, їх тип став числом. Приклад перетворення JavaScript parseFloat особливо показовий: було "12e+3", стало "12000".

Зміни під час перетворення рядка на число можуть бути істотними! Але мають значення лише перші символи: вони мають бути цифровими. Якщо немає жодного цифрового символу, результат буде NaN.

Зворотне перетворення рядка, що «стало» числом, не завжди такий самий рядок. Цей момент можна використовувати для перевірки правильності введення чисельної інформації.

The parseInt()функція поєднується з string argument і returns integer of the specified radix (the base in mathematical numeral systems).

Source для цього interactive example is stored in GitHub repository. Якщо ви знайдете, щоб розширити проектні приклади, повторити clone https://github.com/mdn/interactive-examples і виконати додаткові запити.

Syntax

parseInt(string , radix)

Parameters

string The value to parse. Якщо цей argument не є string, то це ведеться до одного з використанням ToString abstract operation. Leading whitespace в цей argument is ignored. radix Optional An integer між 2 і 36 що представляють radix (основу в математичних номерних системах) of string . Be careful-this does not default to 10! The explains in more detail what happens when radix is ​​not provided.

Return value

An integer parsed from the given string .

Якщо дихання є смаллер не 11 , і першим не будь-яким простим характером не може бути перераховано на номер, NaN є відновлено.

Description

ПірсІнші функції перетворюють його в першу чергу на string, з'являються, що string, будуть відновити integer або NaN .

Якщо не NaN , то оборотна величина буде бути всередині , що є першим argumentом , як номер в особливих radix . (Наприклад, редагування 10 конвертів від десяткового числа, 8 конвертів від octal, 16 від hexadecimal, і so on.)

Для radices above 10 , Letters of English alfabet indicate numerals greater than 9 . Для прикладу, для hexadecimal numbers (base 16), за допомогою F are used.

Якщо parseInt encounters character that is not numeral in the specified radix , it ignores it and all succeeding characters and returns the integer value parsed up to point. parseInt truncates numbers до integer values. Leading and trailing spaces allow allowed.

Тому деякі номери використовують e-character в їхній string representation (e.g. 6.022e23для 6.022 × 10 23), використовуючи периферіюВін для нумерації номерів буде виробляти невизначені результати при використанні на дуже великі або дуже маленькі номери. parseInt should not be used as substitute for Math.floor() .

parseInt understands exactly два signs: + for positive, and - for negative (since ECMAScript 1). Це робиться як початковий хід в ходьбі з whitespace is removed. Якщо немає сигналів, ви знайдете, algoritm moves to following step; іншіwise, it removes the sign and runs the number-parsing on the rest of the string.

Якщо radix is ​​undefined , 0 , або unspecified, JavaScript розуміє, що:

1. Якщо вхідний рядок запису з "0x" або "0X" (на 0, наведено внизу або внизу X), рішучість є прийнята до 16 років і залишок string є зафіксований як hexidecimal number.
2. Якщо вводити string починаючи з "0" (а cero), радіс is assumed to be 8 (octal) or 10 (decimal). Фактично, який радіс є chosen є implementation-dependent. ECMAScript 5 clarifies that 10 (decimal) should be used, but not all browsers support this yet. For this reason, always specify a radix when using parseInt.
3. Якщо вхідні string починаються з будь-якою іншою величиною, radix is ​​10 (decimal).

Якщо перший показник може не бути введений до номера, ParseInt returns NaN unless the radix is ​​bigger than 10 .

Для аритметичних цінностей, NaN value is not a number in any radix. Ви можете зателефонувати isNaN функцію до значення, якщо результат parseInt is NaN . Якщо NaN йде на аритмічних операціях, результат виконання буде на NaN .

Наведіть номер до його string literal в особливу radix, use thatNumber .toString(radix) .

Examples

Using parseInt

The following examples all return 15:

ParseInt("0xF", 16) parseInt("F", 16) parseInt("17", 8) parseInt(021, 8) parseInt("015", 10) // but `parseInt(015, 10)` will return 13 parseInt(15.99, 10) parseInt("15,123", 10) parseInt("FXX123", 16) parseInt("1111", 2) parseInt("15 * 3", 10) parseInt("15 parseInt("15px", 10) parseInt("12", 13)

The following examples all return NaN:

ParseInt("Hello", 8) // Немає номера на всіх parseInt("546", 2) // Digits інші не 0 або 1 є неправильним для binary radix

Наведені нижче описи all return -15:

ParseInt("-F", 16) parseInt("-0F", 16) parseInt("-0XF", 16) parseInt(-15.1, 10) parseInt("-17", 8) parseInt("-15", 10) parseInt("-1111", 2) parseInt("-15e1", 10) parseInt("-12", 13)

The following examples all return 4:

ParseInt(4.7, 10) parseInt(4.7 * 1e22, 10) // Very large number becomes 4 parseInt(0.000000000000434, 10) // Very small number becomes 4

The following example returns 224:

ParseInt("0e0", 16) parseInt("123_456") // 123

Octal interpretations with no radix

Although discouraged by ECMAScript 3 і призначений ECMAScript 5, багато implementation interpret numerical string beginning with leading 0 as octal. Наступний може мати octal result, або він може мати decimal result. Always specify a radix до avoid це unreliable behavior.

ParseInt("0e0") // 0 parseInt("08") // 0, тому "8" is not an octal digit.

ECMAScript 5 removes octal interpretation

ECMAScript 5 specification of the function parseInt longer allows implementations to treat Strings beginning with a 0 characters as octal values. ECMAScript 5 states:

ПірсІншої функції виробляють integer value dictated by interpretation of contents of string argument argumenting the specified radix. Leading white space в string is ignored. Якщо редагування є невизначеним або 0 , то це означає, що до 10 except, коли номер починається з параметром розміру 0x або 0X, в якому випадку редагування 16 є зарахованим.

Це різняться з ECMAScript 3, які розрізняються, але дозволяють octal interpretation.

Багато implementations не adopted this behavior as of 2013, and because older browsers must be supported, always specify a radix.

A stricter parse функція

Це є деякими можливими для того, щоб мати стриманий спосіб до періодів.

Regular expressions can help:

Function filterInt(value) ( ​​if (/^[-+]?(\d+|Infinity)$/.test(value)) ( return Number(value) ) else ( return NaN ) ) console.log(filterInt("421 ")) // 421 console.log(filterInt("-421")) // -421 console.log(filterInt("+421")) // 421 console.log(filterInt("Infinity")) // Infinity console.log(filterInt("421e+0")) // NaN console.log(filterInt("421hop")) // NaN console.log(filterInt("hop1.61803398875")) // NaN console.log (filterInt("1.61803398875")) // NaN

Specifications

Specification	Status	Comment
ECMAScript 1st Edition (ECMA-262)	Standard	Initial definition.
ECMAScript 5.1 (ECMA-262)	Standard
ECMAScript 2015 (6th Edition, ECMA-262) Визначення "parseInt" в цій specification.	Standard
ECMAScript Latest Draft (ECMA-262) Визначення "parseInt" в цій specification.	Draft

Browser compatibility

Компактність таблиці на цій сторінці генерується з структурованих даних. Якщо ви знайдете, щоб дізнатися про ваші дані, клацніть на https://github.com/mdn/browser-compat-data і пишуть.

Update compatibility data on GitHub

	Desktop						Mobile						Server
	Chrome	Edge	Firefox	Internet Explorer	Opera	Safari	Android webview	Chrome для Android	Firefox for Android	Opera for Android	Safari on iOS	Samsung Internet	Node.js
parseInt	Chrome Full support 1	Edge Full support 12	Firefox Full support 1	IE Full support 3	Opera Full support Yes	Safari Full support Yes	WebView Android Full support 1	Chrome Android Full support 18	Firefox Android Full support 4		Safari iOS Full support Yes	Samsung Internet Android Full support 1.0	nodejs Full support Yes
Parses leading-zero strings є decimal, не octal	Chrome Full support 23	Edge Full support 12	Firefox Full support 21	IE Full support 9	Opera Full support Yes	Safari Full support 6	WebView Android Full support 4.4	Chrome Android Full support 25	Firefox Android Full support 21	Opera Android Full support Yes	Safari iOS Full support 6	Samsung Internet Android Full support Yes	nodejs Full support Yes

Здрастуйте, дорогі читачі. Сьогодні я напишу, як перетворюється на javascriptрядок у число. Це робиться за допомогою функції Number, зараз я покажу її використання на прикладі.
Також пропоную переглянути відео-версію цієї статті:

Трохи про типи даних

Як ви знаєте, у JavaScript є числовий і рядковий тип даних. Спробуймо створити дві змінні, в які збережемо числа, а потім виведемо результат на екран.

Var a = 5; var b = 12; document.write(a + b);

Яким буде результат? 17, що й вивів нам браузер. Отже, це числові дані, тому браузер успішно склав їх. А тепер давайте створимо дві інші змінні, в які покладемо такі ж значення, але в лапках. Я нагадаю, всі рядки в JavaScript пишуться саме в лапках.

Var c = "5"; var d = "12"; document.write("
+ c + d);

Тепер браузер вважає наші дані рядками і якщо ми їх складемо, то просто будуть складені два рядки і ми отримаємо 512, що не є правильним результатом, якщо б складалися числа, але є правильним, якщо поставити разом два рядки.

Як перетворити в JavaScript рядок у число?

Тут все просто, створимо чергові дві змінні, в які запишемо те саме значення, що задано змінним c і d, але пропустивши їх через метод Number:

Var e = Number (c); var f = Number(d); document.write(e + f);

Якщо ви тепер спробуєте вивести результат від цієї додавання на екран, то виведеться 17. Все тому, що наш метод успішно відпрацював і перетворив рядок на число. Хочу наголосити, що якщо ви напишіть так:

Document.write("
+ e + f);

То на екран виведеться 512, тому що при складанні рядків та чисел ЗАВЖДИрезультат перетворюється на рядок. Якщо ви хочете додати перенесення рядка і при цьому зберегти правильний результат, можна записати все в два рядки або в одне так:

Document.write("
+ (e + f));

Якщо взяти числа в дужки, то вони не будуть перетворені на рядки та успішно збережуть свої властивості. Ось така коротка стаття у мене сьогодні. Сподіваюся, javascript став для вас трохи зрозумілішим.

У JavaScript існують 2 вбудовані функції перетворення рядків у числа: parseFloat() і parseInt() .

parseFloat() приймає аргументом рядок, який необхідно привести до чисельного типу, та повертає число типу float. Число має утримуватися на початку рядка. Якщо після числа у рядку йдуть ще якісь символи, вони відсікаються. Дробова частина числа має бути записана через точку (кома не сприймається як роздільник). Якщо parseFloat() не може перетворити рядок, то вона повертає NaN.

Також функція може обробити «число n, помножене на 10 ступенем x», яке в програмуванні прийнято записувати через букву E, наприклад: 0.5E6 або 0.5E+6. Ступінь може бути також негативною: 0.5E-6, що дорівнює 0.5*10^-6 або 0.5/1000000.

ParseFloat("3.78kg") // 3.78 parseFloat("kg33") // NaN parseFloat("0004.111") // 4.111 parseFloat("0x66") // 0 parseFloat("". 5"") // 0.5 parseFloat(""-.5"") // -0.5 parseFloat(""0.5e6"") // 500000 parseFloat(""0.03E+2"") // 3 parseFloat(" "3E-4"") // 0.0003 parseFloat(""-3E-4"") // -0.0003

Функція parseInt(string[, radix]) приймає як перший аргумент рядок, аналізує його і повертає ціле число (тип integer). Функція намагається аналізувати систему числення, в якій записано число у вихідному рядку (наприклад, десятковий, вісімковий або шістнадцятковий — але не тільки ці). Також систему числення можна вказати очевидно, передавши її другим параметром radix. Параметр radix може приймати будь-яке число від 2 до 36 (у системах вище 10 використовуються літери англійського алфавіту, від A до Z).

Числа типу 1.5e6 функція не обробляє так, як parseFloat() .

Будь ласка, ознайомтеся з прикладами нижче, щоб не наколотися на підводні камені, заховані в роботі функції parseInt() .

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045"",10) // 45 parseInt( ""70"",8) // 56 (70 у вісімковій системі це 56 у десятковій) parseInt(""070"") // 56 (ВАЖЛИВО!!! нуль спочатку змусить функцію проаналізувати рядок як вісімкове число) parseInt(" "88"",8) // NaN (у вісімковій системі немає цифри 8) parseInt(""a1"") // NaN (ВАЖЛИВО!!! Функція за замовчуванням не сприймає число як 16-річне, якщо не дописати на початку рядки 0x) parseInt(""a1"",16) // 161 (тут явно вказана система числення) parseInt(""0xa1"") // 161 (правильний формат 16-річного числа, можна не вказувати другий параметр) parseInt( ""099"") // 0 (ВАЖЛИВО!!! Число сприймається як вісімкове, але містить неприпустимі символи) parseInt(""0.5e6"") // 0 (ВАЖЛИВО!!! не працює як parseFloat) parseInt("" ZZ"",36) // 1295 parseInt("-FF"") // NaN parseInt(""-FF"",16) // -255

Якщо Ви обробляєте дані з текстового поля, які вводить користувач, завжди використовуйте parseInt() разом із другим параметром radix, це убезпечить Ваш код від несподіваних результатів.