javascript - строку - проверка на число js




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

Как преобразовать string в integer в 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;
}

ParseInt () и + разные

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Вот небольшое сравнение скорости (только Mac Os) ... :)

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

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


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

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

Это приведет к выводу:

i = 12.34
i ⊕ i ⊕ i = 12

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

parseInt("5.6e-14") 

приведет к

5 

вместо

0

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

Example                  Result

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

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


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

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

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

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

анализ

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

parseInt и parseFloat - это две функции, используемые для разбора строк на числа. Синтаксический анализ остановится молча, если он попадет в символ, который он не распознает, что может быть полезно для синтаксического анализа строк, например «92px», но это также несколько опасно, поскольку оно не даст вам никакой ошибки при плохом вводе, вместо этого вы 'вернем NaN, если строка не начинается с числа. Пробел в начале строки игнорируется. Вот пример того, как он делает что-то по-другому, чем вы хотите, и не указывает, что что-то пошло не так:

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

Хорошая практика - всегда указывать в качестве второго аргумента radix. В старых браузерах, если строка начиналась с 0, она была бы интерпретирована как восьмеричная, если бы не было указано значение radix, которое привлекло много людей врасплох. Поведение для шестнадцатеричного инициируется путём начала строки с 0x, если не указано значение radix, например 0xff . Стандарт фактически изменился с помощью ecmascript 5, поэтому современные браузеры больше не запускают восьмеричные, когда есть ведущее 0, если не указано никаких оснований. 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, экспоненты или ведущие пробелы. В зависимости от вашего использования, иногда имеет смысл написать пользовательскую функцию преобразования.

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


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

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

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


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

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

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


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

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

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

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

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

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





parseint