Как преобразовать строку в целое число в JavaScript?

1697

Как мне преобразовать строку в целое число в JavaScript?

cubuspl42
источник
1
На этой странице есть большая таблица внизу, в которой сравниваются различные методы конвертации: medium.com/@nikjohn/…
Джон Гилмер

Ответы:

2154

Самый простой способ - использовать встроенную Numberфункцию:

var x = Number("1000")

Если это не работает для вас, то есть методы parseInt , unary plus , parseFloat with floor и Math.round .

ParseInt:

var x = parseInt("1000", 10); // you want to use radix 10
    // so you get a decimal number even with a leading 0 and an old browser ([IE8, Firefox 20, Chrome 22 and older][1])

унарный плюс, если ваша строка уже в форме целого числа:

var x = +"1000";

если ваша строка является или может быть плавающей точкой, и вы хотите целое число:

var x = Math.floor("1000.01"); //floor automatically converts string to number

или, если вы собираетесь использовать Math.floor несколько раз:

var floor = Math.floor;
var x = floor("1000.01");

Если вы тот тип, который забывает вводить основание при вызове parseInt, вы можете использовать parseFloat и округлить его так, как вам нравится. Здесь я использую пол.

var floor = Math.floor;
var x = floor(parseFloat("1000.01"));

Интересно, что Math.round (например, Math.floor) будет выполнять преобразование строки в число, поэтому, если вы хотите, чтобы число округлялось (или если в строке было целое число), это отличный способ, может быть, мой любимый:

var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)
Nosredna
источник
1
jsperf.com/performance-of-parseint/29 , hy @jedierikb Я редактировал ссылку на jsperf. Добавление '4'>>0и '4'>>>0.
emaniacs
6
Обновление до 2015 года: начиная с ECMAScript 5, строки с начальным нулем "0" также получают по умолчанию основание 10 вместо 8. Явное указание значения 10 необходимо только для старых браузеров. kangax.github.io/compat-table/es5/…
Grilse
20
Обратите внимание, что Number ('') завершается успешно (возвращает 0), хотя большинство людей не считают, что пустая строка представляет допустимое число. И parseInt ('3q') завершается успешно (возвращая 3), даже если большинство людей не сочтут 3q допустимым числом.
Дэйв Пачеко
3
Берегись. Оба parseIntи с parseFloatудовольствием принимают письма. Только Numberвозвращается NaNпоследовательно.
Карл Покус
2
По моему мнению, синтаксический анализ целого числа должен приводить к исключению / NaNдля каждого значения, которое не является целым числом. Поэтому нет ни один из них не работает , как Number('2.2')принуждают к 2и Number('')принуждать к 0.
Михал Knapik
225

Попробуйте функцию parseInt:

var number = parseInt("10");

Но существует проблема. Если вы попытаетесь преобразовать «010» с помощью функции parseInt, она обнаружит восьмеричное число и вернет число 8. Итак, вам нужно указать основание (от 2 до 36). В этом случае база 10.

parseInt(string, radix)

Пример:

var result = parseInt("010", 10) == 10; // Returns true

var result = parseInt("010") == 10; // Returns false

Обратите внимание, что parseIntигнорирует неверные данные после анализа чего-либо действительного.
Этот гид будет разобрать как

var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true
Zanoni
источник
4
Radix больше не требуется в 2016 году.
7
Это может быть не для новых браузеров, но основа все еще требуется для обратной совместимости.
профессор программирования
как насчет '', или '02 ', или' 02 + 1 ', или' 03,12 ', или' 03.12 '?
stackdave
3
Обратите внимание, что это игнорирует неверные данные после числа. Например, parseInt('0asdf', 10)производит 0.
Сэм
121

Есть два основных способа преобразовать строку в число в JavaScript. Одним из способов является его разбор, а другим способом - изменить его тип на Number. Все приемы в других ответах (например, унарный плюс) включают в себя неявное приведение типа строки к числу. Вы также можете сделать то же самое явно с помощью функции Number.

анализ

var parsed = parseInt("97", 10);

parseInt и parseFloat - две функции, используемые для разбора строк на числа. Синтаксический анализ прекратится тихо, если он попадет в символ, который он не распознает, что может быть полезно для анализа строк, таких как «92px», но это также несколько опасно, поскольку при неправильном вводе вы не получите никакой ошибки, вместо этого вы вернусь NaN, если строка не начинается с числа. Пробелы в начале строки игнорируются. Вот пример того, как он делает что-то отличное от того, что вы хотите, и не указывает, что что-то пошло не так:

var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97

Рекомендуется всегда указывать основание в качестве второго аргумента. В старых браузерах, если строка начиналась с 0, она была бы интерпретирована как восьмеричная, если бы не был указан radix, что застало многих врасплох. Поведение для шестнадцатеричного запускается, если строка начинается с 0x, если не указан radix, например0xff . Стандарт на самом деле изменился с ecmascript 5, поэтому современные браузеры больше не запускают восьмеричный код, когда идет начальный 0, если не задано основание. parseInt понимает основание вплоть до основания 36, и в этом случае как заглавные, так и строчные буквы рассматриваются как эквивалентные.

Изменение типа строки на число

Все другие трюки, упомянутые выше, которые не используют parseInt, включают неявное приведение строки в число. Я предпочитаю делать это явно,

var cast = Number("97");

Это поведение отличается от методов синтаксического анализа (хотя оно по-прежнему игнорирует пробелы). Это более строгое: если он не понимает всю строку, чем возвращает NaN, то вы не можете использовать его для строк вроде 97px. Поскольку вам нужен простой номер, а не объект-обертка Number, убедитесь, что вы не ставитеnew перед функцией Number.

Очевидно, что преобразование в Number дает вам значение, которое может быть числом с плавающей точкой, а не целым числом, поэтому, если вам нужно целое число, вам нужно изменить его. Есть несколько способов сделать это:

var rounded = Math.floor(Number("97.654"));  // other options are Math.ceil, Math.round
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
var bitwised = Number("97.654")|0;  // do not use for large numbers

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

~~"3000000000.654" === -1294967296
// This is the same as
Number("3000000000.654")|0
"3000000000.654" >>> 0 === 3000000000 // unsigned right shift gives you an extra bit
"300000000000.654" >>> 0 === 3647256576 // but still fails with larger numbers

Чтобы правильно работать с большими числами, вы должны использовать методы округления

Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))

Имейте в виду , что все эти методы понимают экспоненциальную нотацию, так 2e2это , 200а не NaN. Кроме того, Number понимает «Бесконечность», а методы разбора - нет.

изготовленный на заказ

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

Всегда проверяйте, что выходные данные Number или одного из методов разбора соответствуют ожидаемому числу. Вы почти наверняка захотите использовать, isNaNчтобы убедиться, что число не является NaN (обычно это единственный способ узнать, что анализ не выполнен).

kybernetikos
источник
6
Это зависит от того, хотите ли вы, чтобы ваш код также принимался 97,8,00и был похож или нет. Простой трюк состоит в том, .replace(/[^0-9]/g, "")чтобы удалить из вашей строки все нецифровые символы, а затем выполнить преобразование. Это, конечно, будет игнорировать все виды сумасшедших строк, в которых вы, вероятно, должны
ошибиться,
6
@kybernetikos, вероятно, должно быть .replace(/[^0-9.]/g, ""), иначе «1,05» станет «105».
J.Steve
Совершенно верно, хотя я бы не стал использовать что-то подобное для важного кода в любом случае - есть так много способов, которыми он может что-то пропустить через вас, на самом деле не хотят пропускать.
kybernetikos
2
Я нашел, что использование Number намного более читабельно в коде, поэтому спасибо, что указали на это как на решение.
carlin.scott
1
@kybernetikos In var fixed = Number("97.654").toFixed(0); // rounded rather than truncated, мы получаем string(из-за .toFixedметода) вместо number(целое число). Если мы хотим округленное целое число, то, вероятно, лучше просто использоватьMath.round("97.654");
Эду Замора
50

ParseInt () и + разные

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456
Далиус I
источник
37

Самый быстрый

var x = "1000"*1;

Тестовое задание

Вот небольшое сравнение скорости (только Mac OS) ... :)

Для chrome «плюс» и «мул» самые быстрые (> 700 000,00 операций в секунду), «Math.floor» самый медленный. Для Firefox «плюс» - самый медленный (!), «Мул» - самый быстрый (> 900 000 000 операций в секунду). В Safari «parseInt» - это посты, «номер» - самый медленный (но результаты очень похожи,> 13 000 000 <31 000 000). Поэтому Safari для приведения строки к int более чем в 10 раз медленнее, чем другие браузеры. Таким образом, победитель ' муль ' :)

Вы можете запустить его в своем браузере по этой ссылке https://jsperf.com/js-cast-str-to-number/1

введите описание изображения здесь

Обновить

Я также тестирую var x = ~~"1000";- на Chrome и Safari немного медленнее, чем var x = "1000"*1(<1%), на Firefox немного быстрее (<1%). Я обновляю картинку выше и тестирую

Камил Келчевски
источник
Там нет значительной разницы между результатами тестов A, B, E и F - они все по сути одинаковы,
Альф Итон
36

Хотя старый вопрос, но, возможно, это может быть полезно для кого-то.

Я использую этот способ преобразования строки в целое число

var str = "25";       // string
var number = str*1;   // number

Таким образом, при умножении на 1 значение не изменяется, но js автоматически возвращает число.

Но, как показано ниже, это следует использовать, если вы уверены, что str это число (или может быть представлено как число), в противном случае он вернет NaN, а не число.

Вы можете создать простую функцию для использования, например,

function toNumber(str) {
   return str*1;
}

введите описание изображения здесь

DAV
источник
33

Попробуйте parseInt.

var number = parseInt("10", 10); //number will have value of 10.
SolutionYogi
источник
4
Вы, вероятно, также захотите включить в него основание : var number = parseInt ("10", 10);
Джоэл Коухорн
27

Я написал неправильный ответ здесь, извините. фиксированный.

Это старый вопрос, но я люблю этот трюк:

~~"2.123"; //2
~~"5"; //5

Двойной побитовый минус отбрасывает что-либо после десятичной точки И преобразует его в числовой формат. Мне сказали, что это немного быстрее, чем вызов функций и еще много чего, но я не совсем уверен.

РЕДАКТИРОВАТЬ: еще один метод, который я только что видел здесь (вопрос об операторе javascript >>>, который является сдвиг вправо с нулевым заполнением), который показывает, что смещение числа на 0 с помощью этого оператора преобразует число в uint32, что хорошо, если вы также хочу это без знака . Опять же, это преобразуется в целое число без знака , что может привести к странному поведению, если вы используете число со знаком.

"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5
Ян Оои
источник
19

Осторожно, если вы используете parseInt для преобразования числа с плавающей точкой в ​​научную запись! Например:

parseInt("5.6e-14") 

приведет к

5 

вместо

0
Том
источник
14
Использование parseIntне будет работать правильно для поплавка. parseFloatработает правильно в этом случае.
Benekastah
16

Чтобы преобразовать строку в целое число, я рекомендую использовать parseFloat и НЕ parseInt. Вот почему:

Использование parseFloat:

parseFloat('2.34cms')  //Output: 2.34
parseFloat('12.5')     //Output: 12.5
parseFloat('012.3')    //Output: 12.3

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

parseInt('2.34cms')  //Output: 2
parseInt('12.5')     //Output: 12
parseInt('012.3')    //Output: 12

Так что, если вы заметили, parseInt отбрасывает значения после десятичных чисел, тогда как parseFloat позволяет работать с числами с плавающей запятой и, следовательно, более подходит, если вы хотите сохранить значения после десятичных дробей. Используйте parseInt тогда и только тогда, когда вы уверены, что хотите получить целочисленное значение.

Devner
источник
6
Вопрос был «Как я могу преобразовать строку в целое число в javascript»
Пьер Арло
15

Также как примечание: Mootools имеет функцию toInt (), которая используется для любой нативной строки (или float (или integer)).

"2".toInt()   // 2
"2px".toInt() // 2
2.toInt()     // 2
Хенрик Хансен
источник
7
Третий пример вызывает a SyntaxError, вы должны использовать двойную точку, например: 2..toInt();первая точка заканчивает представление Numberлитерала, а вторая точка является средством доступа к свойству.
CMS
2
этот вопрос не о mootools, а о JavaScript.
Лиам
14

Пожалуйста, смотрите ниже пример. Это поможет очистить ваши сомнения

Example                  Result

parseInt("4")            4
parseInt("5aaa")         5
parseInt("4.33333")      4
parseInt("aaa");         NaN (means "Not a Number")

с помощью функции parseint. Она выдаст только целое число, а не строку

Zeeshan
источник
12

мы можем использовать +(stringOfNumber)вместо того, чтобы использоватьparseInt(stringOfNumber)

Пример: +("21")возвращает int 21 как parseInt("21").

мы можем использовать этот унарный оператор "+" для разбора float ...

РевантКришнаКумар В.
источник
1
Но вы не можете использовать его в формулах! Т.е. (1 + ("21")) * 10 === 1210!
Александр Васильев
2
@AlexanderVasilyev Я думаю, вы можете, не могли бы вы использовать дополнительные скобки вокруг +?
NiCk Newman
@NiCkNewman Я получаю + ("21") из примера в ответе, который мы комментируем.
Александр Васильев
Мне действительно не нравится это решение. Это не явно, как parseIntесть. Обычная реализация const myNumber = +myNumberAsAStringвыглядит на первый взгляд как стандарт +=или =+оператор. Также при неправильном использовании это может привести к ошибкам конкатенации. Это решение основано на том факте, что 0 считается левой стороной, когда число не указано.
Шторм Мюллер
10

Попробуйте str - 0конвертировать stringв number.

> str = '0'
> str - 0
  0
> str = '123'
> str - 0
  123
> str = '-12'
> str - 0
  -12
> str = 'asdf'
> str - 0
  NaN
> str = '12.34'
> str - 0
  12.34

Вот две ссылки для сравнения производительности нескольких способов преобразования строки в int

https://jsperf.com/number-vs-parseint-vs-plus

http://phrogz.net/js/string_to_number.html

zangw
источник
1
@AlexanderYau, в этом документ , то '1'будет преобразован 1путем ToNumber, то 1 - 0будет1
zangw
10

В JavaScript есть много способов преобразовать строку в числовое значение ... Все просто и удобно, выберите способ, который вам подходит:

var num = Number("999.5"); //999.5
var num = parseInt("999.5", 10); //999
var num = parseFloat("999.5"); //999.5
var num = +"999.5"; //999.5

Также любая математическая операция конвертирует их в число, например ...

var num = "999.5" / 1; //999.5
var num = "999.5" * 1; //999.5
var num = "999.5" - 1 + 1; //999.5
var num = "999.5" - 0; //999.5
var num = Math.floor("999.5"); //999
var num = ~~"999.5"; //999

Я предпочитаю использовать +знак, который является элегантным способом преобразования строки в число в JavaScript.

Алиреза
источник
8

Google дал мне этот ответ как результат, так что ...

На самом деле мне нужно было «сохранить» строку как целое число для связи между C и JavaScript, поэтому я преобразовал строку в целочисленное значение:

/*
    Examples:
        int2str( str2int("test") ) == "test" // true
        int2str( str2int("t€st") ) // "t¬st", because "€".charCodeAt(0) is 8364, will be AND'ed with 0xff
    Limitations:
        max 4 chars, so it fits into an integer
*/
function str2int(the_str) {
    var ret = 0;
    var len = the_str.length;
    if (len >= 1) ret += (the_str.charCodeAt(0) & 0xff) <<  0;
    if (len >= 2) ret += (the_str.charCodeAt(1) & 0xff) <<  8;
    if (len >= 3) ret += (the_str.charCodeAt(2) & 0xff) << 16;
    if (len >= 4) ret += (the_str.charCodeAt(3) & 0xff) << 24;
    return ret;
}
function int2str(the_int) {
    var tmp = [
        (the_int & 0x000000ff) >>  0,
        (the_int & 0x0000ff00) >>  8,
        (the_int & 0x00ff0000) >> 16,
        (the_int & 0xff000000) >> 24
    ];
    var ret = "";
    for (var i=0; i<4; i++) {
        if (tmp[i] == 0)
            break;
        ret += String.fromCharCode(tmp[i]);
    }
    return ret;
}
lama12345
источник
4
Это интересный способ хранения и извлечения 4-байтовых значений. Это не отвечает обычной интерпретации вопроса: как преобразовать строковое представление числа в целочисленное значение. В любом случае, ваша int2strфункция останавливается, если байт равен 0, что может быть допустимым элементом в значении, поэтому if... breakследует удалить, чтобы получить полное возвращенное 4-байтовое значение.
Suncat2000
8

На мой взгляд, ни один ответ не покрывает все граничные случаи, так как анализ float должен привести к ошибке.

function parseInteger(value) {
    if(value === '') return NaN;
    const number = Number(value);
    return Number.isInteger(number) ? number : NaN;
}
parseInteger("4")            // 4
parseInteger("5aaa")         // NaN
parseInteger("4.33333")      // NaN
parseInteger("aaa");         // NaN
Михал Кнапик
источник
1
Возвращение не число является немного агрессивным для поплавка, не так ли?
Томас Аюб,
2
Это parseIntegerне так parseNumber. Я думаю, что каждое решение - это обходной путь, так как JS не поддерживает целые числа и с плавающей точкой как отдельные типы. Мы могли бы вернуться nullвместо NaN, если не номер вводит в заблуждение.
Михал Кнапик,
4

Вот самое простое решение

let myNumber = "123" | 0;

Более простое решение

let myNumber = +"123";
Танвир Шах
источник
2

все вышеперечисленное верно. Пожалуйста, убедитесь, что это число в строке, выполнив "typeot x === 'number'", иначе он вернет NaN

 var num = "fsdfsdf242342";
 typeof num => 'string';

 var num1 = "12423";
 typeof num1 => 'number';
 +num1 = > 12423`
Шахар ン ー ン Леви
источник
В узле v8.5.0 var num1 = "12423"; typeof num1;возвращается string.
Эду Замора
2

Другой вариант - удвоить значение XOR для себя:

var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));

Это выведет:

i = 12.34
i  i  i = 12
BanksySan
источник
2

Я добавил только один плюс (+) перед строкой, и это было решением!

+"052254" //52254

Надеюсь, поможет ;)

ivahidmontazer
источник
2

Суммируя умножение цифр с соответствующей степенью десяти:

т.е.: 123 = 100 + 20 + 3 = 1 * 100 + 2 + 10 + 3 * 1 = 1 * (10 ^ 2) + 2 * (10 ^ 1) + 3 * (10 ^ 0)

function atoi(array) {

// use exp as (length - i), other option would be to reverse the array.
// multiply a[i] * 10^(exp) and sum

let sum = 0;

for (let i = 0; i < array.length; i++) {
    let exp = array.length-(i+1);
    let value = array[i] * Math.pow(10,exp);
    sum+=value;
}

return sum;

}

Хавьер Джованнини
источник
1

function doSth(){
  var a = document.getElementById('input').value;
  document.getElementById('number').innerHTML = toNumber(a) + 1;
}
function toNumber(str){
  return +str;
}
<input id="input" type="text">
<input onclick="doSth()" type="submit">
<span id="number"></span>

Маджид Найери
источник
1

Я использую это

String.prototype.toInt = function (returnval) { 
    var i = parseInt(this);
    return isNaN(i) ? returnval !== undefined ? returnval : - 1  :      i; 
}

таким образом я всегда получаю инт обратно.

Майк
источник
1

Самый безопасный способ убедиться, что вы получите действительное целое число:

let integer = (parseInt(value, 10) || 0);

Примеры:

// Example 1 - Invalid value:
let value = null;
let integer = (parseInt(value, 10) || 0);
// => integer = 0
// Example 2 - Valid value:
let value = "1230.42";
let integer = (parseInt(value, 10) || 0);
// => integer = 1230
// Example 3 - Invalid value:
let value = () => { return 412 };
let integer = (parseInt(value, 10) || 0);
// => integer = 0
Офир
источник
1
function parseIntSmarter(str) {
    // ParseInt is bad because it returns 22 for "22thisendsintext"
    // Number() is returns NaN if it ends in non-numbers, but it returns 0 for empty or whitespace strings.
    return isNaN(Number(str)) ? NaN : parseInt(str, 10);
}
mhenry1384
источник
0

Вы можете использовать плюс, например =>

var personAge = '24'; var personAge1 = (+ personAge)

тогда вы можете увидеть typeof personAge это число

Эльназ Насири
источник