it-roy-ru.com

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

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

1467

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

var x = Number("1000")

Если это не работает для вас, то существуют методы parseInt , unary plus , parseFloat с 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)
1884
Nosredna

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

Есть два основных способа преобразовать строку в число в 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, если не указано основание, например, 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 понимает «Бесконечность», а методы разбора - нет.

Custom

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

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

115
kybernetikos

ParseInt () и + разные

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456
50
Dalius I

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

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

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

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

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

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

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

enter image description here

34
dav

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

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

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

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

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

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

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

"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5
26
Ian Ooi

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

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 раз медленнее, чем другие браузеры. Таким образом, победитель 'mul' :)

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

 enter image description here

Обновление

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

26
Kamil Kiełczewski

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

parseInt("5.6e-14") 

приведет к

5 

вместо

0
18
tom

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

"2".toInt()   // 2
"2px".toInt() // 2
2.toInt()     // 2
15
Henrik Hansen

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

Example                  Result

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

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

14
zeeshan

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

14
Devner

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

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

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

12
RevanthKrishnaKumar V.

Попробуйте 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

10
zangw

В 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

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

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
Alireza

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

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

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

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

 var num1 = "12423";
 typeof num1 => 'number';
 +num1 = > 12423`
1
Shahar ドーン Levi

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

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

Это выведет:

i = 12.34
i ⊕ i ⊕ i = 12
1
BanksySan

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

let myNumber = "123" | 0;
0
Thanveer Shah

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>

0
Majid Nayyeri

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

+"052254" //52254

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

0
ivahidmontazer

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

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

}

0
Javier Giovannini

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

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

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

0
Mike