Синтаксис JavaScript parseInt: примеры использования. Более строгая функция интерпретации

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

Синтаксис

parseInt(string , radix );

Параметры

string Значение, которое необходимо проинтерпретировать. Если значение параметра string не принадлежит строковому типу, оно преобразуется в него (с помощью абстрактной операции ToString). Пробелы в начале строки не учитываются. radix Целое число в диапазоне между 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 (/^(\-|\+)?(+|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

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

Спецификация	Статус	Комментарий
ECMAScript 1st Edition (ECMA-262)	Стандарт	Изначальное определение.
ECMAScript 5.1 (ECMA-262)	Стандарт
ECMAScript 2015 (6th Edition, ECMA-262) Определение "parseInt" в этой спецификации.	Стандарт
ECMAScript Latest Draft (ECMA-262) Определение "parseInt" в этой спецификации.	Черновик

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

The compatibility table on this page is generated from structured data. If you"d like to contribute to the data, please check out https://github.com/mdn/browser-compat-data and send us a pull request.

Update compatibility data on GitHub

	Компьютеры						Мобильные							Server
	Chrome	Edge	Firefox	Internet Explorer	Opera	Safari	Android webview	Chrome для Android	Edge Mobile	Firefox для Android	Opera для Android	Safari on iOS	Samsung Internet	Node.js
Базовая поддержка	Chrome Полная поддержка Да	Edge Полная поддержка Да	Firefox Полная поддержка 1	IE Полная поддержка Да	Opera Полная поддержка Да	Safari Полная поддержка Да	WebView Android Полная поддержка Да	Chrome Android Полная поддержка Да	Edge Mobile Полная поддержка Да	Firefox Android Полная поддержка 4	Opera Android Полная поддержка Да	Safari iOS Полная поддержка Да	Samsung Internet Android Полная поддержка Да	nodejs Полная поддержка Да
Parses leading-zero strings are decimal, not octal	Chrome Полная поддержка 23	Edge Полная поддержка Да	Firefox Полная поддержка 21	IE Полная поддержка 9	Opera Полная поддержка Да	Safari Полная поддержка 6	WebView Android Полная поддержка 4.4	Chrome Android Полная поддержка Да	Edge Mobile Полная поддержка Да	Firefox Android Полная поддержка 21	Opera Android Полная поддержка Да	Safari iOS Полная поддержка 6	Samsung Internet Android Полная поддержка Да	nodejs Полная поддержка Да

Распознать в строке число и быть уверенным, что в алгоритме используется значение переменной, тип которой - число, необходимо почти в каждом алгоритме. Метод JavaScript parseInt решает эту задачу и позволяет распознавать числовые значения в популярных системах счисления.

Синтаксис метода parseInt

Метод принимает два параметра, второй из которых не обязательный. Результат работы - всегда число. Если первый параметр (строка) не содержит в начале символов системы счисления, то результатом будет NaN.

К цифрам шестнадцатеричной системы счисления относятся буквы: "a", "b", "c", "d", "e" и "f". Признаком восьмеричного числа является начальный "0", а шестнадцатеричного начальная пара "0x". Но не всегда преобразование будет выполнено верно, хотя синтаксически оно обозначено корректно.

Функция парсинга чисел - востребованная операция. В самом простом случае метод parseInt JavaScript и prompt позволяют фильтровать ввод правильных цифровых значений для принятия быстрых решений.

Примечание. Функция promt() - вводит то, что набрал посетитель в поле ввода, а не "результат" кнопок Ok или Cancel. Именно поэтому для получения быстрых значений можно на лету отследить содержание ввода посетителя и принять правильное решение.

Применение метода parseInt

Интернет-программирование имеет свою специфику и оказывает сильное влияние на идеи программирования вообще. Слияние маленьких данных в одно емкое "слово" - параметр, основные качества которого:

компактность;
быстрая распознаваемость.

Во многих случаях самые большие "любители" этого фактора CSS и HTML стали писать число, а затем сразу без пробела единицу измерения или знак препинания. Иначе говоря - составлять строгие символьные последовательности.

Регулярные выражения вообще, для непосвященного в таинства парсинга, представляют собой азбуку морзе, в которой каша из точек и тире "разведена" почти на все символы традиционного восьмибитного набора. Причем все, что не входит в видимую часть символьной таблицы, можно легко расписать кодами, то есть числами и буквами - это и есть метод JavaScript parseInt.

Многие параметры некоторых функций CSS не допускают пробело, и работают только тогда, когда они записаны исключительно по точному стандарту.

Язык XML при всей своей открытости не допускает вольностей при кодировании параметрической информации.

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

Значение числового парсинга

Разбор информации - символьная процедура, но программирование сегодня - это все та же обработка числовой информации, как и три десятка лет назад. В прошлом не было JavaScript & parseInt. Но именно из опыта прошлого пришло знание об обработке числовой информации, был накоплен потенциал для регулярных выражений и других подобных идей.

В определенный период времени языки программирования допустили "вольности" в ключевых словах, "разблокировали" кириллицу и позволили разработчику обрабатывать слабо формализованные данные. Но этот период был краток, а с усилением интереса к объектно-ориентированному программированию образовалась "черная дыра" между тем:

как делать;
что делать.

Современный язык программирования вообще (хотя значение языка JavaScript трудно оценить в общем) обязан отделить инструмент работы от предмета работы. Инструмент должен быть точным и быстрым, а предмет работы может быть сколь угодно большим и практически неформализованным. Но результат работы программы с каждым моментом времени становится существеннее.

Разработка объектов без JavaScript parseInt - неоправданная трата сил, времени и кода. Методы объекта должны работать как часы, быстро и точно. Но предмет для работы объекта - информация, результат работы объекта - тоже информация. И понимать здесь под объектом вовсе не обязательно концепцию JavaScript, PHP или Python ... - это частные варианты и стили кодирования реальных объектов.

Функция ParseInt предназначена для преобразования в JavaScript строки в число. Метод принимает в качестве аргумента строчное значение и преобразует его в число без знаков после запятой, или в качестве альтернативы выдается значение NaN . ParseInt принимает два аргумента. Второй параметр определяет систему исчисления, которая будет использоваться при преобразовании значения строки в число.

Простой пример с использованием десятичной системы исчисления выглядит следующим образом:

var x = "1"; console.log(x, typeof x); //1 строка x = parseInt(x, 10); console.log(x, typeof x); //1 число Онлайн пример кода

Если для значения системы исчисления аргумент не передается, будет использоваться значение по умолчанию (базовая десятичная система ). Также можно задать значение 2 , чтобы указать функции использовать двоичную систему исчисления. Значение 8 указывает ParseInt использовать восьмеричную систему, а значение 16 указывает — шестнадцатеричную. Для систем исчисления с основанием больше 10 вместо чисел больше 9 используются буквы алфавита.

Перед тем, как в JavaScript преобразовать строку в число, рассмотрим пример преобразования двоичного числа в целое число в десятичной системе исчисления:

var x = 10; x = parseInt(x, 2); console.log(x); //2 Онлайн пример кода

Переменная х получает значение 10 . В двоичной системе значение 10 (то есть, «один, ноль» ) эквивалентно 2 в десятичной системе. Мы передали в функцию ParseInt 10 и указали в качестве системы исчисления двоичную. Функция вернула значение 2 , которое является целым числом, эквивалентным «один, ноль «.

А что произойдет, если мы передадим в функцию ParseInt десятичное число с одним или несколькими знаками после запятой? Давайте посмотрим:

var x = 3.14; x = parseInt(x, 10); console.log(x); //3 Онлайн пример кода

Функция ParseInt приняла числовое значение со знаками после запятой и привела его к целому. Но, что если нужно осуществить в JavaScript преобразование строки в число? Вот пример:

var x = "Hola World!"; x = parseInt(x, 10); console.log(x); //NaN ...или Not a Number Онлайн пример кода

Если в ParseInt передается аргумент, который не может быть просто преобразован в числовое значение, то возвращаемое значение будет — NaN (или не число ). Если в функцию передается сочетание числовых и буквенных строковых значений, то она будет преобразовывать числовые символы в целые числа и отбрасывать остальные:

var x = "123UnoDosTres";

Explore JavaScript Courses

x = parseInt(x, 10); console.log(x); //123 Онлайн пример кода

Это основные принципы использования функции ParseInt . Следует помнить, что основная цель ParseInt – JavaScript перевод строки в число (без знаков после запятой ). Также можно указать систему исчисления, которую нужно использовать. Если функции передается значение, которое не может быть преобразовано в число, то ParseInt возвращает значение NaN .

Дополнительную информацию о JavaScript-функции ParseInt можно найти здесь .

Перевод статьи «Using the JavaScript ParseInt Method » был подготовлен дружной командой проекта .

Хорошо Плохо