web-dev-qa-db-ja.com

JavaScriptで変数が数値か文字列かを確認する

JavaScriptで変数が数値か文字列かを確認する方法を知っている人はいますか。

javascripttypes
435
Jin Yong

コンストラクタではなくリテラル表記を扱っている場合は、 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
420
Sampson

そのための最善の方法は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'); // true  
isNumber (5); // true  
isNumber ('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber('   '); // false
187
BitOfUniverse

私が見つけた最善の方法は、文字列のメソッドをチェックすることです。

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

またはnumberプロパティのnumberチェックで何かしたい場合は、

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

これは「ダックタイピング」のようなもので、どちらが最も理にかなっているかはあなた次第です。私はコメントするのに十分なカルマを持っていません、しかし、typeofは箱で囲まれたストリングと数のために失敗します、すなわち：

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

「オブジェクト」を警告します。

74
Alokito

値が文字列リテラルかStringオブジェクトかを確認します。

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);
}
28
snorbi

あなたは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"));

JavaScript isNaN（）関数 MDNでの参照。

27
Jakob Gade

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
19
adius

これを試して、

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

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

if(isInteger("1a11")) {
   console.log( 'Integer' );
} else {
   console.log( 'Non Integer' );
}
</script>
17
adatapost
//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'

2012年5月12日更新： Javascriptでの完全な例： のより良いtypeof。

13
mrrena

これを行うための最良の方法：

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
Sitch

あなたはそれを1で割ることができますか？

私は問題が "123ABG"のような文字列入力であると思います

var Check = "123ABG"

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

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

私が最近やった方法のひとつです。

8
Luke

これは、ゼロまたはNULL文字列を追加して入力を数値または文字列に強制変換してから、型付き等価比較を実行するという考えに基づくアプローチです。

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()の約4倍の速さですが、アンダースコアソースのコメントでは「NaNはそれ自体と等しくない唯一の number 」であり、_のチェックを追加しています。 isNumberです。どうして？他にどのようなものが彼ら自身と同等ではないでしょうか？また、アンダースコアはx !== +x--を使いますが、ここでの+の違いはなんでしょうか。

それから妄想のために：

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

ええと、どうですか。

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

数か月後にさらに検討した後、これはobjがメソッドまたはプロパティ名toLowerCaseが定義されているオブジェクトであることのみを保証します。私は私の答えを恥ずかしく思います。トップ投票のtypeofを見てください。

7
ZagNut

または単にisNaNの反転を使う

if（！isNaN（data））それ以外の場合は文字列

そうです - jQueryを使う - $ .isNumeric（）は、支出に対してもっと楽しいです。

6
osomanden

Varを文字列に変換するとパフォーマンスが低下すると思います。少なくともこの テスト は最新のブラウザで実行されます。

それであなたがパフォーマンスを気にするならば、私はそうするでしょう、私はこれを使います：

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

変数が文字列かどうかをチェックします（たとえvar str = new String("foo")を使っていてもstr instanceof Stringはtrueを返します）。

それが数字かどうかをチェックするために私はネイティブのために行くだろう：isNaN;関数。

6
Roland

この解決策はここで提起された問題の多くを解決します！

これは私がこれまでに使った中で最も信頼できる方法です。私はこれを発明しませんでした、そして私が最初にそれを見つけた場所を思い出すことができません。しかし、それは他のテクニックが失敗するところでうまくいきます：

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

jQueryはこれを使用します。

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

FYIをJsut、あなたがあなたが持っているjQueryを使っているなら

$.isNumeric()

これを処理します。 http://api.jquery.com/jQuery.isNumeric/ /に関する詳細

4
Angelos

typeofはほとんどの場合私にとって非常にうまく機能します。 if文を使ってみることができます

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

xは任意の変数名です。

4
Tanah

@ BitOfUniverseの答えは良いです、そして私は新しい方法を思い付きました：

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

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

0は配当できないことを私は知っていますが、ここで関数は完全に機能します。

3
towry

私が見つけた最良の方法は正と負の数についても考えることです： O'Reilly JavascriptとDHTML Cookbook ：

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
Alex Peta

typeofを含む '1234'のような文字列は '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だけがするでしょう。

3
pocesar

え？正規表現を使ってください。 :)

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

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

XOR演算を使用して、数値または文字列を検出できます。 number ^ 0は常に数値を出力として与え、string ^ 0は0を出力として与えます。

Example: 
   1)  2 ^ 0 = 2
   2)  '2' ^ 0  = 2
   3)  'Str' ^ 0 = 0
1
Himanshu Shekhar
function IsNumeric(num) {
    return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}
0
hosein

これについてどう思いますか？

const numberOrString='10' 
const isNumber = !isNaN(numberOrString*1)
0
Yoraco Gonzales

数字を検出するための、JavaScriptからの次の文章：Douglas CrockfordによるThe Good Partsが関連しています。

IsFinite関数は、NaNとInfinityを拒否するため、値を数値として使用できるかどうかを判断するための最良の方法です。残念ながら、isFiniteはそのオペランドを数値に変換しようとするので、値が実際には数値ではない場合、それは良いテストではありません。あなたはあなた自身のisNumber関数を定義したいかもしれません：

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

あなただけを使用することができます：

!isNaN(+variable);
0
Amir Forsati

パーティーにとても遅刻しました。ただし、入力が文字列なのか数値なのかを一度に確認したい場合は、次のようにしてください。

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

単に使う

myVar.constructor == String

または

myVar.constructor == Number

オブジェクトまたはリテラルとして定義された文字列を処理したい場合や、保存する場合は、ヘルパー関数を使用したくありません。

0
Jonathon

変数が数値であるかどうかのチェックでjsperfを作成しました。とてもおもしろい！ typeofは実際にはパフォーマンスを発揮します。数値以外のものにtypeofを使用すると、javascriptのデータ型の大部分はオブジェクトであるため、一般にvariable.constructorの3分の1の速度になります。数字は違います！

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に大きな期待を寄せていましたが、それらは恐ろしく遅くなりました。

0
jemiloii