Sprawdź, czy liczba ma miejsce dziesiętne/jest liczbą całkowitą

Lub możesz po prostu użyć, aby dowiedzieć się, czy nie jest to dziesiętne:

string.indexOf(".")==-1;

Najczęstszym rozwiązaniem jest usunięcie części całkowitej liczby i porównanie jej do zera w ten sposób:

function Test()
{
     var startVal = 123.456
     alert( (startVal - Math.floor(startVal)) != 0 )
}

Number.isInteger(23);  // true
Number.isInteger(1.5); // false
Number.isInteger("x"); // false: 

Numer.isInteger () {[6] } jest częścią standardu ES6 i nie jest obsługiwany w IE11.

Zwraca false dla NaN, Infinity i nie-numerycznych argumentów, podczas gdy x % 1 != 0 zwraca true.

/ / A może byte-ing?

Number.prototype.isInt= function(){
 return this== this>> 0;
}

Zawsze czuję się źle z operatorami bitowymi w javascript -

Proste, ale skuteczne!

Math.floor(number) == number;

var re=/^-?[0-9]+$/;
var num=10;
re.test(num);

function isDecimal(n){
    if(n == "")
        return false;

    var strCheck = "0123456789";
    var i;

    for(i in n){
        if(strCheck.indexOf(n[i]) == -1)
            return false;
    }
    return true;
}

number = 20.5

if (number == Math.floor(number)) {

alert("Integer")

} else {

alert("Decimal")

}

Całkiem fajne i działa na rzeczy jak XX. 0 też! To działa, ponieważ matematyka.floor() odcina dowolną liczbę dziesiętną, jeśli ma taką, więc jeśli podłoga różni się od pierwotnej liczby, wiemy, że jest dziesiętna! I bez konwersji ciągów:)

parseInt(num) === num

Po przekazaniu liczby, parseInt() po prostu zwraca liczbę jako int:

parseInt(3.3) === 3.3 // false because 3 !== 3.3
parseInt(3) === 3     // true

Oto fragment mojej biblioteki guard (zainspirowany efektywnym JavaScript autorstwa Davida Hermana):

var guard = {

    guard: function(x) {
        if (!this.test(x)) {
            throw new TypeError("expected " + this);
        }
    }

    // ...
};

// ...

var number = Object.create(guard);
number.test = function(x) {
    return typeof x === "number" || x instanceof Number;
};
number.toString = function() {
    return "number";
};


var uint32 = Object.create(guard);
uint32.test = function(x) {
    return typeof x === "number" && x === (x >>> 0);
};
uint32.toString = function() {
    return "uint32";
};


var decimal = Object.create(guard);
decimal.test = function(x) {
    return number.test(x) && !uint32.test(x);
};
decimal.toString = function() {
    return "decimal";
};


uint32.guard(1234);     // fine
uint32.guard(123.4);    // TypeError: expected uint32

decimal.guard(1234);    // TypeError: expected decimal
decimal.guard(123.4);   // fine

Możesz pomnożyć go przez 10 , a następnie wykonać operację" modulo " z 10 i sprawdzić, czy wynik tych dwóch operacji jest zerowy. Wynik tych dwóch operacji daje pierwszą cyfrę po przecinku. Jeżeli wynik jest równy zeru, to liczba jest liczbą całkowitą.

if ( (int)(number * 10.0) % 10 == 0 ){
// your code
}

Number.isInteger() jest chyba najbardziej zwięzły. Zwraca true, jeśli jest liczbą całkowitą, i false, jeśli nie jest.

Funkcja dla liczby kontrolnej jest liczbą dziesiętną lub całkowitą

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

    if (p_decimalNumber % 1 == 0)
        l_boolIsExist = false;

    return l_boolIsExist;
}

Konwertuj łańcuch liczb na tablicę, podzieloną przez punkt dziesiętny. Wtedy, jeżeli tablica ma tylko jedną wartość, to znaczy, że w łańcuchu nie ma miejsca dziesiętnego.

if(!number.split(".")[1]){
    //do stuff
}

W ten sposób możesz również wiedzieć, czym są liczby całkowite i dziesiętne. bardziej zaawansowanym przykładem może być.

number_to_array = string.split(".");
inte = number_to_array[0];
dece = number_to_array[1]; 

if(!dece){
    //do stuff
}

function isDecimal(num) {
  return (num !== parseInt(num, 10));
}

Możesz użyć operacji bitowych, które nie zmieniają wartości (^ 0 lub ~~), aby odrzucić część dziesiętną, która może być używana do zaokrąglania. Po zaokrągleniu liczby jest ona porównywana z oryginalną wartością:

function isDecimal(num) {
  return (num ^ 0) !== num;
}

console.log( isDecimal(1) ); // false
console.log( isDecimal(1.5) ); // true
console.log( isDecimal(-0.5) ); // true

Możesz użyć następującej funkcji, aby sprawdzić, czy liczba ma miejsca po przecinku:

function hasDecimal(num){
    return !!(num % 1);
}

console.log(hasDecimal(2)); //true
console.log(hasDecimal(2.32423)); //false

Więc najwyraźniej niektórzy użytkownicy chcą wyjaśnień. Rozbiję go na kawałki: (num % 1)

Nawias oznacza, że najpierw wykonaj te operacje. num-zmienna przekazywana przez funkcję. % - symbol modułu, który próbuje podzielić lewą liczbę przez prawą. Jeśli jest reszta, zwraca ją jako wartość dziesiętną. Jeśli dzieli się równomiernie, zwraca 0.

0 po równomiernym podzieleniu lub #.##### if not

0 = = false.

[ANY_NUMBER_NOT_ZERO] = = true

Inne alternatywy: użytkownik mógł spróbować zwrócić wartość (num % 1)., co w zasadzie osiągnęłoby to samo. Ponieważ return (0) jest false, a return (1.213113) jest true.

Ale chciałem zwrócić wartość logiczną. Więc jako skrót wymusić wartość do boolean dodałem a ! symbol przed nim.

Od symobol wymusza wartość do wartości logicznej i odwraca jej wartość. Używam !! aby wymusić wartość do wartości logicznej i odwrócić jej wartość z powrotem do pierwotnej wartości logicznej.

$('.rsval').bind('keypress', function(e){  
        var asciiCodeOfNumbers = [48,46, 49, 50, 51, 52, 53, 54, 54, 55, 56, 57];
        var keynum = (!window.event) ? e.which : e.keyCode; 
        var val = this.value;
        var numlenght = val.length;
        var splitn = val.split("."); 
        var decimal = splitn.length;
        var precision = splitn[1];
        var startPos = this.selectionStart;
        var decimalIndex = val.indexOf('.'); 
        if(decimal == 2) {  
            if(decimalIndex < startPos){
                if(precision.length >= 2){
                  e.preventDefault();  
                }
            } 
        } 
        if( keynum == 46 ){  
            if(startPos < (numlenght-2)){
                e.preventDefault(); 
            }
            if(decimal >= 2) { e.preventDefault(); }  
        } 
        if ($.inArray(keynum, asciiCodeOfNumbers) == -1)
            e.preventDefault();    
  });