Возможно ли как-то вернуть 0 вместо NaN при анализе значений в JavaScript?
В случае пустой строки parseInt возвращает NaN.
Можно ли сделать что-то подобное в JavaScript для проверки NaN?
var value = parseInt(tbb) == NaN ? 0 : parseInt(tbb)
Или, может быть, есть другая функция или плагин jQuery, который может сделать что-то подобное?
var s = '';
var num = parseInt(s) || 0;
Вы также можете использовать функцию isNaN():
var s = ''
var num = isNaN(parseInt(s)) ? 0 : parseInt(s)
Я с удивлением заметил, что никто не упоминает использование Number(). Разумеется, он будет разбирать десятичные числа, если они предоставлены, поэтому будет действовать иначе, чем parseInt(), однако он уже предполагает базу 10 и превратит "или даже" " в 0.
Для людей, которые не ограничены parseInt, вы можете использовать побитовый оператор ИЛИ (который неявно вызывает ToInt32 для своих операндов).
var value = s | 0;
// NaN | 0 ==>> 0
// '' | 0 ==>> 0
// '5' | 0 ==>> 5
// '33Ab' | 0 ==>> 0
// '0x23' | 0 ==>> 35
// 113 | 0 ==>> 113
// -12 | 0 ==>> -12
// 3.9 | 0 ==>> 3
Примечание. ToInt32 отличается от parseInt. (т.е. parseInt('33Ab') === 33)
Проблема
В других ответах не учитывается, что 0 является ложным, и, следовательно, следующее будет равно 20 вместо 0:
var myNumber = parseInt('0') || 20; // 20
Решение
Я предлагаю вспомогательную функцию, которая решает большинство проблем:
function getNumber(number, defaultNumber) {
return isNaN(parseInt(number, 10)) ? defaultNumber : parseInt(number, 10);
}
Вспомогательная функция даст следующие результаты:
getNumber('0', 20); // 0
getNumber('2', 20); // 2
getNumber('2.2', 20); // 2
getNumber('any string', 20); // 20
getNumber(undefined, 20); // 20
getNumber(null, 20); // 20
getNumber(NaN, 20); // 20
getNumber(false, 20); // 20
getNumber(true, 20); // 20
var value = isNaN(parseInt(tbb)) ? 0 : parseInt(tbb);
Делает ли работа намного чище, чем parseInt, по моему мнению, используйте +operator
var s = '';
console.log(+s);
var s = '1024'
+s
1024
s = 0
+s
0
s = -1
+s
-1
s = 2.456
+s
2.456
s = ''
+s
0
s = 'wtf'
+s
NaN
Сделайте отдельную проверку пустой строки (так как это один конкретный случай) и установите в этом случае нуль.
Вы могли бы призывать "0" к началу, но тогда вам нужно добавить префикс, чтобы указать, что он является десятичным, а не восьмеричным числом
Почему бы не переопределить функцию? В этом случае вы всегда можете быть уверены, что он возвращает 0 в случае NaN:
(function(original) {
parseInt = function() {
return original.apply(window, arguments) || 0;
};
})(parseInt);
Теперь, в любом месте вашего кода:
parseInt('') === 0
У меня была аналогичная проблема (firefox v34) с простыми строками вроде:
var myInt = parseInt("b4");
Итак, я быстро взломал:
var intVal = ("" + val).replace(/[^0-9]/gi, "");
И потом все глупо с трудом справлялись с float + ints для непростых вещей:
var myval = "12.34";
function slowParseNumber(val, asInt){
var ret = Number( ("" + val).replace(/[^0-9\.]/gi, "") );
return asInt ? Math.floor(ret) : ret;
}
var floatVal = slowParseNumber(myval);
var intVal = slowParseNumber(myval, true);
console.log(floatVal, intVal);
Он вернет 0 для таких вещей, как:
var intVal = slowParseNumber("b"); // yeilds 0
//////////////////////////////////////////////////////
function ToInt(x){x=parseInt(x);return isNaN(x)?0:x;}
//////////////////////////////////////////////////////
var x = ToInt(''); //-> x=0
x = ToInt('abc') //-> x=0
x = ToInt('0.1') //-> x=0
x = ToInt('5.9') //-> x=5
x = ToInt(5.9) //-> x=5
x = ToInt(5) //-> x=5
Я создал 2 прототипа, чтобы справиться с этим для меня, один для числа и один для строки.
// This is a safety check to make sure the prototype is not already defined.
Function.prototype.method = function (name, func) {
if (!this.prototype[name]) {
this.prototype[name] = func;
return this;
}
};
// returns the int value or -1 by default if it fails
Number.method('tryParseInt', function (defaultValue) {
return parseInt(this) == this ? parseInt(this) : (defaultValue === undefined ? -1 : defaultValue);
});
// returns the int value or -1 by default if it fails
String.method('tryParseInt', function (defaultValue) {
return parseInt(this) == this ? parseInt(this) : (defaultValue === undefined ? -1 : defaultValue);
});
Если вы не хотите использовать проверку безопасности, используйте
String.prototype.tryParseInt = function(){
/*Method body here*/
};
Number.prototype.tryParseInt = function(){
/*Method body here*/
};
Пример использования:
var test = 1;
console.log(test.tryParseInt()); // returns 1
var test2 = '1';
console.log(test2.tryParseInt()); // returns 1
var test3 = '1a';
console.log(test3.tryParseInt()); // returns -1 as that is the default
var test4 = '1a';
console.log(test4.tryParseInt(0));// returns 0, the specified default value
// implicit cast
var value = parseInt(tbb*1); // see original question
Объяснение, для тех, кто не считает это тривиальным:
Умножение на единицу, метод, называемый "неявное приведение", пытается превратить операнд неизвестного типа в примитивный тип "число". В частности, пустая строка станет номером 0, что делает ее подходящим типом для parseInt()...
Очень хороший пример также был приведен выше PirateApp, который предложил добавить знак +, заставляя JavaScript использовать неявное приведение числа.
Также так, почему бы не написать функцию и назвать ее там, где это требуется. Я предполагаю, что это запись в поля формы для выполнения вычислений.
var Nanprocessor = function (entry) {
if(entry=="NaN") {
return 0;
} else {
return entry;
}
}
outputfield.value = Nanprocessor(x);
// where x is a value that is collected from a from field
// i.e say x =parseInt(formfield1.value);
что плохого делать?
Вот метод tryParseInt, который я использую, он принимает значение по умолчанию в качестве второго параметра, поэтому он может быть любым, что вам нужно.
function tryParseInt(str, defaultValue) {
return parseInt(str) == str ? parseInt(str) : defaultValue;
}
tryParseInt("", 0);//0
tryParseInt("string", 0);//0
tryParseInt("558", 0);//558
вспомогательная функция, которая все еще позволяет использовать основание
function parseIntWithFallback(s, fallback, radix) {
var parsed = parseInt(s, radix);
return isNaN(parsed) ? fallback : parsed;
}
Вы можете иметь очень чистый код, у меня были похожие проблемы, и я решил их с помощью:
var a="bcd";
~~parseInt(a);