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

Самый простой способ - использовать встроенную 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)

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

Есть два основных способа преобразовать строку в число в 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 (обычно это единственный способ узнать, что анализ не выполнен).

ParseInt () и + разные

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

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

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%). Я обновляю картинку выше и тестирую

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

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

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

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

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

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

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

parseInt("5.6e-14") 

приведет к

5 

вместо

0

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

Также как примечание: 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. Она выдаст только целое число, а не строку

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

Пример: +("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;
}

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

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

let myNumber = "123" | 0;

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

let myNumber = +"123";

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

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

+"052254" //52254

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

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

т.е.: 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;

}

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

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

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

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

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

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

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

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

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