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

Szukam łatwego sposobu w JavaScript, aby sprawdzić, czy liczba ma miejsce dziesiętne (w celu ustalenia, czy jest liczbą całkowitą). Na przykład,

23 -> OK
5 -> OK
3.5 -> not OK
34.345 -> not OK

if(number is integer) {...}

Korzystanie z modułu będzie działać:

num % 1 != 0
// 23 % 1 = 0
// 23.5 % 1 = 0.5

Pamiętaj, że jest to oparte na wartości liczbowej liczby, niezależnie od formatu. Traktuje ciągi liczbowe zawierające liczby całkowite ze stałym punktem dziesiętnym takim samym jak liczby całkowite:

'10.0' % 1; // returns 0
10 % 1; // returns 0
'10.5' % 1; // returns 0.5
10.5 % 1; // returns 0.5

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

Number.isInteger () jest częścią standardu ES6 i nie jest obsługiwany w IE11.

Zwraca false NaN, Infinitya non-numeryczne argumenty natomiast x % 1 != 0zwraca true.

Możesz też użyć tego, aby dowiedzieć się, czy NIE jest to ułamek dziesiętny:

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

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

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

Proste ale efektywne!

Math.floor(number) === number;

// Co powiesz na bajtowanie?

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

Zawsze źle się czuję dla operatorów bitów w javascript-

prawie nie ćwiczą.

number = 20.5

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

alert("Integer")

} else {

alert("Decimal")

}

Całkiem fajne i działa również na takie rzeczy jak XX.0! Działa, ponieważ Math.floor () odcina każdy ułamek dziesiętny, jeśli go ma, więc jeśli podłoga różni się od pierwotnej liczby, wiemy, że jest to ułamek dziesiętny! I brak konwersji ciągów :)

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

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

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

parseInt(num) === num

gdy przekazany numer, parseInt()po prostu zwraca liczbę jako int:

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

konwertuj ciąg liczbowy na tablicę, dzielony przez przecinek dziesiętny. Następnie, jeśli tablica ma tylko jedną wartość, oznacza to brak dziesiętnego ciągu.

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

W ten sposób możesz także wiedzieć, jaka jest liczba całkowita i dziesiętna. bardziej zaawansowanym przykładem byłby.

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

if(!dece){
    //do stuff
}

Oto fragment mojej biblioteki strażników (zainspirowanej przez Effective JavaScript 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ę / podział „ modulo ” z 10 i sprawdzić, czy wynik tych dwóch operacji wynosi zero. Wynik tych dwóch operacji da ci pierwszą cyfrę po przecinku. Jeśli wynik jest równy zero, to liczba jest liczbą całkowitą.

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

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

Możesz użyć operacji bitowych, które nie zmieniają wartości ( ^ 0lub ~~), aby odrzucić część dziesiętną, której można użyć do zaokrąglenia. Po zaokrągleniu liczba jest porównywana z pierwotną 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

function isWholeNumber(num) {
  return num === Math.round(num);
}

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

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

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

Najwyraźniej niektórzy użytkownicy chcą wyjaśnień. Rozbiorę to na kawałki: (num% 1)

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

Podsumowując to, co do tej pory mamy., (Num% 1) zwróci:

0 równomiernie podzielone LUB #. ##### jeśli nie

0 == fałsz.

[ANY_NUMBER_NOT_ZERO] == prawda.

Przykłady: nowy Boolean (0) jest fałszem nowy Boolean (12312.1231) jest prawdziwy

Inne alternatywy: użytkownik mógł spróbować zwrócić wartość (num% 1)., Co w zasadzie pozwoliłoby osiągnąć 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 do wymuszenia wartości logicznej dodałem! symbol przed nim.

Tyle, ile może wiedzieć.,! oznacza NIE. Ale wymusza także wartość logiczną.

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

Funkcja numeru kontrolnego to liczba dziesiętna lub całkowita

function IsDecimalExist(p_decimalNumber) {
    var l_boolIsExist = true;

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

    return l_boolIsExist;
}

Może to ci odpowiada?

Używa wyrażenia regularnego, aby sprawdzić, czy w numerze jest przecinek, a jeśli go nie ma, doda przecinek i pasek.

var myNumber = '50';
function addCommaStripe(text){
    if(/,/.test(text) == false){
        return text += ',-';
    } else {
        return text;
    }
}
myNumber = addCommaStripe(myNumber);

Użyj następującego, jeśli wartość jest łańcuchem (np. Z <input):

Math.floor(value).toString() !== value

Dodam .toString()do podłogi, aby działała również w przypadkach, gdy value == "1."(kończy się separatorem dziesiętnym lub innym ciągiem). Również Math.floorzawsze zwraca pewną wartość, więc .toString()nigdy nie zawodzi.