Pregunta ¿Cómo puedo verificar que un número sea flotante o entero?


Cómo encontrar que un número es float o integer?

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

609
2017-10-07 20:55


origen


Respuestas:


verifique el resto al dividir por 1:

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

Si no sabe que el argumento es un número, necesita dos pruebas:

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

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

1068
2017-10-07 21:43



Pruebe estas funciones para probar si un valor es un valor primitivo numérico que no tiene una parte fraccionaria y está dentro de los límites de tamaño de lo que se puede representar como un número entero exacto.

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

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

142
2017-10-07 20:59



¿Por qué no algo como esto?

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

81
2017-11-28 18:48



Hay un método llamado Number.isInteger() que actualmente se implementa solo en la última versión de Firefox y aún forma parte de la propuesta de EcmaScript 6. sin embargo MDN proporciona un polyfill para los otros navegadores, que coincide con el especificado en la armonía ECMA:

if (!Number.isInteger) {
  Number.isInteger = function isInteger (nVal) {
    return typeof nVal === "number" && isFinite(nVal) && nVal > -9007199254740992 && nVal < 9007199254740992 && Math.floor(nVal) === nVal;
  };
}

49
2017-12-26 04:57



Puedes usar una expresión regular simple:

function isInt(value) {

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

    return er.test(value);
}

O puede usar las funciones a continuación también, según sus necesidades. Ellos son desarrollados por el Proyecto PHPJS.

is_int() => Compruebe si el tipo de variable es entero y si su contenido es entero

is_float() => Compruebe si el tipo de variable es flotante y si su contenido es flotante

ctype_digit() => Compruebe si el tipo de variable es una cadena y si su contenido tiene solo dígitos decimales

Actualización 1

Ahora también verifica los números negativos, gracias por @ChrisBartley comentario!


33
2018-04-24 18:36



Aquí hay funciones eficientes que verifican si el valor es un número o puede ser convertido de forma segura a un número:

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

Y para enteros (devolvería falso si el valor es un flotante):

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

La eficiencia aquí es que se evitan parseInt (o parseNumber) cuando el valor ya es un número. Ambas funciones de análisis siempre conviértase en cadena primero y luego intente analizar esa cadena, lo que sería un desperdicio si el valor ya es un número.

¡Gracias a las otras publicaciones aquí por proporcionar más ideas para la optimización!


17
2017-07-17 20:25



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

11
2018-05-07 22:05



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

funciona para todos los casos.


9
2018-02-12 13:03



Como otros mencionaron, solo tienes dobles en JS. ¿Cómo se define un número como un número entero? Simplemente verifique si el número redondeado es igual a sí mismo:

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

6
2017-10-07 21:08