wake-up-neo.com

Wie überprüfe ich, ob eine Zahl float oder integer ist?

Wie finde ich heraus, dass eine Zahl float oder integer ist?

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

überprüfe den Rest, wenn du durch 1 teilst:

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

Wenn Sie nicht wissen, dass das Argument eine Zahl ist, benötigen Sie zwei Tests:

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

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

Update 2019 5 Jahre nachdem diese Antwort geschrieben wurde, wurde eine Lösung in ECMA Script 2015 standardisiert. Diese Lösung wird behandelt in dieser Antwort =.

1183
kennebec

Mit diesen Funktionen können Sie testen, ob ein Wert ein Zahlenprimitivwert ist, der keinen Bruchteil enthält und innerhalb der Größenbeschränkungen dessen liegt, was als exakte Ganzzahl dargestellt werden kann.

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

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

Warum nicht so etwas:

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

Es gibt eine Methode mit dem Namen Number.isInteger(), die derzeit in allen außer IE implementiert ist. MDN bietet auch eine Polyfüllung für andere Browser:

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

In den meisten Anwendungsfällen ist es jedoch besser, Number.isSafeInteger zu verwenden, mit dem auch geprüft wird, ob der Wert so hoch/niedrig ist, dass Dezimalstellen ohnehin verloren gegangen wären. MDN hat auch dafür eine Polydatei. (Du brauchst auch die isInteger Pollyfill oben.)

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

Sie können einen einfachen regulären Ausdruck verwenden:

function isInt(value) {

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

    return er.test(value);
}

Oder Sie können auch die folgenden Funktionen verwenden, je nach Ihren Bedürfnissen. Sie werden vom PHPJS Project entwickelt.

is_int() => Überprüfen Sie, ob der Variablentyp eine Ganzzahl ist und ob der Inhalt eine Ganzzahl ist

is_float() => Überprüfen Sie, ob der Variablentyp float ist und ob sein Inhalt float ist

ctype_digit() => Überprüfen Sie, ob der Variablentyp ein String ist und ob der Inhalt nur Dezimalstellen enthält

Update 1

Jetzt prüft es auch negative Zahlen, danke für @ ChrisBartley Kommentar !

32

Hier sind effiziente Funktionen, die prüfen, ob der Wert eine Zahl ist oder sicher konvertiert eine Zahl sein kann:

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

Und für ganze Zahlen (würde false zurückgeben, wenn der Wert ein Float ist):

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

Die Effizienz hier ist, dass parseInt (oder parseNumber) vermieden werden, wenn der Wert bereits eine Zahl ist. Beide Parsing-Funktionen immer konvertieren zuerst in einen String und versuchen dann, diesen String zu analysieren. Dies wäre eine Verschwendung, wenn der Wert bereits eine Zahl ist.

Vielen Dank an die anderen Beiträge hier für weitere Optimierungsideen!

18
Tal Liron
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
shime
function isInt(n) 
{
    return n != "" && !isNaN(n) && Math.round(n) == n;
}
function isFloat(n){
    return n != "" && !isNaN(n) && Math.round(n) != n;
}

funktioniert für alle Fälle.

9
Deepak Yadav

Wie bereits erwähnt, gibt es in JS nur Doppelsitzer. Wie definieren Sie eine Zahl als Ganzzahl? Prüfen Sie einfach, ob die gerundete Zahl mit sich selbst übereinstimmt:

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

Folgendes verwende ich für ganze Zahlen:

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

Kurz, schön :) Funktioniert die ganze Zeit. Dies ist, was David Flanagan vorschlägt, wenn ich mich nicht irre.

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

Hatte noch keinen Fall, in dem dies nicht funktioniert hätte.

3
ankr

Es muss wirklich nicht so kompliziert sein. Der numerische Wert der parseFloat () - und parseInt () -Äquivalente einer Ganzzahl ist derselbe. So kann man das machen:

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

Dann

if (isInt(x)) // do work

Dies ermöglicht auch Stringprüfungen und ist daher nicht streng. Wenn Sie eine starke Lösung suchen (auch bekannt als "Strings"):

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

Alle Gleitkommazahlen mit einem Dezimalteil von Null (z. B. 1,0, 12,00, 0,0) werden implizit in Ganzzahlen umgewandelt, sodass nicht überprüft werden kann, ob es sich um Gleitkommazahlen handelt oder nicht.

3
Mike Mancini
!!(24%1) // false
!!(24.2%1) // true

Wie wäre es mit diesem?

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

Es kommt wirklich darauf an, was Sie erreichen wollen. Wenn Sie stark typisierte Sprachen "emulieren" möchten, empfehle ich Ihnen, es nicht zu versuchen. Wie bereits erwähnt, haben alle Nummern die gleiche Darstellung (den gleichen Typ).

Mit etwas wie Claudi vorausgesetzt:

isInteger( 1.0 ) -> true

das sieht gut aus für den gesunden Menschenverstand, aber in etwas wie C würden Sie false

3
gblazex

Diese Lösung hat bei mir funktioniert.

<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>
2
Abdelraouf GR
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');
}
2
Vitim.us

DIESES IS ENDGÜLTIGER CODE FÜR DIE ÜBERPRÜFUNG VON INT UND FLOAT

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

OR

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

Ich habe eine Funktion geschrieben, die Strings akzeptiert (falls jemand sie benötigt)

function isInt(x) {
    return !isNaN(x) && eval(x).toString().length == parseInt(eval(x)).toString().length
}

function isFloat(x) {
    return !isNaN(x) && !isInt(eval(x)) && x.toString().length > 0
}

beispiel-Ausgänge:

console.log(isFloat('0.2'))  // true
console.log(isFloat(0.2))    // true
console.log(isFloat('.2'))   // true
console.log(isFloat('-.2'))  // true
console.log(isFloat(-'.2'))  // true
console.log(isFloat(-.2))    // true
console.log(isFloat('u.2'))  // false
console.log(isFloat('2'))    // false
console.log(isFloat('0.2u')) // false

console.log(isInt('187'))  // true
console.log(isInt(187))    // true
console.log(isInt('1.2'))  // false
console.log(isInt('-2'))   // true
console.log(isInt(-'1'))   // true
console.log(isInt('10e1')) // true
console.log(isInt(10e1))   // true
2

Es ist ganz einfach:

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

Versuchen Sie dies in der Konsole:

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!

Das verwirrt viele Menschen. Immer wenn etwas .0 ist, ist es kein Schwimmer mehr. Es ist eine ganze Zahl. Oder man kann es einfach "eine numerische Sache" nennen, denn es gibt keine strenge Unterscheidung wie damals in C. Gute alte Zeiten.

Alles, was Sie tun können, ist, auf Ganzzahlen zu prüfen, wobei Sie die Tatsache akzeptieren, dass 1.000 eine Ganzzahl ist.

Interessante Randnotiz

Es gab einen Kommentar zu riesigen Zahlen. Riesige Zahlen bedeuten für diesen Ansatz KEIN Problem. Wenn parseInt die Zahl nicht verarbeiten kann (weil sie zu groß ist), gibt es etwas anderes als den tatsächlichen Wert zurück, sodass der Test FALSE zurückgibt. Das ist eine gute Sache, denn wenn Sie etwas als "Zahl" betrachten, erwarten Sie normalerweise, dass JS damit rechnen kann - also sind die Zahlen begrenzt und parseInt wird dies berücksichtigen , um es so auszudrücken.

Versuche dies:

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

In meinem Browser (IE8) gibt dies "a ist in Ordnung; b schlägt fehl" zurück, was genau an der großen Zahl in b liegt. Das Limit kann variieren, aber ich denke, 20 Stellen "sollten für jeden reichen", um einen Klassiker zu zitieren :)

2
dkellner

Als ich hier einige der Antworten ausprobierte, schrieb ich diese Lösung. Dies funktioniert auch mit Zahlen innerhalb eines Strings.

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);
1

Für ganze Zahlen verwende ich dies

function integer_or_null(value) {
    if ((undefined === value) || (null === value)) {
        return null;
    }
    if(value % 1 != 0) {
        return null;
    }
    return value;
}
1
neoneye

In Java Skripten sind alle Zahlen internally 64 bit floating point, genauso wie double in Java. Es gibt keine unterschiedlichen Typen in Javascript, alle werden durch den Typ number dargestellt. Sie können also keine instanceof Prüfung durchführen. Sie können jedoch die oben angegebenen Lösungen verwenden, um herauszufinden, ob es sich um eine gebrochene Zahl handelt. Designer von Java -Skripten haben das Gefühl, mit einem einzigen Typ zahlreiche Typumwandlungsfehler zu vermeiden.

1
Punith Raj

Das ist meins:

function isInt(quale) {
    var valore = $('#'+quale).val().toLowerCase();
    if (isNaN(Number(String(valore))) || (valore.indexOf("e") > 0)) {
        // Not int
    } else {
        // Is Int!
    }
}

Und das:

function isFloat(quale) {
   var valore = $('#'+quale).val();
   valore = valore.replace(",", "");
   if (isNaN(String(valore)) || (valore.indexOf("e") > 0)) {
    // Not Float
   } else {
    // Float
   }
}

Ad majora!

0
Damy Z

Dies ist möglicherweise nicht so performant wie die% -Antwort, sodass Sie nicht zuerst in einen String konvertieren müssen, aber ich habe noch niemanden gesehen, der es veröffentlicht hat. Hier ist eine weitere Option, die gut funktionieren sollte:

function isInteger(num) {
    return num.toString().indexOf('.') === -1;
}
0
Axle

Das finde ich am elegantesten:

function isInteger(n) {
    return n === (n^0);
}

Es ist auch wichtig, im Falle eines nicht numerischen Wertes false zurückzugeben.

0
bugovicsb

Die folgenden Funktionen schützen vor leeren Zeichenfolgen, undefinierten Werten, Nullen und Maximal-/Minimalwerten. Die Javascript-Engine sollte diese Funktionen vom ersten Tag an eingebaut haben. :)

Genießen!

function IsInteger(iVal) {
    var iParsedVal; //our internal converted int value


    iParsedVal = parseInt(iVal,10);

    if (isNaN(iParsedVal) || Infinity == iParsedVal || -Infinity == iParsedVal) //sanity check - guard against empty strings and max/min values
        return false;
    else
        return Number(iVal) === (iParsedVal | 0); //the 2nd operand group (intValue | 0), evaluates to true only if the intValue is an integer; so an int type will only return true
}

function IsFloat(fVal) {
    var fParsedVal; //our internal converted float value


    fParsedVal = parseFloat(fVal);

    if (isNaN(fParsedVal) || Infinity == fParsedVal || -Infinity == fParsedVal) //sanity check - guard against empty strings and max/min values
        return false;
    else
        return !!(fVal % 1); //true only if there is a fractional value after the mod op; the !! returns the opposite value of the op which reflects the function's return value
}
0
wanglabs

Für diejenigen, die neugierig sind und Benchmark.js verwenden, habe ich die am häufigsten gestellten Antworten (und die heute veröffentlichte) auf diesen Beitrag getestet. Hier sind meine Ergebnisse:

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
0
jnthnjns
try this one
function amountcheck()
    {
        var dpamt=$('#dpamt').val()/5000;
        var ints=dpamt.toString();
        var isint=ints.split('.');
        if(isint[1]>0)
        {
            alert('float value');
            return false;
        }
        else
        {   
            alert('int value');
        }
    }
0
Ashish4434

Bedingung für die Floating-Validierung:

if (lnk.value == +lnk.value && lnk.value != (lnk.value | 0)) 

Bedingung für die Ganzzahlvalidierung:

if (lnk.value == +lnk.value && lnk.value == (lnk.value | 0)) 

Hoffe das könnte hilfreich sein.

0
Joe Mike

Hier ist mein Code. Es wird überprüft, ob es sich um eine leere Zeichenfolge handelt (die ansonsten übergeben wird), und anschließend in das numerische Format konvertiert. Abhängig davon, ob Sie möchten, dass "1.1" gleich "1.1" ist, ist dies möglicherweise das, wonach Sie suchen, oder nicht.

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;

};

Inspiriert von warfares 'antworte ich damit, um eine Zeichenketteneingabe zu validieren.

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

  // For testing
  console.log("validLatLng::n", n);
  console.log("validLatLng::parseInt", parseInt(n));
  console.log("validLatLng::parseFloat", parseFloat(n));
  console.log("validLatLng::isInt", isInt(n));
  console.log("validLatLng::isFloat", isFloat(n));

  return isInt(n) || isFloat(n);
}

Sie können es auf der Konsole folgendermaßen testen:

// Invalid for my use case
validLatLng("") // or `null`, `undefined`, etc.
validLatLng("a")
validLatLng("a1100")
validLatLng("-100a")
validLatLng("a100.00")
validLatLng("-2a100.00123")

// VALID for my use case
validLatLng("100")
validLatLng("-100")
validLatLng("100.00")
validLatLng("-100.00123")
0
vpibano

YourJS bietet die folgenden zwei Funktionen, die für alle Nummern funktionieren, einschließlich der Rückgabe von false für -Infinity und Infinity:

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

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

Da es sich bei typeOf() um eine interne YourJS-Funktion handelt, können Sie die Version für diese Funktionen hier herunterladen: http://yourjs.com/snippets/build/ 34

0
Chris West

Basierend auf allem, was ich hier gesehen habe, habe ich meine eigenen Funktionen erstellt, um zu testen, was ich brauche:

function NumberValidator() {
this.isFloat = function (n) {
    return typeof(n)==="number" && n === +n && Math.round(n) !== n;
};

this.isInteger = function (n) {
    return typeof(n)==="number" && n === +n && Math.round(n) === n;
};

this.isFloatOrInteger = function (n) {
    return this.isFloat(n) || this.isInteger(n);
};

this.isNonZeroFloatOrInteger = function (n) {
    return this.isFloatOrInteger(n) && n > 0;
};

this.isNonZeroInteger = function (n) {
    return this.isInteger(n) && n > 0;
};
}

Die Lösung von shime ist jedoch kürzer und mit weniger Überprüfungen versehen, sodass sie möglicherweise besser ist.

0
XMight

Ich musste einen Eingabewert überprüfen, ob er eine Ganzzahl oder ein Gleitkomma ist, und dazu habe ich Folgendes gefunden:

function isInteger(x) {
  var integer = parseInt(x, 10);
  if (!isNaN(integer) && !isFloat(x)) {
    return true;
  }
  return false;
}

function isFloat(x) {
  var f = parseFloat(x);
  var floor = Math.floor(f);
  var fraction = f - floor;
  if (fraction > 0) {
    return true;
  }
  return false;
}

var cases = [
  "1",
  "1.00",
  "1.01",
  "0.05",
  "ab1",
  "ab1.1",
  1,
  1.00,
  1.01,
  0.05,
  1e+5,
  "",
  true,
  false,
  null,
  NaN,
  undefined,
];

console.log("isInteger()");
for (var i = 0; i < cases.length; i++) {
  console.log(cases[i], isInteger(cases[i]));
}

console.log("\nisFloat()");
for (var i = 0; i < cases.length; i++) {
  console.log(cases[i], isFloat(cases[i]));
}
0
akinuri
function int(a) {
  return a - a === 0 && a.toString(32).indexOf('.') === -1
}

function float(a) {
  return a - a === 0 && a.toString(32).indexOf('.') !== -1
}

Sie können typeof a === 'number' hinzufügen, wenn Sie Zeichenfolgen ausschließen möchten.

0
Mirek Rusin

In manchen Fällen können Sie mit Number-Objekten den Mod-Operator (%) nicht direkt verwenden. In diesem Fall können Sie diese Lösung verwenden.

if(object instanceof Number ){
   if( ((Number) object).doubleValue() % 1 == 0 ){
      //your object is an integer
   }
   else{
      //your object is a double
   }
}
0
toddsalpen

Ich mag diese kleine Funktion, die sowohl für positive als auch für negative ganze Zahlen true zurückgibt:

function isInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN(val+".0");
}

Dies funktioniert, weil aus 1 oder 1 "1.0" wird, wobei isNaN () false zurückgibt (was wir dann negieren und zurückgeben), aber aus 1,0 oder 1,0 wird "1.0.0", während "string" zu "string" wird. 0 ", von denen keine Zahlen sind, also gibt isNaN () false zurück (und wird wiederum negiert).

Wenn Sie nur positive ganze Zahlen wollen, gibt es diese Variante:

function isPositiveInt(val) {
    return ["string","number"].indexOf(typeof(val)) > -1 && val !== '' && !isNaN("0"+val);
}

oder für negative ganze Zahlen:

function isNegativeInt(val) {
    return `["string","number"].indexOf(typeof(val)) > -1` && val !== '' && isNaN("0"+val);
}

isPositiveInt () verschiebt die verkettete numerische Zeichenfolge vor den zu testenden Wert. Beispielsweise führt isPositiveInt (1) dazu, dass isNaN () "01" auswertet, was false auswertet. Währenddessen führt isPositiveInt (-1) dazu, dass isNaN () "0-1" auswertet, was true ergibt. Wir negieren den Rückgabewert und das gibt uns das, was wir wollen. isNegativeInt () funktioniert ähnlich, ohne jedoch den Rückgabewert von isNaN () zu negieren.

Bearbeiten:

Meine ursprüngliche Implementierung würde auch für Arrays und leere Zeichenfolgen true zurückgeben. Diese Implementierung hat diesen Fehler nicht. Es hat auch den Vorteil, frühzeitig zurückzukehren, wenn val keine Zeichenfolge oder Zahl ist oder wenn es eine leere Zeichenfolge ist, wodurch es in diesen Fällen schneller wird. Sie können es weiter modifizieren, indem Sie die ersten beiden Klauseln durch ersetzen

typeof(val) != "number"

wenn Sie nur Literalzahlen (und keine Zeichenfolgen) abgleichen möchten

Bearbeiten:

Ich kann noch keine Kommentare veröffentlichen, daher füge ich dies meiner Antwort hinzu. Der von @Asok veröffentlichte Benchmark ist sehr informativ. Die schnellste Funktion entspricht jedoch nicht den Anforderungen, da sie auch TRUE für Floats, Arrays, Booleans und leere Zeichenfolgen zurückgibt.

Ich habe die folgende Testsuite erstellt, um jede der Funktionen zu testen. Dabei habe ich auch meine Antwort zur Liste hinzugefügt (Funktion 8, die Zeichenfolgen analysiert, und Funktion 9, die dies nicht tut):

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!");
}

Ich habe auch den Benchmark mit der Funktion Nr. 8 erneut in die Liste aufgenommen. Ich werde das Ergebnis nicht veröffentlichen, da es etwas peinlich ist (z. B. ist diese Funktion NICHT schnell) ...

Die (abgekürzt - ich habe erfolgreiche Tests entfernt, da die Ausgabe ziemlich lang ist) Ergebnisse lauten wie folgt:

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!

Ich habe Fehler hinterlassen, damit Sie sehen können, wo jede Funktion ausfällt, und die (Zeichenfolge) "#" -Tests, damit Sie sehen können, wie jede Funktion Ganzzahl- und Gleitkommawerte in Zeichenfolgen verarbeitet, da einige diese möglicherweise als Zahlen und andere analysieren möchten nicht dürfen.

Von den 10 getesteten Funktionen sind diejenigen, die tatsächlich den Anforderungen des OP entsprechen, [1,3,5,6,8,9].

0
KeMBro2012