숫자가 부동 또는 정수인지 어떻게 확인합니까?

어떻게 숫자입니다 찾기하는 float나 integer?

1.25 --> float  
1 --> integer  
0 --> integer  
0.25 --> float

1로 나눌 때 나머지를 확인하십시오.

function isInt(n) {
   return n % 1 === 0;
}

인수가 숫자인지 모른다면 두 가지 테스트가 필요합니다.

function isInt(n){
    return Number(n) === n && n % 1 === 0;
}

function isFloat(n){
    return Number(n) === n && n % 1 !== 0;
}

이 답변이 작성된 후 5 년이 지난 2019 년 업데이트 된 솔루션은 ECMA Script 2015에서 표준화되었습니다.이 솔루션은 이 답변에서 다룹니다 .

이 함수를 사용하여 값이 소수 부분이없고 정확한 정수로 표시 될 수있는 크기 한계 내에있는 숫자 기본 값인지 테스트하십시오.

function isFloat(n) {
    return n === +n && n !== (n|0);
}

function isInteger(n) {
    return n === +n && n === (n|0);
}

왜 이런 식으로하지?

var isInt = function(n) { return parseInt(n) === n };

Number.isInteger()IE 이외의 모든 것에 현재 구현되어 있는 메소드 가 있습니다. MDN 은 다른 브라우저를위한 폴리 필도 제공합니다.

Number.isInteger = Number.isInteger || function(value) {
  return typeof value === 'number' && 
    isFinite(value) && 
    Math.floor(value) === value;
};

그러나 대부분의 사용 사례의 경우 Number.isSafeInteger 값을 너무 높거나 낮게 설정하여 소수점 이하 자릿수가 손실되었는지 확인하는 것이 좋습니다. MDN 에는 이에 대한 폴리 파일도 있습니다. (또한 isInteger위 의 pollyfill이 필요합니다 .)

if (!Number.MAX_SAFE_INTEGER) {
    Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
}
Number.isSafeInteger = Number.isSafeInteger || function (value) {
   return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};

간단한 정규식을 사용할 수 있습니다.

function isInt(value) {

    var er = /^-?[0-9]+$/;

    return er.test(value);
}

또는 필요에 따라 아래 기능도 사용할 수 있습니다. 그것들은 PHPJS Project에 의해 개발되었습니다 .

is_int() => 변수 유형이 정수인지, 내용이 정수인지 확인

is_float() => 변수 유형이 부동인지 그리고 내용이 부동인지 확인

ctype_digit() => 변수 유형이 문자열인지, 내용에 10 진수 만 있는지 확인하십시오.

업데이트 1

이제 @ChrisBartley 의견에 감사드립니다 .

다음은 값이 숫자인지 또는 숫자로 안전하게 변환 될 수 있는지 확인하는 효율적인 함수입니다 .

function isNumber(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    if (typeof value == 'number') {
        return true;
    }
    return !isNaN(value - 0);
}

그리고 정수의 경우 (값이 float이면 false를 반환합니다) :

function isInteger(value) {
    if ((undefined === value) || (null === value)) {
        return false;
    }
    return value % 1 == 0;
}

여기서 효율성은 값이 이미 숫자 인 경우 parseInt (또는 parseNumber)를 피할 수 있다는 것입니다. 두 구문 분석 함수는 항상 문자열로 먼저 변환 한 다음 해당 문자열을 구문 분석하려고 시도합니다. 값이 이미 숫자이면 낭비입니다.

최적화를위한 추가 아이디어를 제공 한 다른 게시물에 감사합니다!

function isInteger(x) { return typeof x === "number" && isFinite(x) && Math.floor(x) === x; }
function isFloat(x) { return !!(x % 1); }

// give it a spin

isInteger(1.0);        // true
isFloat(1.0);          // false
isFloat(1.2);          // true
isInteger(1.2);        // false
isFloat(1);            // false
isInteger(1);          // true    
isFloat(2e+2);         // false
isInteger(2e+2);       // true
isFloat('1');          // false
isInteger('1');        // false
isFloat(NaN);          // false
isInteger(NaN);        // false
isFloat(null);         // false
isInteger(null);       // false
isFloat(undefined);    // false
isInteger(undefined);  // false

function isInt(n) 
{
    return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
    return n != "" && !isNaN(n) && Math.round(n) != n;
}

모든 경우에 작동합니다.

다른 사람들이 언급했듯이 JS에는 두 배만 있습니다. 그렇다면 숫자를 정수로 어떻게 정의합니까? 반올림 된 숫자가 자신과 같은지 확인하십시오.

function isInteger(f) {
    return typeof(f)==="number" && Math.round(f) == f;
}
function isFloat(f) { return typeof(f)==="number" && !isInteger(f); }

이건 어때?

isFloat(num) {
    return typeof num === "number" && !Number.isInteger(num);
}

정수에 사용하는 것은 다음과 같습니다.

Math.ceil(parseFloat(val)) === val

짧고 좋은 :) 항상 작동합니다. 내가 틀리지 않으면 David Flanagan이 제안한 것입니다.

실제로 달성하려는 목표에 달려 있습니다. 강력하게 입력 된 언어를 "에뮬레이션"하려면 시도하지 않는 것이 좋습니다. 다른 사람들이 언급했듯이 모든 숫자는 동일한 표현 (동일한 유형)을 갖습니다.

Claudiu 와 같은 것을 사용하여 제공했습니다 :

isInteger( 1.0 ) -> 참

상식으로는 괜찮아 보이지만 C와 같은 방식으로 얻을 수 있습니다. false

소수점 이하 자릿수가 0 인 부동 소수점 숫자 (예 : 1.0, 12.00, 0.0)는 암시 적으로 정수로 캐스트되므로 부동 소수점인지 여부를 확인할 수 없습니다.

!!(24%1) // false
!!(24.2%1) // true

실제로 그렇게 복잡 할 필요는 없습니다. 정수의 parseFloat () 및 parseInt ()에 해당하는 숫자 값은 동일합니다. 따라서 다음과 같이 할 수 있습니다.

function isInt(value){ 
    return (parseFloat(value) == parseInt(value)) && !isNaN(value);
}

그때

if (isInt(x)) // do work

이것은 또한 문자열 검사를 허용하므로 엄격하지 않습니다. 강력한 유형의 솔루션을 원한다면 (일명 문자열로 작동하지 않음) :

function is_int(value){ return !isNaN(parseInt(value * 1) }

var isInt = function (n) { return n === (n | 0); };

이것이 일을하지 않은 경우가 없었습니다.

이 코드는 INT 및 플로트 확인을위한 최종 코드입니다

function isInt(n) { 
   if(typeof n == 'number' && Math.Round(n) % 1 == 0) {
       return true;
   } else {
       return false;
   }
} 

또는

function isInt(n) {   
   return typeof n == 'number' && Math.Round(n) % 1 == 0;   
}   

function isInteger(n) {
   return ((typeof n==='number')&&(n%1===0));
}

function isFloat(n) {
   return ((typeof n==='number')&&(n%1!==0));
}

function isNumber(n) {
   return (typeof n==='number');
}

다음과 같이 간단합니다.

if( n === parseInt(n) ) ...

콘솔에서 이것을 시도하십시오 :

x=1;
x===parseInt(x); // true
x="1";
x===parseInt(x); // false
x=1.1;
x===parseInt(x); // false, obviously

// BUT!

x=1.0;
x===parseInt(x); // true, because 1.0 is NOT a float!

이것은 많은 사람들을 혼란스럽게합니다. 무언가가 .0 일 때마다 더 이상 부동이 아닙니다. 정수입니다. 또는 C에서와 같이 엄격한 구별이 없기 때문에 그냥 "숫자"라고 부를 수 있습니다.

따라서 기본적으로 할 수있는 것은 1.000이 정수라는 사실을 받아들이는 정수를 확인하는 것입니다.

재미있는 사이드 노트

거대한 숫자에 대한 의견이있었습니다. 숫자가 크면이 방법에 아무런 문제가 없습니다. parseInt가 숫자를 처리 할 수 ​​없을 때마다 (너무 큰 경우) 실제 값 이외의 값을 반환하므로 테스트에서 FALSE를 반환합니다. 이것은 "숫자"로 간주 될 경우 일반적으로 JS 가이 를 계산할 수 있기를 기대하기 때문에 좋은 것입니다. 그렇습니다 .

이 시도:

<script>

var a = 99999999999999999999;
var b = 999999999999999999999; // just one more 9 will kill the show!
var aIsInteger = (a===parseInt(a))?"a is ok":"a fails";
var bIsInteger = (b===parseInt(b))?"b is ok":"b fails";
alert(aIsInteger+"; "+bIsInteger);

</script>

내 브라우저 (IE8)에서 이것은 "a is ok; b failed"를 반환합니다. 이것은 정확히 b의 숫자 때문입니다. 한계는 다를 수 있지만 20 자리는 "누구에게 충분해야한다"고 고전을 인용합니다. :)

이 솔루션은 저에게 효과적이었습니다.

<html>
<body>
  <form method="post" action="#">
    <input type="text" id="number_id"/>
    <input type="submit" value="send"/>
  </form>
  <p id="message"></p>
  <script>
    var flt=document.getElementById("number_id").value;
    if(isNaN(flt)==false && Number.isInteger(flt)==false)
    {
     document.getElementById("message").innerHTML="the number_id is a float ";
    }
   else 
   {
     document.getElementById("message").innerHTML="the number_id is a Integer";
   }
  </script>
</body>
</html>

정수의 경우 이것을 사용합니다

function integer_or_null(value) {
    if ((undefined === value) || (null === value)) {
        return null;
    }
    if(value % 1 != 0) {
        return null;
    }
    return value;
}

자바 스크립트에서 모든 숫자는 internally 64 bit floating pointjava의 double과 동일합니다. 자바 스크립트에는 다른 유형이 없으며 모두 유형으로 표시됩니다 number. 따라서 당신은 instanceof수표를 만들 수 없습니다 . 그러나 위의 솔루션을 사용하여 소수인지 확인할 수 있습니다. Java 스크립트 디자이너는 단일 유형을 사용하여 수많은 유형 캐스트 ​​오류를 ​​피할 수 있습니다.

때때로 Number 객체를 사용하면 mod 연산자 (%)를 직접 사용할 수 없습니다.이 경우에는이 솔루션을 사용할 수 있습니다.

if(object instanceof Number ){
   if( ((Number) object).doubleValue() % 1 == 0 ){
      //your object is an integer
   }
   else{
      //your object is a double
   }
}

여기에 대한 답변 중 일부를 시도하면이 솔루션을 작성하게되었습니다. 이것은 문자열 안의 숫자와도 작동합니다.

function isInt(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return !(number - parseInt(number));
}

function isFloat(number) {
    if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
    return number - parseInt(number) ? true : false;
}

    var tests = {
        'integer' : 1,
        'float' : 1.1,
        'integerInString' : '5',
        'floatInString' : '5.5',
        'negativeInt' : -345,
        'negativeFloat' : -34.98,
        'negativeIntString' : '-45',
        'negativeFloatString' : '-23.09',
        'notValidFalse' : false,
        'notValidTrue' : true,
        'notValidString' : '45lorem',
        'notValidStringFloat' : '4.5lorem',
        'notValidNan' : NaN,
        'notValidObj' : {},
        'notValidArr' : [1,2],
    };

    function isInt(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return !(number - parseInt(number));
    }
    
    function isFloat(number) {
        if(!/^["|']{0,1}[-]{0,1}\d{0,}(\.{0,1}\d+)["|']{0,1}$/.test(number)) return false;
        return number - parseInt(number) ? true : false;
    }

    function testFunctions(obj) {
        var keys = Object.keys(obj);
        var values = Object.values(obj);

        values.forEach(function(element, index){
            console.log(`Is ${keys[index]} (${element}) var an integer? ${isInt(element)}`);
            console.log(`Is ${keys[index]} (${element}) var a float? ${isFloat(element)}`);
        });
    }

    testFunctions(tests);

이것은 아마도 % 답변만큼 성능이 좋지 않아서 문자열로 먼저 변환하지 않아도되지만 아직 아무도 게시하지는 않았으므로 제대로 작동 해야하는 다른 옵션이 있습니다.

function isInteger(num) {
    return num.toString().indexOf('.') === -1;
}

궁금한 점이 Benchmark.js를 사용 하여이 게시물에서 가장 많이 투표 된 답변 (오늘 게시 된 답변)을 테스트 한 결과는 다음과 같습니다.

var n = -10.4375892034758293405790;
var suite = new Benchmark.Suite;
suite
    // kennebec
    .add('0', function() {
        return n % 1 == 0;
    })
    // kennebec
    .add('1', function() {
        return typeof n === 'number' && n % 1 == 0;
    })
    // kennebec
    .add('2', function() {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    })

    // Axle
    .add('3', function() {
        return n.toString().indexOf('.') === -1;
    })

    // Dagg Nabbit
    .add('4', function() {
        return n === +n && n === (n|0);
    })

    // warfares
    .add('5', function() {
        return parseInt(n) === n;
    })

    // Marcio Simao
    .add('6', function() {
        return /^-?[0-9]+$/.test(n.toString());
    })

    // Tal Liron
    .add('7', function() {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    });

// Define logs and Run
suite.on('cycle', function(event) {
    console.log(String(event.target));
}).on('complete', function() {
    console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run({ 'async': true });

0 x 12,832,357 ops/sec ±0.65% (90 runs sampled)
1 x 12,916,439 ops/sec ±0.62% (95 runs sampled)
2 x 2,776,583 ops/sec ±0.93% (92 runs sampled)
3 x 10,345,379 ops/sec ±0.49% (97 runs sampled)
4 x 53,766,106 ops/sec ±0.66% (93 runs sampled)
5 x 26,514,109 ops/sec ±2.72% (93 runs sampled)
6 x 10,146,270 ops/sec ±2.54% (90 runs sampled)
7 x 60,353,419 ops/sec ±0.35% (97 runs sampled)

Fastest is 7 Tal Liron

여기 내 코드가 있습니다. 빈 문자열이 아닌지 확인하고 (그렇지 않으면 전달됨) 숫자 형식으로 변환합니다. 이제 '1.1'을 1.1로 원하는지 여부에 따라 원하는 것이거나 아닐 수도 있습니다.

var isFloat = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseFloat(n));
};
var isInteger = function(n) {
    n = n.length > 0 ? Number(n) : false;
    return (n === parseInt(n));
};

var isNumeric = function(n){

   if(isInteger(n) || isFloat(n)){
        return true;
   }
   return false;

};

양의 정수와 음의 정수 모두에 대해 true를 반환하는이 작은 함수를 좋아합니다.

function isInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}

이것은 1 또는 "1"이 "1.0"이되고, isNaN ()은 false를 반환하지만 (부정하고 리턴) 1.0 또는 "1.0"은 "1.0.0"이되고 "string"은 "string"이되기 때문에 작동합니다. 0 "은 숫자가 아니므로 isNaN ()은 false를 반환합니다 (다시 부정됩니다).

양의 정수만 원하면 다음과 같은 변형이 있습니다.

function isPositiveInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}

또는 음의 정수인 경우 :

function isNegativeInt(val) {
    return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}

isPositiveInt ()는 연결된 숫자 문자열을 테스트 할 값보다 먼저 이동하여 작동합니다. 예를 들어, isPositiveInt (1)은 "01"을 평가하는 isNaN ()의 결과로 거짓을 평가합니다. 한편, isPositiveInt (-1)은 "0-1"을 평가하는 isNaN ()이되며, 이는 참으로 평가됩니다. 우리는 반환 값을 부정하고 우리가 원하는 것을 제공합니다. isNegativeInt ()는 비슷하게 작동하지만 isNaN ()의 반환 값을 무시하지 않습니다.

편집하다:

내 원래 구현은 배열과 빈 문자열에서도 true를 반환합니다. 이 구현에는 그러한 결함이 없습니다. 또한 val이 문자열이나 숫자가 아니거나 빈 문자열이면 일찍 반환하는 이점이 있습니다.이 경우 더 빠릅니다. 처음 두 절을 다음과 같이 바꿔서 더 수정할 수 있습니다.

typeof(val) != "number"

문자열이 아닌 리터럴 숫자 만 일치시키려는 경우

편집하다:

댓글을 아직 게시 할 수 없으므로 내 답변에 추가하고 있습니다. @Asok이 게시 한 벤치 마크는 매우 유익합니다. 그러나 가장 빠른 함수는 부동 소수점, 배열, 부울 및 빈 문자열에 대한 TRUE도 반환하므로 요구 사항에 맞지 않습니다.

다음 테스트 스위트를 만들어 각 함수를 테스트하고 목록에 답변을 추가했습니다 (문자열을 구문 분석하는 함수 8, 그렇지 않은 함수 9).

funcs = [
    function(n) {
        return n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && n % 1 == 0;
    },
    function(n) {
        return typeof n === 'number' && parseFloat(n) == parseInt(n, 10) && !isNaN(n);
    },
    function(n) {
        return n.toString().indexOf('.') === -1;
    },
    function(n) {
        return n === +n && n === (n|0);
    },
    function(n) {
        return parseInt(n) === n;
    },
    function(n) {
        return /^-?[0-9]+$/.test(n.toString());
    },
    function(n) {
        if ((undefined === n) || (null === n)) {
            return false;
        }
        if (typeof n == 'number') {
            return true;
        }
        return !isNaN(n - 0);
    },
    function(n) {
        return ["string","number"].indexOf(typeof(n)) > -1 && n !== '' && !isNaN(n+".0");
    }
];
vals = [
    [1,true],
    [-1,true],
    [1.1,false],
    [-1.1,false],
    [[],false],
    [{},false],
    [true,false],
    [false,false],
    [null,false],
    ["",false],
    ["a",false],
    ["1",null],
    ["-1",null],
    ["1.1",null],
    ["-1.1",null]
];

for (var i in funcs) {
    var pass = true;
    console.log("Testing function "+i);
    for (var ii in vals) {
        var n = vals[ii][0];
        var ns;
        if (n === null) {
            ns = n+"";
        } else {
            switch (typeof(n)) {
                case "string":
                    ns = "'" + n + "'";
                    break;
                case "object":
                    ns = Object.prototype.toString.call(n);
                    break;
                default:
                    ns = n;
            }
            ns = "("+typeof(n)+") "+ns;
        }

        var x = vals[ii][1];
        var xs;
        if (x === null) {
            xs = "(ANY)";
        } else {
            switch (typeof(x)) {
                case "string":
                    xs = "'" + n + "'";
                    break;
                case "object":
                    xs = Object.prototype.toString.call(x);
                    break;
                default:
                    xs = x;
            }
            xs = "("+typeof(x)+") "+xs;
        }

        var rms;
        try {
            var r = funcs[i](n);
            var rs;
            if (r === null) {
                rs = r+"";
            } else {
                switch (typeof(r)) {
                    case "string":
                        rs = "'" + r + "'";
                        break;
                    case "object":
                        rs = Object.prototype.toString.call(r);
                        break;
                    default:
                        rs = r;
                }
                rs = "("+typeof(r)+") "+rs;
            }

            var m;
            var ms;
            if (x === null) {
                m = true;
                ms = "N/A";
            } else if (typeof(x) == 'object') {
                m = (xs === rs);
                ms = m;
            } else {
                m = (x === r);
                ms = m;
            }
            if (!m) {
                pass = false;
            }
            rms = "Result: "+rs+", Match: "+ms;
        } catch (e) {
            rms = "Test skipped; function threw exception!"
        }

        console.log("    Value: "+ns+", Expect: "+xs+", "+rms);
    }
    console.log(pass ? "PASS!" : "FAIL!");
}

또한 기능 # 8이 목록에 추가 된 벤치 마크를 다시 실행했습니다. 나는 약간 당혹 스럽기 때문에 결과를 게시하지 않을 것입니다 (예 : 그 기능이 빠르지 않습니다) ...

결과는 상당히 길기 때문에 요약 된 테스트를 성공적으로 제거했습니다.

Testing function 0
Value: (object) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 1
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 2
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 3
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) false, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) 'a', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
FAIL!

Testing function 4
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 5
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 6
Value: null, Expect: (boolean) false, Test skipped; function threw exception!
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 7
Value: (number) 1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (number) -1.1, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (object) true, Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Array], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (boolean) [object Object], Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '', Expect: (boolean) false, Result: (boolean) true, Match: false
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) true, Match: N/A
FAIL!

Testing function 8
Value: (string) '1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) true, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

Testing function 9
Value: (string) '1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
Value: (string) '-1.1', Expect: (ANY), Result: (boolean) false, Match: N/A
PASS!

나는 실패에 빠졌으므로 각 함수가 실패하는 곳과 (문자열) '#'테스트를 통해 각 함수가 문자열의 정수 및 부동 소수점 값을 처리하는 방법을 볼 수 있습니다. 아닐 수도 있습니다.

테스트 된 10 가지 기능 중 실제로 OP의 요구 사항에 맞는 기능은 [1,3,5,6,8,9]입니다.

플로팅 유효성 검사 조건 :

if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

정수 유효성 검사 조건 :

if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0)) 

이것이 도움이 되길 바랍니다.

function int(a) {
  return a - a === 0 && a.toString(32).indexOf('.') === -1
}

function float(a) {
  return a - a === 0 && a.toString(32).indexOf('.') !== -1
}

typeof a === 'number'문자열을 제외하려는 경우 추가 할 수 있습니다 .