Как преобразовать строку в целое число в 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

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

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

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

var cast = Number("97");

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

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

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

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

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

таможни

маловероятно, что любой из этих методов делать то, что вы хотите. Например, обычно я хотел бы, чтобы при сбое синтаксического анализа возникла ошибка, и мне не нужна поддержка Бесконечности, экспонент или ведущих пробелов. В зависимости от вашего 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>>>, который является нулевым заполнением right shift), который показывает, что смещение числа на 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 "плюс" и " mul "самые быстрые," математика.пол " самый медленный (>700,000,00 op / sec). Для 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                  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

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

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

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

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

попробовать str - 0 преобразование string to 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;
}

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

все вышеперечисленное верно. Пожалуйста, убедитесь, что это число в строке, выполнив "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 обратно.