Как привести к числу javascript

parseInt()

Функция parseInt() принимает строку в качестве аргумента и возвращает целое число в соответствии с указанным основанием системы счисления.

Интерактивный пример

Синтаксис

parseInt(string, radix);

Параметры

Значение, которое необходимо проинтерпретировать. Если значение параметра string не принадлежит строковому типу, оно преобразуется в него (с помощью абстрактной операции ToString ). Пробелы в начале строки не учитываются.

Целое число в диапазоне между 2 и 36, представляющее собой основание системы счисления числовой строки string , описанной выше. В основном пользователи используют десятичную систему счисления и указывают 10. Всегда указывайте этот параметр, чтобы исключить ошибки считывания и гарантировать корректность исполнения и предсказуемость результата. Когда основание системы счисления не указано, разные реализации могут возвращать разные результаты.

Возвращаемое значение

Целое число, полученное парсингом (разбором и интерпретацией) переданной строки. Если первый символ не получилось сконвертировать в число, то возвращается NaN .

Описание

Функция parseInt преобразует первый переданный ей аргумент в строковый тип, интерпретирует его и возвращает целое число или значение NaN . Результат (если не NaN ) является целым числом и представляет собой первый аргумент ( string ), рассматривающийся как число в указанной системе счисления ( radix ). Например, основание 10 указывает на преобразование из десятичного числа, 8 — восьмеричного, 16 — шестнадцатеричного и так далее. Если основание больше 10 , то для обозначения цифр больше 9 используются буквы. Например, для шестнадцатеричных чисел (основание 16) используются буквы от A до F .

Если функция parseInt встречает символ, не являющийся числом в указанной системе счисления, она пропускает этот и все последующие символы (даже, если они подходящие) и возвращает целое число, преобразованное из части строки, предшествовавшей этому символу. parseInt отсекает дробную часть числа. Пробелы в начале и конце строки разрешены.

Так как некоторые числа включают символ e в своём строковом представлении (например, 6.022e23 ), то использование parseInt для усечения числовых значений может дать неожиданные результаты, когда используются очень малые или очень большие величины. parseInt не должна использоваться как замена для Math.floor() .

Если основание системы счисления имеет значение undefined (не определено) или равно 0 (или не указано), то JavaScript по умолчанию предполагает следующее:

• Если значение входного параметра string начинается с » 0x » или » 0X «, за основание системы счисления принимается 16, и интерпретации подвергается оставшаяся часть строки.
• Если значение входного параметра string начинается с «0», за основание системы счисления принимается либо 8, либо 10, в зависимости от конкретной реализации. В спецификации ECMAScript 5 прописано использование 10 (десятичная система), но это поддерживается ещё не всеми браузерами, поэтому необходимо всегда указывать основание системы счисления при использовании функцииparseInt .
• Если значение входного параметра string начинается с любого другого символа, система счисления считается десятичной (основание 10).

Если первый символ строки не может быть преобразован в число, parseInt возвращает значение NaN .

С точки зрения математики, значение NaN не является числом в какой-либо системе счисления. Чтобы определить, вернёт ли parseInt значение NaN в качестве результата, можно вызвать функцию isNaN . Если NaN участвует в арифметических операциях, результатом также будет NaN .

Для преобразования числа в строку в указанной системе счисления, используйте intValue.toString(radix) .

Примеры

Пример: Использование parseInt

Все следующие примеры возвращают 15 :

parseInt(" 0xF", 16); parseInt(" F", 16); parseInt("17", 8); parseInt(021, 8); parseInt("015", 10); //parseInt(015, 10); вернёт 15 parseInt(15.99, 10); parseInt("FXX123", 16); parseInt("1111", 2); parseInt("15*3", 10); parseInt("15e2", 10); parseInt("15px", 10); parseInt("12", 13); 

Все следующие примеры возвращают NaN :

parseInt("Hello", 8); // Не является числом parseInt("546", 2); // Неверное число в двоичной системе счисления 

Все следующие примеры возвращают -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); 

Все следующие примеры возвращают 4 :

parseInt(4.7, 10); parseInt(4.7 * 1e22, 10); // Очень большие числа становятся 4 parseInt(0.00000000000434, 10); // Очень маленькие числа становятся 4 

Следующий пример возвращает 224 :

parseInt("0e0", 16); 

Восьмеричная интерпретация без указания системы счисления

Хотя это не поощряется в спецификацией ECMAScript 3 и запрещено в ECMAScript 5, многие реализации интерпретируют числовую строку, начинающуюся с 0 , как восьмеричную. Следующий пример может иметь как восьмеричный, так и десятичный результат. Чтобы избежать непредвиденного результата, всегда указывайте основание системы счисления.

parseInt("0e0"); // 0 parseInt("08"); // 0, '8' не является цифрой в восьмеричной системе. 

ECMAScript 5 устраняет восьмеричную интерпретацию

Спецификация ECMAScript 5 функции parseInt больше не разрешает трактовать в восьмеричной системе счисления строки, начинающиеся с 0 . ECMAScript 5 провозглашает:

Функция parseInt производит целочисленное значение в результате интерпретации содержимого строкового аргумента в соответствии с указанным основанием системы счисления. Пробел в начале строки не учитывается. Если основание системы счисления не определено или равно 0 , оно считается равным 10 , за исключением случаев, когда строка начинается с пар символов 0x или 0X : тогда за основание принимается 16. Если основанием системы счисления указано 16 , число также может начинаться с пар символов 0x или 0X .

В этом ECMAScript 5 расходится со спецификацией ECMAScript 3, в которой восьмеричная интерпретация не поощрялась, но и не была запрещена.

Поскольку на момент 2013 года описанное выше поведение было применено не во всех реализациях, а поддержка старых браузеров является необходимой, всегда указывайте основание системы счисления.

Более строгая функция интерпретации

Иногда необходим более строгий способ интерпретации целочисленных значений. В этом могут помочь регулярные выражения:

var filterInt = function (value)  if (/^(\-|\+)?([0-9]+|Infinity)$/.test(value)) return Number(value); 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 

Спецификация

Поддержка браузерами

BCD tables only load in the browser

Смотрите также

• parseFloat()
• Number.parseFloat()
• Number.parseInt()
• isNaN()
• Number.toString()
• Object.valueOf

Found a content problem with this page?

• Edit the page on GitHub.
• Report the content issue.
• View the source on GitHub.

This page was last modified on 7 авг. 2023 г. by MDN contributors.

Your blueprint for a better internet.

Как привести к числу javascript

Когда мы складываем 5 и 5 , то ожидаем увидеть вывод — 10 . Однако, получаем 55 и видим, что тип данных — не число, а строка.

Язык JavaScript автоматически преобразовал переменную a в строку и соединил ее с переменной b в одну строку.

Чтобы тип данных был ожидаем для разработчика, используют функции преобразования. Рассмотрим их подробно.

Больше полезных материалов вы найдете на нашем телеграм-канале «Библиотека фронтендера»

Преобразование в строку в JavaScript

Чтобы преобразовать число в строку используют функцию String() .

var a = 5; //число a = String(a);//преобразует переменную а в строку alert(typeof(a));//выведет string 

Преобразование в число в JavaScript

Чтобы преобразовать данные в число используют функцию Number() . Попробуем преобразовать строковое значение 5 в число.

var a = "5";//строка a = Number(a); //преобразует переменную а в число alert(typeof(a));//выведет number 

Если вы будете использовать в математических выражениях строки, то JavaScript автоматически преобразует переменные в числа.

var a = "5"; //строка var b = "5"; //строка var c = a/b; alert(c);//выведет 1, что мы и ожидаем при делении 5 на 5 alert(typeof(c));// выведет number 

Логическое преобразование в JavaScript

Для логического преобразования используют функцию Boolean() .

Данные типа пустая строка , NaN , undefined , null — преобразуются в false .

Все остальные данные: числа и строки, преобразуются в true .

var a = "null"; alert(Boolean(a));//выведет false 

var a = "0"; alert(Boolean(a));//выведет true 

var a = " ";//пробел alert(Boolean(a));//выведет true 

var a = "";//пусто, без пробелов и других знаков alert(Boolean(a));//выведет false 

Подведем итоги

JavaScript может преобразовывать данные автоматически:

• число преобразуются в строки, если их использовать в выражениях со строкой;
• если в строках находятся числа и с ними выполняют математические операции, то они преобразуются в числа.

Для преобразования используют функции:

1. String() — преобразует данные в строки.
2. Number() — преобразует данные в числа.
3. Boolean() — преобразует данные в логические значения true или false.

Материалы по теме

• ☕�� Методы массивов в JavaScript для новичков: советы, рекомендации и примеры
• ☕ 5 крутых функций JavaScript, о которых не знает большинство разработчиков
• ☕ Твой JavaScript должен быть проще: 10 приемов современного разработчика

Преобразование типов для примитивов

Материал на этой странице устарел, поэтому скрыт из оглавления сайта.

Более новая информация по этой теме находится на странице https://learn.javascript.ru/type-conversions.

Система преобразования типов в JavaScript очень проста, но отличается от других языков. Поэтому она часто служит «камнем преткновения» для приходящих из других языков программистов.

Всего есть три преобразования:

1. Строковое преобразование.
2. Численное преобразование.
3. Преобразование к логическому значению.

Эта глава описывает преобразование только примитивных значений, объекты разбираются далее.

Строковое преобразование

Строковое преобразование происходит, когда требуется представление чего-либо в виде строки. Например, его производит функция alert .

var a = true; alert( a ); // "true"

Можно также осуществить преобразование явным вызовом String(val) :

alert( String(null) === "null" ); // true

Как видно из примеров выше, преобразование происходит наиболее очевидным способом, «как есть»: false становится «false» , null – «null» , undefined – «undefined» и т.п.

Также для явного преобразования применяется оператор «+» , у которого один из аргументов строка. В этом случае он приводит к строке и другой аргумент, например:

alert( true + "test" ); // "truetest" alert( "123" + undefined ); // "123undefined"

Численное преобразование

Численное преобразование происходит в математических функциях и выражениях, а также при сравнении данных различных типов (кроме сравнений === , !== ).

Для преобразования к числу в явном виде можно вызвать Number(val) , либо, что короче, поставить перед выражением унарный плюс «+» :

var a = +"123"; // 123 var a = Number("123"); // 123, тот же эффект

// после обрезания пробельных символов останется "123" alert( +" \n 123 \n \n" ); // 123

alert( +true ); // 1 alert( +false ); // 0

alert( "\n0 " == 0 ); // true

alert( "\n" == false ); alert( "1" == true );

Специальные значения

Посмотрим на поведение специальных значений более внимательно.

Интуитивно, значения null/undefined ассоциируются с нулём, но при преобразованиях ведут себя иначе.

Специальные значения преобразуются к числу так:

Это ведёт к забавным последствиям.

Например, null не подчиняется законам математики – он «больше либо равен нулю»: null>=0 , но не больше и не равен:

alert( null >= 0 ); // true, т.к. null преобразуется к 0 alert( null > 0 ); // false (не больше), т.к. null преобразуется к 0 alert( null == 0 ); // false (и не равен!), т.к. == рассматривает null особо.

Значение undefined вообще «несравнимо»:

alert( undefined > 0 ); // false, т.к. undefined -> NaN alert( undefined == 0 ); // false, т.к. это undefined (без преобразования) alert( undefined < 0 ); // false, т.к. undefined ->NaN

Для более очевидной работы кода и во избежание ошибок лучше не давать специальным значениям участвовать в сравнениях > >= <

alert( !!"0" ); // true alert( !!" " ); // любые непустые строки, даже из пробелов - true!

alert( 0 == "\n0\n" ); // true

if ("\n0\n")