JavaScript'te değişkenin sayı mı yoksa dize mi olduğunu kontrol edin

Herkes bir değişkenin JavaScript'te bir sayı mı yoksa dize mi olduğunu nasıl kontrol edebilirim?

Yapıcılarla değil, gerçek gösterimle uğraşıyorsanız, typeof : kullanabilirsiniz .

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

Bir kurucu aracılığıyla sayılar ve dizeler oluşturuyorsanız, bunun için geri dönebileceğini var foo = new String("foo")unutmayın .typeofobjectfoo

Belki de türü kontrol etmek için daha kusursuz bir yöntem, underscore.js'de bulunan yöntemi kullanmak olacaktır (açıklamalı kaynak burada bulunabilir ),

var toString = Object.prototype.toString;

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

Bu true, aşağıdakiler için bir boole döndürür :

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

Bunu yapmanın en iyi yolu isNaN+ tip döküm kullanmaktır:

Güncellenmiş all-in yöntemi:

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

Regex kullanarak aynı:

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

Bulduğum en iyi yolu, dize, yani:

if (x.substring) {
// do string thing
} else{
// do other thing
}

veya bir sayı özelliği için sayı denetimi ile bir şeyler yapmak istiyorsanız,

if (x.toFixed) {
// do number thing
} else {
// do other thing
}

Bu bir çeşit "ördek yazarak" gibi, en mantıklı olan size kalmış. Yorum yapmak için yeterli karma yok, ama typeof kutulu dizeler ve sayılar için başarısız, yani:

alert(typeof new String('Hello World'));
alert(typeof new Number(5));

"nesne" uyarısı verir.

Şunu arıyorsunuz 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"));

Bkz. MDN'de JavaScript isNaN () İşlevi .

Değerin bir dize değişmezi mi yoksa String nesnesi mi olduğunu kontrol edin:

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

Ünite testi:

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

Bir sayıyı kontrol etmek benzerdir:

function isNumber(o) {
    return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}

ES2015'ten beri bir değişkenin geçerli bir sayı olup olmadığını kontrol etmenin doğru yolu Number.isFinite(value)

Örnekler:

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

Bunu dene,

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

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

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

Bunu yapmanın en iyi yolu:

function isNumber(num) {
  return (typeof num == 'string' || typeof num == 'number') && !isNaN(num - 0) && num !== '';
};

Bu, aşağıdaki test senaryolarını karşılar:

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

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

Veya bilinmeyen bir tür döndürmek için uyarlayın:

function realTypeOf(obj) {
    return Object.prototype.toString.call(obj).slice(8, -1);
}

//usage
realTypeOf(999); // 'Number'

12 Mayıs 2012 Güncelleme: Javascript'te tam örnek : A Better typeof .

İşte sıfır veya null dize ekleyerek girdiyi bir sayıya veya dizeye zorlama fikrine dayanan ve ardından yazılan eşitlik karşılaştırması yapan bir yaklaşım.

function is_number(x) { return x === x+0;  }
function is_string(x) { return x === x+""; }

Bazı anlaşılmaz nedenlerden dolayı, x===x+0daha iyi performans gösteriyor gibi görünüyor x===+x.

Bunun başarısız olduğu durumlar var mı?

Aynı damarda:

function is_boolean(x) { return x === !!x; }

Bu hafif daha hızlı görünüyor ya x===true || x===falseya typeof x==="boolean"(ve çok daha hızlı x===Boolean(x)).

Sonra da var

function is_regexp(x)  { return x === RegExp(x); }

Bütün bunlar, herhangi bir değere uygulanabilen ve söz konusu türden bir değeri güvenilir bir şekilde üretebilen, her tipe özgü bir "kimlik" işleminin varlığına bağlıdır. Tarihler için böyle bir operasyon düşünemiyorum.

NaN için,

function is_nan(x) { return x !== x;}

Bu temelde alt çizginin sürümüdür ve durduğu noktadan yaklaşık dört kat daha hızlıdır isNaN(), ancak alt çizgi kaynağındaki yorumlar "NaN, kendine eşit olmayan tek sayıdır " ve _.isNumber için bir kontrol ekler. Neden? Başka hangi nesneler kendilerine eşit olmaz? Ayrıca, alt çizgi kullanır - x !== +xama +burada ne fark yaratabilir ?

Sonra paranoyak için:

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

veya bu

function is_undefined(x) { return x===void(0); }

Sadece 1'e bölebilir misin?

Sorunun "123ABG" gibi bir dize girişi olacağını varsayalım.

var Check = "123ABG"

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

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

Son zamanlarda yaptığım gibi.

ah, ne dersin:

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

Birkaç ay sonra tekrar gözden geçirildikten sonra, bu yalnızca garantiler obj, yöntem veya özellik adı toLowerCasetanımlanmış bir nesnedir . Cevabımdan utanıyorum. Lütfen en çok oy alanlara bakın typeof.

Veya sadece ters çevirmeyi kullanın isNaN():

if(!isNaN(data))
  do something with the number
else
  it is a string

Ve evet, jQuery's kullanmak $.isNumeric()para için daha eğlenceli.

Ben var bir dizeye dönüştürmek performansı düşürür düşünüyorum, en azından en son tarayıcılarda yapılan bu test öyle gösterir.

Performansı önemsiyorsanız, bunu kullanırdım:

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

Değişken bir dize ise kontrol için (eğer kullansanız bile var str = new String("foo"), str instanceof Stringgerçek dönecekti).

Bir sayı olup olmadığını kontrol gelince yerli için gitmek istiyorum isNaN; işlevi.

jQuery bunu kullanır:

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

Bu çözüm, burada ortaya çıkan sorunların çoğunu çözmektedir!

Bu şimdiye kadar kullandığım en güvenilir yöntem. Bunu icat etmedim ve nereden bulduğumu hatırlayamıyorum. Ancak diğer tekniklerin başarısız olduğu yerlerde çalışır:

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

Doğruluk örneği

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"

Jsut bir FYI, jQuery kullanıyorsanız

$.isNumeric() 

bunu halletmek için. Http://api.jquery.com/jQuery.isNumeric/ hakkında daha fazla bilgi

typeof çoğu durumda benim için çok iyi çalışıyor. Bir if ifadesi kullanmayı deneyebilirsiniz

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

burada x, seçtiğiniz herhangi bir değişken addır

Pozitif ve negatif sayıları da düşünen en iyi yol: O'Reilly Javascript ve DHTML Yemek Tarifleri :

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;

}

Errr? Sadece düzenli ifadeler kullanın! :)

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

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

typeof ile '1234' olarak bir dize 'string' göstereceğinden ve tersi asla gerçekleşemeyeceğinden (123 tipi typeof daima sayı olacaktır), en iyisi basit bir normal ifade kullanmaktır /^\-?\d+$/.test(var). Ya da kayan, tamsayı ve negatif sayıları eşleştirmek için daha gelişmiş, /^[\-\+]?[\d]+\.?(\d+)?$/ Önemli tarafı .testvar bir dize değilse bir istisna atmayacak, değer herhangi bir şey olabilir.

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 

Gerçek türü arıyorsanız, o zaman yalnız typeof yapacak.

@ BitOfUniverse'nin cevabı iyi ve ben yeni bir yol buluyorum:

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

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

0Temettü olamayacağımı biliyorum , ama burada fonksiyon mükemmel çalışıyor.

Tip kontrolü

typeofİşleç kullanarak değişken türünü kontrol edebilirsiniz :

typeof variable

Değer kontrolü

Aşağıdaki kod, sayılar için true, başka bir şey için false döndürür:

!isNaN(+variable);

XOR işlemi sayı veya dizeyi algılamak için kullanılabilir. ^ 0 sayısı her zaman sayıyı çıktı olarak verir ve dize ^ 0 çıktı olarak 0 verir.

Example: 
   1)  2 ^ 0 = 2
   2)  '2' ^ 0  = 2
   3)  'Str' ^ 0 = 0

Basit ve kapsamlı:

function isNumber(x) {
  return parseFloat(x) == x
};

Test senaryoları:

console.log('***TRUE CASES***');
console.log(isNumber(0));
console.log(isNumber(-1));
console.log(isNumber(-500));
console.log(isNumber(15000));
console.log(isNumber(0.35));
console.log(isNumber(-10.35));
console.log(isNumber(2.534e25));
console.log(isNumber('2.534e25'));
console.log(isNumber('52334'));
console.log(isNumber('-234'));
console.log(isNumber(Infinity));
console.log(isNumber(-Infinity));
console.log(isNumber('Infinity'));
console.log(isNumber('-Infinity'));

console.log('***FALSE CASES***');
console.log(isNumber(NaN));
console.log(isNumber({}));
console.log(isNumber([]));
console.log(isNumber(''));
console.log(isNumber('one'));
console.log(isNumber(true));
console.log(isNumber(false));
console.log(isNumber());
console.log(isNumber(undefined));
console.log(isNumber(null));
console.log(isNumber('-234aa'));

Basitçe kullanın

myVar.constructor == String

veya

myVar.constructor == Number

nesne veya değişmez olarak tanımlanan dizeleri işlemek ve bir yardımcı işlevi kullanmak istemezsiniz.

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

Partiye çok geç; Ancak, bazı girişlerin bir dize veya tek çekimde bir sayı olup olmadığını kontrol etmek istediğimde, aşağıdakiler her zaman benim için iyi çalıştı.

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

Bir değişkenin sayı olup olmadığını kontrol ederken bir jsperf oluşturdu. Oldukça ilginç! typeof aslında bir performans kullanımı vardır. Kullanılması typeofsayıların dışında herhangi bir şey için, genellikle bir 1 / 3rd hızını gider variable.constructorjavascript nesneler şunlardır veri tiplerinin çoğunluğu beri; sayılar değil!

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

typeof variable === 'number'| en hızlı | 5 gibi bir sayı istiyorsanız, '5' değil
typeof parseFloat(variable) === 'number'| en hızlı | 5 ve '5' gibi bir sayı istiyorsanız

isNaN()daha yavaş, ama o kadar yavaş değil. Ben yüksek umutları vardı parseIntve parseFloatancak korkunç derecede yavaş.

Sayıları tespit etmek için JavaScript'ten aşağıdaki pasaj: Douglas Crockford'un İyi Bölümleri önemlidir:

İsFinite işlevi, bir değerin sayı olarak kullanılıp kullanılamayacağını belirlemenin en iyi yoludur, çünkü NaN ve Infinity'yi reddeder. Ne yazık ki, isFinite işlenenini bir sayıya dönüştürmeye çalışacaktır, bu nedenle bir değer aslında bir sayı değilse iyi bir test değildir. Kendi isNumber işlevinizi tanımlamak isteyebilirsiniz:

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