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

Question

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

Answer 1

Самым простым способом было бы использовать родной Number Функция:

var x = Number("1000")

Если это не работает для вас, то есть Parseint, Unary Plus, Парсефлоат с полом, а также 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])

Unary Plus, если ваша строка уже находится в форме целого числа:

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

Если вы из тех, кто забывает вставить Radix, когда вы называете 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)

Answer 2

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

var number = parseInt("10");

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

parseInt(string, radix)

Пример:

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

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

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

var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true

Answer 3

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

Диапазон

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

Parseint и Parsefloat - это две функции, используемые для разбора строк для чисел. Распокация остановится молча, если он попадет в характер, который он не распознает, что может быть полезно для анализа строк, таких как «92px», но это также несколько опасно, так как он не даст вам никакой ошибки при плохом вводе, вместо этого вы Вернитесь в НАН, если строка не начнется с числа. Пробел в начале струны игнорируется. Вот пример того, как он делает что -то другое, чтобы вы хотите, и не дает никаких признаков того, что что -то пошло не так:

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

Это хорошая практика, чтобы всегда указывать Radix как второй аргумент. В более старых браузерах, если строка началась с 0, она будет интерпретироваться как восьмиугольника, если бы Radix не был указан, что застало много людей врасплох. Поведение для шестнадцатеричного запуска запускается путем начала строки с 0x, если Radix не указан, например, 0xff. Анкет Стандарт фактически изменился с Ecmascript 5, поэтому современные браузеры больше не запускают октальные, когда есть ведущий 0, если Radix не указан. 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 -битное целое число, и большинство из них преобразуются в подписанное целое число. Обратите внимание, что это Не желает, чтобы вы хотели для больших целых чисел. Анкет Если целое число не может быть представлено в 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 а не Нэн. Кроме того, число понимает «бесконечность», а методы анализа нет.

Обычай

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

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

Answer 4

Parseint () и + разные

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Answer 5

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

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

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

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

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

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

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

Answer 6

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

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

Answer 7

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

var x = "1000"*1;

Тест

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

Для Chrome 'Plus' и 'Mul' самые быстрые (> 700 000,00 Op/Sec), «Math.floor» является самым медленным. Для Firefox 'Plus' самый медленный (!) 'Mul' самый быстрый (> 900 000 000 OP/SEC). В Safari 'Parseint' - это посты, «число» является самым медленным (но результаты довольно похожи,> 13 000 000 <31 000 000). Таким образом, Safari для литой строки в int более чем на 10 раз медленнее, чем другие браузеры. Итак, победитель 'мульт' :)

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

Обновлять

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

Answer 8

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

Это старый вопрос, но мне нравится этот трюк:

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

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

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

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

Answer 9

Остерегайтесь, если вы используете Parseint, чтобы преобразовать поплавок в научной нотации! Например:

parseInt("5.6e-14") 

приведет к

5 

вместо

0

Answer 10

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

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

Answer 11

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

Answer 12

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

Example                  Result

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

Используя функцию ParseIn

Answer 13

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

Бывший: +("21") Возвращает int 21, как parseInt("21").

Мы можем использовать этот UNARARY "+" Оператор тоже для анализа плавания ...

Answer 14

Пытаться 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-lus

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

Answer 15

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

Answer 16

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

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

Answer 17

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

Answer 18

Все вышеперечисленное верно. Пожалуйста, убедитесь, что до того, как это число в строке, выполнив «TypeT x ===».

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

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

Answer 19

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

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

Это выведет:

i = 12.34
i ⊕ i ⊕ i = 12

Answer 20

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>

Answer 21

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

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

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

Answer 22

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

+"052254" //52254

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

Answer 23

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

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

}

Answer 24

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

let myNumber = "123" | 0;

Answer 25

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

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

Answer 26

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