Cum pot verifica dacă un număr este float sau întreg?

verificați pentru un rest la împărțirea cu 1:

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

Dacă tu nu't știu că argumentul este un număr aveți nevoie de două teste:

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

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

Actualizare 2019 5 ani după acest răspuns a fost scris, o soluție a fost standardizat în ECMA Script 2015. Această soluție este acoperit în acest răspuns.

Încercați aceste funcții pentru a testa dacă o valoare este un număr primitive valoare care nu are nici o parte fracționată și este în mărime limitele a ceea ce poate fi reprezentat exact ca un întreg.

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

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

De ce nu ceva de genul asta:

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

Există o metodă numită Numărul lui.isInteger()` care este în prezent pusă în aplicare în totul, dar IE. [MDN][1] oferă, de asemenea, un polyfill pentru alte browsere:

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

Cu toate acestea, pentru cele mai multe utilizări cazuri, sunt mai bine folosind Numărul.isSafeIntegercare verifică, de asemenea, în cazul în care valoarea este atât de mare/mic că orice zecimale s-ar fi pierdut oricum. [MDN][2] are o polyfil pentru asta la fel de bine. (Aveți nevoie, de asemenea,isInteger` pollyfill de mai sus.)

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) 

Puteți folosi o simplă expresie regulată:

function isInt(value) {

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

    return er.test(value);
}

Sau puteți folosi funcțiile de mai jos de asemenea, în funcție de nevoile dumneavoastră. Acestea sunt dezvoltate de către PHPJS Proiect.

is_int() => Verificați dacă variabila este de tip întreg și dacă conținutul acestuia este număr întreg

is_float() => Verificați dacă variabila este de tip float și dacă conținutul acestuia este float

ctype_digit() => Verificați dacă variabila este de tip string și dacă conținutul acestuia are numai cifre zecimale

Update 1

Acum se verifică numerele negative prea, multumesc pentru @ChrisBartley comentariu!

Aici sunt eficiente funcții care verifică dacă valoarea este un număr sau pot fi în condiții de siguranță a convertit la un număr de:

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

Și pentru numere întregi (ar întoarce false dacă valoarea este un float):

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

Eficiența aici este că parseInt (sau parseNumber) sunt evitate atunci când valoarea este deja un număr. Ambele parsarea funcții întotdeauna conversia la string mai întâi și apoi încearcă pentru a analiza acel șir, ceea ce ar fi o pierdere dacă valoarea deja este un număr.

Vă mulțumesc pentru alte posturi aici pentru furnizarea de idei noi pentru optimizare!

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

funcționează pentru toate cazurile.

Ca și ceilalți menționat, trebuie doar dublează în JS. Deci, cum a face tu a defini un număr fiind un număr întreg? Doar verifica dacă rotunjite număr este egal cu sine:

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

Aici's ceea ce am folosi pentru numere întregi:

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

Scurt, frumos :) Funcționează tot timpul. Aceasta este ceea ce David Flanagan sugerează dacă am'm înșel.

Orice Float număr cu un zero zecimale (de exemplu, 1.0, ora 12.00, 0.0) sunt implicit aruncat la Întreg, astfel încât nu este posibil pentru a verifica dacă acestea sunt Plutesc sau nu.

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

Am't avut un caz în care acest lucru nu't face treaba.

Este într-adevăr nu't trebuie să fie atât de complicat. Valoarea numerică a unui număr întreg's parseFloat() și parseInt() echivalent va fi la fel. Astfel, poti face astfel:

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

Apoi

if (isInt(x)) // do work

Acest lucru va permite, de asemenea, pentru șir de verificări și, astfel, nu este strictă. Dacă vrei un puternic soluție de tip (aka, obiceiul de lucru cu siruri de caractere):

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

Ce zici de asta?

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

Este într-adevăr depinde de ceea ce vrei pentru a atinge. Dacă doriți pentru a "emula" puternic tastat limbi atunci îți sugerez să nu încerc. Cum alții au menționat că toate numerele au aceeași reprezentare (de același tip).

Folosind ceva de genul Claudiu condiția:

isInteger( 1.0 ) -> adevărat

care arata bine pentru bunul simț, dar în ceva de genul C v-ar lua "false"

L's de simplu ca:

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

Incearca asta in consola:

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!

Acest confundă o mulțime de oameni. Ori de câte ori ceva este .0, - l's nu o plutesc mai. L's un număr întreg. Sau poți doar să-l numesc "un numerice lucru" pentru că nu există nici o distincție strictă ca în C. vremurile Bune.

Deci, practic, tot ce poți face este să verificați pentru întreg acceptarea faptului că 1.000 este un număr întreg.

Interesant notă

Nu a fost un comentariu despre un număr foarte mare. Un număr imens înseamnă NICI o problemă pentru această abordare; ori de câte ori parseInt nu este în măsură să se ocupe de numărul (de l's prea mari) se va reveni altceva decât valoarea reală asa ca testul va returna FALSE. Acesta este un lucru bun pentru că dacă te gândești la ceva mai "număr" - ai aștepta în mod normal JS pentru a fi capabil de a a calcula cu ea - deci da, numerele sunt limitate și parseInt va ia în considerare acest lucru, să-l pună în acest fel.

Încercați acest lucru:

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

În browser-ul meu (IE8) aceasta revine "o este ok; b nu" care este exact din cauza numărului foarte mare în b. Limita poate varia, dar cred că 20 de cifre "ar trebui să fie suficient pentru oricine", ca sa citez un clasic :)

ACESTA ESTE CODUL FINAL PENTRU A VERIFICA AMBELE INT ȘI FLOAT

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

SAU

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

Această soluție a funcționat pentru mine.

    <input type="text" id="number_id"/>
    <input type="submit" value="send"/>

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