Проверьте, является ли переменная number или string в JavaScript

кто-нибудь знает как я могу проверить, является ли переменная числом или строкой в JavaScript?

417
javascript types

27 ответов

если вы имеете дело с буквальной нотацией, а не с конструкторами, вы можете использовать typeof на:.

typeof "Hello World"; // string
typeof 123;           // number

если вы создаете числа и строки с помощью конструктора, например var foo = new String("foo"), вы должны иметь в виду, что typeof может возвратить object на foo.

возможно, более надежным методом проверки типа было бы использовать метод, найденный в подчеркивания.js (аннотированный источник можно найти здесь),

var toString = Object.prototype.toString;

_.isString = function (obj) {
  return toString.call(obj) == '[object String]';
}

это возвращает логическое true следующее:

_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true
404

лучший способ сделать это-использовать isnan + тип литья:

обновлен метод all-in:

function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }

то же самое с помощью regex:

function isNumber(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); } 

------------------------

isNumber ('123'); // true  
isNumber ('123abc'); // true  
isNumber (5); // true  
isNumber ('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber('   '); // false
179

лучший способ, который я нашел, - либо проверить метод на строке, т. е.:

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

предупредит "объект".

72

проверьте, является ли значение строковым литералом или строковым объектом:

function isString(o) {
    return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}

единица тест:

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

вы ищете isNaN():

<script type="text/javascript">
  alert(isNaN(123));
  alert(isNaN(-1.23));
  alert(isNaN(5-2));
  alert(isNaN(0));
  alert(isNaN("Hello"));
  alert(isNaN("2005/12/12"));
</script>

посмотреть функция JavaScript isNaN () в MDN.

22

попробуйте это,

<script>
var regInteger = /^\d+$/;

function isInteger( str ) {    
    return regInteger.test( str );
}

if(isInteger("1a11")) {
   console.log( 'Integer' );
} else {
   console.log( 'Non Integer' );
}
</script>
17

начиная с 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
16
//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: лучший typeof.

13

лучший способ сделать это:

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));
12

вот подход, основанный на идее принуждения ввода к числу или строке путем добавления нуля или нулевой строки, а затем выполните типизированное сравнение равенства.

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 или 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--но какая разница + здесь делают?

тогда для параноиков:

function is_undefined(x) { return x===[][0]; }
8

вы можете просто разделить его на 1?

Я предполагаю, что проблема будет строковым входом, например: "123ABG"

var Check = "123ABG"

if(Check == Check / 1)
{
alert("This IS a number \n")
}

else
{
alert("This is NOT a number \n")
}

просто так я сделал это недавно.

7

как насчет просто:

function IsString(obj) {
    return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}

после дальнейшего рассмотрения много месяцев спустя, это только гарантирует obj - это объект с именем метода или свойства toLowerCase определенными. Мне стыдно за свой ответ. Пожалуйста, смотрите top-voted typeof один.

7

Я думаю, что преобразование var в строку снижает производительность, по крайней мере, это тест выполняется в последних браузерах показывает так.

поэтому, если вы заботитесь о производительности, я бы, я бы использовал это:

typeof str === "string" || str instanceof String

для проверки, является ли переменная строкой (даже если вы используете var str = new String("foo"), str instanceof String вернет true).

что касается проверки, если это номер, я бы пошел на родной:isNaN; функция.

6

или просто используйте инверт isNaN

if (!isNaN(данные)) сделайте что-нибудь с номером еще это строка

и да-с помощью jQuery -$.isNumeric () больше удовольствия для доллара.

5

Это решение решает многие вопросы, поднятые здесь!

это, безусловно,самый надежный метод, который я использовал. Я не изобретал его и не могу вспомнить, где я его нашел. Но он работает там, где другие методы терпят неудачу:

// 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"
4

вызова typeof работает очень хорошо для меня в большинстве случаев. Вы можете попробовать использовать оператор if

if(typeof x === 'string' || typeof x === 'number') {
    console.log("Your statement");
}

где x-любое имя переменной по вашему выбору

4

лучший способ, который я нашел, который также думает о положительных и отрицательных числах, - это : O'Reilly Javascript и 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;

}

3

Errr? Просто используйте регулярные выражения! :)

function isInteger(val) {
  return val.match(/^[0-9]$/)
}

function isFloat(val) {
  return val.match(/^[0-9]*/\.[0-9]+$/)
}
3

поскольку строка как "1234" с typeof покажет "строку", а обратное никогда не может произойти (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 в одиночку будет делать.

3

ответ@BitOfUniverse хорош, и я придумываю новый способ:

function isNum(n) {
    return !isNaN(n/0);
}

isNum('')  // false
isNum(2)   // true
isNum('2k') // false
isNum('2')  //true

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

3

Jsut FYI, если вы используете jQuery, у вас есть

$.isNumeric()

чтобы справиться с этим. Подробнее оhttp://api.jquery.com/jQuery.isNumeric/

3

jQuery использует это:

function isNumber(obj) {
  return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}
2

просто использовать 

myVar.constructor == String

или

myVar.constructor == Number

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

0
function IsNumeric(num) {
    return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}
0

очень поздно на вечеринку; однако следующее Всегда хорошо работало для меня, когда я хочу проверить, является ли какой-либо вход строкой или числом в одном кадре.

return !!Object.prototype.toString.call(input).match(/\[object (String|Number)\]/);
0

создал jsperf при проверке, является ли переменная числом. Очень интересно! typeof фактически использует производительность. Используя typeof для чего-либо, кроме чисел, как правило, идет 1/3 скорость как variable.constructor поскольку большинство типов данных в javascript являются объектами; числа-нет!

http://jsperf.com/jemiloii-fastest-method-to-check-if-type-is-a-number

typeof variable === 'number' / fastest | если вы хотите число, например 5, а не '5'
typeof parseFloat(variable) === 'number' / самый быстрый | если вы хотите число, например, 5 и'5'

isNaN() медленнее, но не намного медленнее. Я возлагал большие надежды на parseInt и parseFloat, однако они были ужасно медленнее.

0

для обнаружения чисел имеет значение следующий отрывок из JavaScript: хорошие части Дугласа Крокфорда:

функция isFinite-лучший способ определить, может ли значение использоваться как число, потому что оно отвергает NaN и бесконечность . К сожалению, isFinite попытается преобразовать операнд в число, это не хороший тест, если значение на самом деле не число. Вы можете определить свою собственную функцию isNumber:

var isNumber = function isNumber(value) { return typeof value === 'number' &&
            isFinite(value);
};
0