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

попробуйте функцию 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

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

извлечение

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

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

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

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

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

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

var cast = Number("97");

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

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

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, а не Нана. Кроме того, число понимает "Бесконечность", в то время как методы разбора этого не делают.

Custom

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

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

ParseInt() и + разные

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

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

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

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

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

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

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

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

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

var number = parseInt("10", 10); //number will have value of 10.

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

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

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

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

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

"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5

остерегайтесь, если вы используете parseInt для преобразования float в научной нотации! Например:

parseInt("5.6e-14") 

в результате

5 

вместо

0

вот небольшое сравнение скорости (только для Mac Os)... :)

для chrome 'plus' и 'mul' являются самыми быстрыми, ' Math.пол ' является самым медленным (>700,000,00 оп/сек). Для Firefox "плюс" является самым медленным (!) 'mul' является самым быстрым (>900,000,000 op/sec). В Safari 'parseInt' - это fastes,' number ' - самый медленный (но результаты очень похожи, >13,000,000 mul':)

вы вы можете запустить его в своем браузере по этой ссылке https://jsperf.com/casttonumber

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

"2".toInt()   // 2
"2px".toInt() // 2
2.toInt()     // 2

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

Example                  Result

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

С помощью функции parseint он будет давать только op целочисленного настоящего, а не строку

чтобы преобразовать строку в целое число, я рекомендую использовать 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

можно использовать +(stringOfNumber) вместо parseInt(stringOfNumber)

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

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

попробовать 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

в 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.

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;
}

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

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

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

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

 var num1 = "12423";
 typeof num1 => 'number';
 +num1 = > 12423`

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

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

это будет выход:

i = 12.34
i ⊕ i ⊕ i = 12

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>

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

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

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