JavaScript에서 변수가 숫자인지 문자열인지 확인합니다.

JavaScript에서 변수가 숫자인지 문자열인지 확인합니다.

JavaScript에서 변수가 숫자인지 문자열인지 어떻게 확인할 수 있는지 아는 사람 있나요?

생성자가 아닌 리터럴 표기법을 사용하는 경우 type of: 를 사용할 수 있습니다.

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

방법은 ""를 사용하는 입니다.isNaN 캐스팅 + 타입 캐스팅:

업데이트된 올인 방식:

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'); // false  
isNumber(5); // true  
isNumber('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber('   '); // false

가장 좋은 방법은 문자열에서 메서드를 확인하는 것입니다.

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

또는 번호 속성 번호 확인 작업을 수행하려는 경우,

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

이것은 일종의 "duck typing"입니다. 어느 쪽이 가장 말이 되는지에 따라 달라집니다.코멘트를 할 만한 업보는 없지만 박스형 문자열과 숫자에 대한 타입은 실패합니다.

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

는 "object" 에 경고합니다.

계신 것은 ★★★★★★★★★★★★입니다.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"));

MDN의 JavaScript isN() 함수를 참조하십시오.

ES2015 이후 변수가 유효한 숫자를 보유하고 있는지 확인하는 올바른 방법은 다음과 같습니다.

예:

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

값이 문자열 리터럴 또는 문자열 개체인지 확인합니다.

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

이거 드셔보세요.

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

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

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

가장 좋은 방법:

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

//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의 완전한 예: A Better type of.

다음은 숫자 또는 문자열에 0 또는 늘 문자열을 추가하여 입력을 강제하고, 그 다음 유형화된 동등성 비교를 수행하는 아이디어에 기초한 접근법입니다.

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

은 this은,, 느 this this this this either either either either either either either either either보다 약간 빠른 .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;}

이것은 기본적으로 언더스코어 버전이며, 현재 상태로는 이 버전보다 약 4배 더 빠릅니다.isNaN()단, 밑줄 소스 내의 코멘트에서는 "NaN은 그 자체와 일치하지 않는 유일한 번호"라고 언급하고 _.isNumber에 대한 체크를 추가합니다.왜요?다른 어떤 물체들이 자신과 같지 않을까요?또, 언더 스코어는x !== +x--그러나, 그 차이는 무엇인가.+여기서 만들어요?

그럼 편집증 환자분들을 위해:

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

또는 이것

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

심플하고 철저:

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

테스트 케이스:

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

그냥 1로 나눌 수 있나요?

이 문제는 "123ABG"와 같은 문자열 입력일 것입니다.

var Check = "123ABG"

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

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

그냥 최근에 한 방법이야.

var를 문자열로 변환하면 성능이 저하된다고 생각합니다.최소한 최신 브라우저에서 수행된 이 테스트에서 알 수 있습니다.

퍼포먼스를 중시한다면 다음과 같이 하겠습니다.

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

변수가 문자열인지 확인하기 위해(사용하는 경우에도)var str = new String("foo"),str instanceof Stringtrue가 반환됩니다).

원어민용 번호인지 확인합니다.isNaN; 기능합니다.

또는 의 인버트를 사용합니다.isNaN():

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

네, jQuery's를 사용하여$.isNumeric()돈벌이가 더 재밌어요.

어, 그냥...

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

몇 달 후에 더 자세히 검토한 후, 이것은 단지 다음 사항을 보증할 뿐이다.obj메서드 또는 속성 이름을 가진 개체입니다.toLowerCase정의되어 있습니다.나는 내 대답이 부끄럽다.톱 투표 참조typeof하나.

jQuery는 다음을 사용합니다.

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

이 솔루션은 여기서 제기된 많은 문제를 해결합니다.

이것은 지금까지 사용한 방법 중 가장 신뢰할 수 있는 방법입니다.이것은 제가 발명한 것이 아니고, 원래 어디서 찾았는지 기억이 나지 않습니다.그러나 다른 기술이 실패했을 때는 효과가 있습니다.

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

Jsut an FYI, jQuery를 사용하는 경우

$.isNumeric() 

이 일을 처리할 수 있습니다.상세한 것에 대하여는, http://api.jquery.com/jQuery.isNumeric/ 를 참조해 주세요.

주의해 주세요.typeof NaN그건...'number'

typeof NaN === 'number'; // true

양수와 음수를 동시에 생각하는 가장 좋은 방법은 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;

}

오류? 정규 표현만 사용하세요! : )

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

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

typeof를 가진 문자열 '1234'는 'string'을 나타내며, 그 반대가 일어날 수 없기 때문에(123의 type은 항상 숫자입니다), 가장 좋은 것은 단순한 regex를 사용하는 것입니다./^\-?\d+$/.test(var)플로트, 정수, 음수를 일치시키는 고급형도 있습니다./^[\-\+]?[\d]+\.?(\d+)?$/의 중요한 측면.testvar가 문자열이 아닌 경우 예외를 발생시키지 않으며 값이 무엇이든 될 수 있습니다.

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 

진짜 타입을 찾고 있다면 타입만 있으면 됩니다.

@BitOfUniverse의 답변은 훌륭하고, 새로운 방법을 생각해냈다.

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

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

는 알고 있다0배당은 안 되지만, 이 기능은 완벽하게 작동합니다.

대부분의 경우, 이 타입은 저에게 매우 잘 맞습니다.if 문을 사용해 볼 수 있습니다.

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

여기서 x는 선택한 변수 이름입니다.

유형 확인

변수 유형을 할 수 .typeof★★★★★★★★★★★★★★★★★★:

typeof variable

값 확인

다음 코드는 숫자에 대해 true를 반환하고 그 외의 모든 것에 대해 false를 반환합니다.

!isNaN(+variable);

XOR 연산을 사용하여 숫자 또는 문자열을 검출할 수 있습니다.number ^ 0 은 항상 출력과 같은 숫자를 나타내며 문자열 ^ 0 은 출력으로 0 을 나타냅니다.

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

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

간단하게 사용

myVar.constructor == String

또는

myVar.constructor == Number

개체 또는 리터럴로 정의된 문자열을 처리하고 저장하려는 경우 도우미 기능을 사용하지 않을 수 있습니다.

파티에 늦었지만, 입력이 스트링인지 숫자인지 한 번에 확인하고 싶을 때는 항상 다음과 같은 것이 효과가 있었습니다.

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

jsperf로 하다꽤 흥미롭군요! 실제로 퍼포먼스 용도가 있는 타입입니다.「」를 사용합니다.typeof숫자 이외의 다른 것에 대해서는, 통상, 3분의 1의 속도로 행해집니다.variable.constructor의 데이터 이고, 가 아니기 에!javascript의 Objects는 Objects의 Objectsavascript의 Objects는 Objects입니다.

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

typeof variable === 'number'| | (' 5' 등)를| fast | '5'로 5로 변경
typeof parseFloat(variable) === 'number'| | : 5, | fast | 5 ÷ '5' 5

isNaN()더 느리지만 그렇게 느리지는 않아요.는 큰 기대를 걸고 있었다.parseInt ★★★★★★★★★★★★★★★★★」parseFloat하지만 그들은 끔찍하게 느렸다.

언급URL : https://stackoverflow.com/questions/1303646/check-whether-variable-is-number-or-string-in-javascript