Кто-нибудь знает, как я могу проверить, является ли переменная числом или строкой в JavaScript?
Проверьте, является ли переменная числом или строкой в JavaScript
Ответ 1
Если вы имеете дело с буквальной нотацией, а не с конструкторами, вы можете использовать typeof:.
typeof "Hello World"; // string
typeof 123; // number
Если вы создаете числа и строки через конструктор, например var foo = new String("foo"), вы должны иметь в виду, что typeof может возвращать object для foo.
Возможно, более надежным методом проверки типа будет использование метода, найденного в underscore.js (можно найти искомый источник здесь),
var toString = Object.prototype.toString;
_.isString = function (obj) {
return toString.call(obj) == '[object String]';
}
Это возвращает логическое true для следующего:
_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true
Ответ 2
Лучший способ сделать это - использовать приведение типа isNaN +:
Обновлен метод олл-ин:
function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }
То же самое с использованием регулярных выражений:
function isNumber(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); }
------------------------
isNumber('123'); // true
isNumber('123abc'); // false
isNumber(5); // true
isNumber('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber(' '); // false
Ответ 3
Лучший способ, который я нашел, - либо проверить метод на строку, т.е.:
if (x.substring) {
// do string thing
} else{
// do other thing
}
или если вы хотите что-то сделать с проверкой числа для свойства number,
if (x.toFixed) {
// do number thing
} else {
// do other thing
}
Это похоже на "утиную печать", это зависит от вас, что имеет смысл. Мне не хватает кармы для комментариев, но typeof не подходит для строк и чисел в коробке, то есть:
alert(typeof new String('Hello World'));
alert(typeof new Number(5));
будет предупреждать "объект".
Ответ 4
Вы ищете isNaN():
console.log(!isNaN(123));
console.log(!isNaN(-1.23));
console.log(!isNaN(5-2));
console.log(!isNaN(0));
console.log(!isNaN("0"));
console.log(!isNaN("2"));
console.log(!isNaN("Hello"));
console.log(!isNaN("2005/12/12"));Ответ 5
Проверьте, является ли значение строковым литералом или объектом String:
function isString(o) {
return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}
Unit test:
function assertTrue(value, message) {
if (!value) {
alert("Assertion error: " + message);
}
}
function assertFalse(value, message)
{
assertTrue(!value, message);
}
assertTrue(isString("string literal"), "number literal");
assertTrue(isString(new String("String object")), "String object");
assertFalse(isString(1), "number literal");
assertFalse(isString(true), "boolean literal");
assertFalse(isString({}), "object");
Проверка числа аналогична:
function isNumber(o) {
return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}
Ответ 6
Начиная с ES2015, правильный способ проверить, содержит ли переменная правильное число, - Number.isFinite(value)
Примеры:
Number.isFinite(Infinity) // false
Number.isFinite(NaN) // false
Number.isFinite(-Infinity) // false
Number.isFinite(0) // true
Number.isFinite(2e64) // true
Number.isFinite('0') // false
Number.isFinite(null) // false
Ответ 7
Попробуй это,
<script>
var regInteger = /^-?\d+$/;
function isInteger( str ) {
return regInteger.test( str );
}
if(isInteger("1a11")) {
console.log( 'Integer' );
} else {
console.log( 'Non Integer' );
}
</script>
Ответ 8
//testing data types accurately in JavaScript (opposed to "typeof")
//from http://bonsaiden.github.com/JavaScript-Garden/
function is(type, obj) {
var clas = Object.prototype.toString.call(obj).slice(8, -1);
return obj !== undefined && obj !== null && clas === type;
}
//basic usage
is('String', 'test'); // true
is('Array', true); // false
Или адаптируйте его для возврата неизвестного типа:
function realTypeOf(obj) {
return Object.prototype.toString.call(obj).slice(8, -1);
}
//usage
realTypeOf(999); // 'Number'
12 мая 2012 г. Обновление: Полный пример в Javascript: лучший тип.
Ответ 9
Лучший способ сделать это:
function isNumber(num) {
return (typeof num == 'string' || typeof num == 'number') && !isNaN(num - 0) && num !== '';
};
Это удовлетворяет следующим тестовым примерам:
assertEquals("ISNUMBER-True: 0", true, isNumber(0));
assertEquals("ISNUMBER-True: 1", true, isNumber(-1));
assertEquals("ISNUMBER-True: 2", true, isNumber(-500));
assertEquals("ISNUMBER-True: 3", true, isNumber(15000));
assertEquals("ISNUMBER-True: 4", true, isNumber(0.35));
assertEquals("ISNUMBER-True: 5", true, isNumber(-10.35));
assertEquals("ISNUMBER-True: 6", true, isNumber(2.534e25));
assertEquals("ISNUMBER-True: 7", true, isNumber('2.534e25'));
assertEquals("ISNUMBER-True: 8", true, isNumber('52334'));
assertEquals("ISNUMBER-True: 9", true, isNumber('-234'));
assertEquals("ISNUMBER-False: 0", false, isNumber(NaN));
assertEquals("ISNUMBER-False: 1", false, isNumber({}));
assertEquals("ISNUMBER-False: 2", false, isNumber([]));
assertEquals("ISNUMBER-False: 3", false, isNumber(''));
assertEquals("ISNUMBER-False: 4", false, isNumber('one'));
assertEquals("ISNUMBER-False: 5", false, isNumber(true));
assertEquals("ISNUMBER-False: 6", false, isNumber(false));
assertEquals("ISNUMBER-False: 7", false, isNumber());
assertEquals("ISNUMBER-False: 8", false, isNumber(undefined));
assertEquals("ISNUMBER-False: 9", false, isNumber(null));
Ответ 10
Здесь подход, основанный на идее приведения ввода к числу или строке путем добавления нуля или нулевой строки, а затем выполнения типизированного сравнения на равенство.
function is_number(x) { return x === x+0; }
function is_string(x) { return x === x+""; }
По непонятной причине x===x+0 кажется, работает лучше, чем x===+x.
Есть ли случаи, когда это не удается?
В том же духе:
function is_boolean(x) { return x === !!x; }
Это выглядит немного быстрее, чем x===true || x===false x===true || x===false или typeof x==="boolean" (и намного быстрее, чем x===Boolean(x)).
Тогда там также
function is_regexp(x) { return x === RegExp(x); }
Все это зависит от существования операции "идентификация", специфичной для каждого типа, которая может применяться к любому значению и надежно генерировать значение рассматриваемого типа. Я не могу думать о такой операции для дат.
Для NaN есть
function is_nan(x) { return x !== x;}
Это в основном версия с подчеркиванием, и в нынешнем виде она примерно в четыре раза быстрее, чем isNaN(), но комментарии в источнике с подчеркиванием упоминают, что "NaN - это единственное число, которое не равно себе" и добавляет проверку для _.isNumber. Зачем? Какие другие объекты не будут равны себе? Кроме того, подчеркивание использует x !== +x --but, что может изменить знак +?
Тогда для параноика:
function is_undefined(x) { return x===[][0]; }
или это
function is_undefined(x) { return x===void(0); }
Ответ 11
Можете ли вы просто разделить его на 1?
Я предполагаю, что проблема будет представлять собой строковый ввод: "123ABG"
var Check = "123ABG"
if(Check == Check / 1)
{
alert("This IS a number \n")
}
else
{
alert("This is NOT a number \n")
}
Только что я сделал это недавно.
Ответ 12
uh, как насчет просто:
function IsString(obj) {
return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}
После дальнейшего рассмотрения много месяцев спустя, это гарантирует только obj - объект, который имеет имя метода или свойства toLowerCase. Мне стыдно за мой ответ. Пожалуйста, см. Топ-проголосовавший typeof один.
Ответ 13
Я думаю, что преобразование var в строку уменьшает производительность, по крайней мере, этот тест, выполненный в последних браузерах, показывает это.
Итак, если вы заботитесь о производительности, я бы использовал это:
typeof str === "string" || str instanceof String
для проверки, является ли переменная строкой (даже если вы используете var str = new String("foo"), str instanceof String вернет true).
Что касается проверки, если бы это число, я бы пошел на native: isNaN; функция.
Ответ 14
Или просто используйте инвертирование isNaN():
if(!isNaN(data))
do something with the number
else
it is a string
И да, использование jQuery $.isNumeric() приносит больше удовольствия.
Ответ 15
jQuery использует это:
function isNumber(obj) {
return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}
Ответ 16
Это решение разрешает многие проблемы, поднятые здесь!
Это, безусловно, самый надежный метод, который я использовал далеко. Я этого не изобретал и не могу вспомнить, откуда я его нашел. Но он работает там, где не срабатывают другие методы:
// Begin public utility /getVarType/
// Returns 'Function', 'Object', 'Array',
// 'String', 'Number', 'Boolean', or 'Undefined'
getVarType = function ( data ){
if (undefined === data ){ return 'Undefined'; }
if (data === null ){ return 'Null'; }
return {}.toString.call(data).slice(8, -1);
};
// End public utility /getVarType/
Пример правильности
var str = new String();
console.warn( getVarType(str) ); // Reports "String"
console.warn( typeof str ); // Reports "object"
var num = new Number();
console.warn( getVarType(num) ); // Reports "Number"
console.warn( typeof num ); // Reports "object"
var list = [];
console.warn( getVarType( list ) ); // Reports "Array"
console.warn( typeof list ); // Reports "object"
Ответ 17
Jsut FYI, если вы используете jQuery, у вас есть
$.isNumeric()
чтобы справиться с этим. Подробнее о http://api.jquery.com/jQuery.isNumeric/
Ответ 18
typeof отлично работает для меня в большинстве случаев. Вы можете попробовать использовать оператор if
if(typeof x === 'string' || typeof x === 'number') {
console.log("Your statement");
}
где x - любое имя переменной по вашему выбору
Ответ 19
лучший способ найти, который также думает о положительных и отрицательных числах: O'Reilly Javascript и Cookbook DHTML:
function isNumber(elem) {
var str = elem.value;
var oneDecimal = false;
var oneChar = 0;
// make sure value hasn't cast to a number data type
str = str.toString( );
for (var i = 0; i < str.length; i++) {
oneChar = str.charAt(i).charCodeAt(0);
// OK for minus sign as first character
if (oneChar = = 45) {
if (i = = 0) {
continue;
} else {
alert("Only the first character may be a minus sign.");
return false;
}
}
// OK for one decimal point
if (oneChar = = 46) {
if (!oneDecimal) {
oneDecimal = true;
continue;
} else {
alert("Only one decimal is allowed in a number.");
return false;
}
}
// characters outside of 0 through 9 not OK
if (oneChar < 48 || oneChar > 57) {
alert("Enter only numbers into the field.");
return false;
}
}
return true;
}
Ответ 20
Errr? Просто используйте регулярные выражения!:)
function isInteger(val) {
return val.match(/^[0-9]$/)
}
function isFloat(val) {
return val.match(/^[0-9]*/\.[0-9]+$/)
}
Ответ 21
так как строка в виде "1234" с typeof будет показывать "string", а инверсия никогда не может произойти (typeof 123 всегда будет номером), лучше всего использовать простое регулярное выражение /^\-?\d+$/.test(var). Или более продвинутый, чтобы соответствовать поплавкам, целым числам и отрицательным числам, /^[\-\+]?[\d]+\.?(\d+)?$/
Важной стороной .test является то, что она НЕ выбрасывает исключение, если var не является строкой, значение может быть любым.
var val, regex = /^[\-\+]?[\d]+\.?(\d+)?$/;
regex.test(val) // false
val = '1234';
regex.test(val) // true
val = '-213';
regex.test(val) // true
val = '-213.2312';
regex.test(val) // true
val = '+213.2312';
regex.test(val) // true
val = 123;
regex.test(val) // true
val = new Number(123);
regex.test(val) // true
val = new String('123');
regex.test(val) // true
val = '1234e';
regex.test(val) // false
val = {};
regex.test(val) // false
val = false;
regex.test(val) // false
regex.test(undefined) // false
regex.test(null) // false
regex.test(window) // false
regex.test(document) // false
Если вы ищете настоящий тип, то typeof сделает это.
Ответ 22
@BitOfUniverse ответ хороший, и я придумываю новый способ:
function isNum(n) {
return !isNaN(n/0);
}
isNum('') // false
isNum(2) // true
isNum('2k') // false
isNum('2') //true
Я знаю, что 0 не может быть дивидендом, но здесь функция работает отлично.
Ответ 23
Код ниже возвращает true для чисел и false для всего остального:
!isNaN(+variable);
Ответ 24
Операция XOR может использоваться для определения числа или строки. число ^ 0 всегда будет давать число как вывод, а строка ^ 0 будет давать 0 как вывод.
Example:
1) 2 ^ 0 = 2
2) '2' ^ 0 = 2
3) 'Str' ^ 0 = 0
Ответ 25
Просто используйте
myVar.constructor == String
или
myVar.constructor == Number
если вы хотите обрабатывать строки, определенные как объекты или литералы, и сохраняет, что вы не хотите использовать вспомогательную функцию.
Ответ 26
function IsNumeric(num) {
return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}
Ответ 27
Очень поздно вечеринке; однако для меня всегда хорошо работало, когда я хочу проверить, является ли какой-либо ввод ни строкой, ни числом за один снимок.
return !!Object.prototype.toString.call(input).match(/\[object (String|Number)\]/);
Ответ 28
Создал jsperf при проверке, является ли переменная числом. Довольно интересно! typeof фактически использует производительность. Используя typeof для чего угодно, кроме чисел, обычно идет 1/3 скорость как variable.constructor, так как большинство типов данных в javascript являются объектами; чисел нет!
http://jsperf.com/jemiloii-fastest-method-to-check-if-type-is-a-number
typeof variable === 'number' | быстрый | если вы хотите число, например 5, а не "5" typeof parseFloat(variable) === 'number' | быстрый | если вы хотите число, такое как 5 и "5"
isNaN() медленнее, но не намного медленнее. Я возлагал большие надежды на parseInt и parseFloat, однако они были ужасно медленнее.
Ответ 29
Для обнаружения номеров следующий отрывок из JavaScript: "Хорошие детали" Дугласа Крокфорда актуальны:
Функция isFinite - лучший способ определить, может ли значение использоваться как число, потому что оно отклоняет NaN и Infinity. К сожалению, isFinite попытается преобразовать свой операнд в число, поэтому он не является хорошим тестом, если значение фактически не является числом. Вы можете определить свою собственную функцию isNumber:
var isNumber = function isNumber(value) { return typeof value === 'number' &&
isFinite(value);
};
Ответ 30
Вот как isString реализована в AngularJS:
function isString(value) {return typeof value === ‘string’;}
Вы также можете использовать эти 2 is-string и is-number с открытым исходным кодом, чтобы выполнить работу без дублирования.
Примеры:
isString(3) // => false
isString('') // => true
и
isNumber('') // => false