programing

숫자가 실수인지 정수인지 어떻게 확인합니까?

nasanasas 2020. 9. 30. 10:56
반응형

숫자가 실수인지 정수인지 어떻게 확인합니까?

숫자가 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 은 다른 브라우저를위한 polyfill도 제공합니다.

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 프로젝트에 의해 개발되었습니다 .

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

is_float() => 변수 유형이 float인지, 내용이 float인지 확인

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

업데이트 1

이제 음수도 확인합니다. @ChrisBartley 의견에 감사드립니다 !

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

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

정수의 경우 (값이 부동 소수점이면 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); }

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

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

짧고 멋지다 :) 항상 작동합니다. 이것이 내가 착각하지 않았다면 David Flanagan이 제안하는 것입니다.

소수 부분이 0 인 Float 숫자 (예 : 1.0, 12.00, 0.0)는 암시 적으로 Integer로 캐스트되므로 Float인지 아닌지 확인할 수 없습니다.

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

Claudiu 와 같은 것을 사용하면 다음이 제공됩니다.

isInteger( 1.0 ) -> 참

상식으로는 괜찮아 보이지만 C와 같은 경우에는 false

정말 그렇게 복잡 할 필요는 없습니다. 정수의 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) }

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

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

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

이건 어때?

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

이것은 INT와 FLOAT를 모두 확인하기위한 최종 코드입니다.

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이면 더 이상 float가 아닙니다. 정수입니다. 또는 C에서와 같이 엄격한 구분이 없기 때문에 "숫자적인 것"이라고 부를 수 있습니다. 좋은 옛날.

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

흥미로운 사이드 노트

엄청난 수에 대한 의견이있었습니다. 엄청난 숫자는이 접근 방식에 문제가 없음을 의미합니다. parseInt가 숫자를 처리 할 수 ​​없을 때마다 (너무 커서) 실제 값이 아닌 다른 값을 반환하므로 테스트에서 FALSE를 반환합니다. 어떤 것을 "숫자"라고 생각하면 일반적으로 JS가 계산할 수있을 것으로 기대하기 때문에 이것은 좋은 것입니다. 그래서 예, 숫자는 제한되어 있고 parseInt는 이것을 고려 하여 이런 식으로 표현합니다.

이 시도:

<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 fails"를 반환하는데, 이는 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수표를 만들 수 없습니다 . 그러나 u는 주어진 위의 솔루션을 사용하여 분수인지 확인할 수 있습니다. 자바 스크립트의 디자이너는 단일 유형으로 여러 유형 캐스트 ​​오류를 ​​피할 수 있다고 느꼈습니다.

여기에 몇 가지 답변을 시도하여 결국이 솔루션을 작성했습니다. 이것은 문자열 안의 숫자에서도 작동합니다.

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)는 isNaN ()이 "01"을 평가하여 false로 평가합니다. 한편, isPositiveInt (-1)는 "0-1"을 평가하는 isNaN ()이 true로 평가되도록합니다. 우리는 반환 값을 부정하고 우리가 원하는 것을 제공합니다. 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'문자열을 제외하려면 추가 할 수 있습니다 .

YourJS 는 및에 false대한 반환 을 포함하여 모든 숫자에 대해 작동하는 다음 두 가지 기능을 제공합니다 .-InfinityInfinity

function isFloat(x) {
  return typeOf(x, 'Number') && !!(x % 1);
}

function isInt(x) {
  return typeOf(x, 'Number') && x % 1 == 0;
}

typeOf()YourJS 내부 함수 라는 사실로 인해 이러한 정의를 사용하려면 여기에서 이러한 함수에 대한 버전을 다운로드 할 수 있습니다. http://yourjs.com/snippets/build/34

참고 URL : https://stackoverflow.com/questions/3885817/how-do-i-check-that-a-number-is-float-or-integer

반응형

'programing' 카테고리의 다른 글

임의의 범위를 1–5에서 1–7로 확장  (0) 2020.09.30
동적으로 명명 된 속성을 JavaScript 개체에 추가 할 수 있습니까?  (0) 2020.09.30
Mac OS X에서 Java는 어디에 설치됩니까?  (0) 2020.09.30
변수에 값을 할당하여 한 줄씩 파일 읽기  (0) 2020.09.30
마스터와 개발 분기 병합  (0) 2020.09.30

'programing'의 다른글

  • 현재글숫자가 실수인지 정수인지 어떻게 확인합니까?

관련글

댓글

티스토리툴바