Ответ 1

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

var x = Number("1000")

Если это не работает для вас, то есть parseInt, унарный плюс, parseFloat с полом и 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");

Если вы тот тип, который забывает вставлять 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)

Ответ 2

Попробуйте функцию 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 игнорирует parseInt данные после анализа чего-либо действительного.
Этот гид будет разобрать как

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

Ответ 3

Существует два основных способа преобразования строки в число в javascript. Один из способов - проанализировать его, а другой способ - изменить его тип на число. Все трюки в других ответах (например, унарный плюс) подразумевают неявное принуждение типа строки к числу. Вы также можете сделать то же самое с помощью функции 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, если не указано значение radix. parseInt понимает радики до основания 36, и в этом случае как верхние, так и строчные буквы обрабатываются как эквивалентные.

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

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

var cast = Number("97");

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

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

Любой побитовый оператор (здесь я поразрядный или, но вы также можете сделать двойное отрицание, как в более раннем ответе или бит-сдвиге) преобразует значение в 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 понимает "Бесконечность", в то время как методы анализа не делают.

Пользовательский

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

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

Ответ 4

ParseInt() и + разные

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Ответ 5

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

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

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

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

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

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

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

Ответ 6

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

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

Ответ 7

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

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

Ответ 8

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

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

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

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

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

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

Ответ 9

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

parseInt("5.6e-14") 

приведет к

5 

вместо

0

Ответ 10

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

Ответ 11

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

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

Ответ 12

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

Example                  Result

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

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

Ответ 13

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

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

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

Ответ 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-plus

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

Ответ 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.

Ответ 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

Ответ 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;
}

Ответ 18

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

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

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

Ответ 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

Ответ 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>

Ответ 21

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

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

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

Ответ 22

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

+"052254" //52254

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

Ответ 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;

}

Ответ 24

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

let myNumber = "123" | 0;

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

let myNumber = +"123";

Ответ 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

Ответ 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);
}