Як перетворити рядок у ціле число в JavaScript?

Найпростішим способом було б використання нативної Numberфункції:

var x = Number("1000")

Якщо це не працює для вас, існують методи parseInt , unry plus , parseFloat з floor і Math.round .

розбір:

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ігнорує погані дані після аналізу будь-якого дійсного.
Цей настанов буде проаналізовано як 51:

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

Є два основні способи перетворення рядка в число в JavaScript. Один із способів - це розібрати його, а інший - змінити його тип на число. Усі хитрощі в інших відповідях (наприклад, унійний плюс) передбачають неявне примушування типу рядка до числа. Те ж саме можна зробити явно за допомогою функції «Число».

Розбір

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

parseInt і parseFloat - це дві функції, які використовуються для розбору рядків до чисел. Парсинг зупиниться мовчки, якщо він потрапить на символ, який він не розпізнає, що може бути корисним для розбору рядків типу "92px", але це також дещо небезпечно, оскільки не дасть вам помилок при неправильному введенні, замість вас Я поверну NaN, якщо рядок не починається з числа. Пробіл на початку рядка ігнорується. Ось приклад того, як ви робите щось інше, ніж ви хочете, і не вказуючи на те, що щось пішло не так:

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

Добра практика завжди визначати радіус як другий аргумент. У старих браузерах, якщо рядок починався з 0, він би тлумачився як восьмеричний, якби не було вказано радіус, що здивувало багатьох людей. Поведінка для шістнадцяткової викликається тим, що рядок починається з 0x, якщо не вказано жодного радіасу, наприклад 0xff. Стандарт фактично змінився з ecmascript 5, тому сучасні браузери більше не запускають восьмерику, коли є ведучий 0, якщо не вказано жодного радіусу. 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-бітове ціле число, і більшість з них перетвориться на підписане ціле число. Зауважте, що для великих цілих чисел це не потрібно . Якщо ціле число не можна представити в 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. Крім того, номер розуміє "нескінченність", тоді як методи аналізу не відповідають.

Користувальницькі

Навряд чи будь-який із цих методів робить саме те, що ви хочете. Наприклад, зазвичай я б хотів, щоб помилка була видалена, якщо розбір не вдається, і мені не потрібна підтримка Infinity, експонентів або провідних пробілів. Залежно від вашої справи, іноді має сенс написати спеціальну функцію перетворення.

Завжди переконайтеся, що вихід числа чи одного з методів розбору є таким числом, яке ви очікуєте. Ви майже напевно хочете скористатися, isNaNщоб переконатися, що число не є NaN (зазвичай це єдиний спосіб дізнатися, що аналіз не вдався).

ParseInt () і + різні

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Найшвидший

var x = "1000"*1;

Тест

Ось мало порівняння швидкості (лише для Mac Os) ... :)

Для хрому "плюс" і "мул" найшвидші (> 700 000,00 оп / сек), "Math.floor" є найповільнішим. Для Firefox 'плюс' є найповільнішим (!) 'Mul' є найшвидшим (> 900000000 оп / сек). У 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%). Я оновлюю вище зображення та тест

Хоч і давнє запитання, але, можливо, це може комусь допомогти.

Я використовую такий спосіб перетворення рядка в int число

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

Отже, при множенні на 1 значення не змінюється, але js автоматично повертає число.

Але як показано нижче, це слід використовувати, якщо ви впевнені, що strце число (або його можна представити як число), інакше він поверне NaN - не число.

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

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

Спробуйте розібратися.

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

Тут я виклав неправильну відповідь, вибачте. фіксований.

Це старе питання, але я люблю цю хитрість:

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

Подвійний розрядний від’ємник випадає після десяткової крапки і перетворює його у формат числа. Мені сказали, що це трохи швидше, ніж виклик функцій і багато чого іншого, але я не зовсім переконаний.

EDIT: Ще один метод, який я щойно побачив тут (питання щодо оператора 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 (або цілому)).

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

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

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

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

На мою думку, жодна відповідь не охоплює всі крайові випадки, оскільки розбір плавця повинен призвести до помилки.

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 - це номер