76 views

(ingebouwde) Way in JavaScript om te controleren of een string een geldig nummer is

Hosted by Code Expert
javascript

Ik hoop dat er iets in dezelfde conceptuele ruimte is als de oude VB6 IsNumeric()Functie?

Antwoord 1, Autoriteit 100%

2 oktober 2020: Merk op dat veel blote botten benaders worden beladen met subtiele bugs (bijv. Whitespace, impliciete gedeeltelijke parsing, radix, dwang van arrays etc.) dat veel van de antwoorden hier falen om rekening mee te houden. De volgende implementatie kan voor u werken, maar merk op dat het niet geschikt is voor nummerafscheiders, behalve het decimale punt “.“: 

function isNumeric(str) {
  if (typeof str != "string") return false // we only process strings!  
  return !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
         !isNaN(parseFloat(str)) // ...and ensure strings of whitespace fail
}

Controleer of een variabele (inclusief een string) een getal is, controleer of het geen nummer is:

Dit werkt, ongeacht of de variabele inhoud een tekenreeks of nummer is. 

isNaN(num)         // returns true if the variable does NOT contain a valid number

Voorbeelden 

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true
isNaN('')          // false
isNaN(' ')         // false
isNaN(false)       // false

Natuurlijk kunt u dit ontkennen als u dat nodig hebt. Bijvoorbeeld om de isNumericte implementeren die u hebt gegeven: 

function isNumeric(num){
  return !isNaN(num)
}

Om een tekenreeks met een getal om te zetten in een getal:

Werkt alleen als de tekenreeks alleennumerieke tekens bevat, anders wordt NaNgeretourneerd.

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

Voorbeelden

+'12'              // 12
+'12.'             // 12
+'12..'            // NaN
+'.12'             // 0.12
+'..12'            // NaN
+'foo'             // NaN
+'12px'            // NaN

Een tekenreeks losjes omzetten in een getal

Nuttig voor het converteren van ’12px’ naar 12, bijvoorbeeld:

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

Voorbeelden

parseInt('12')     // 12
parseInt('aaa')    // NaN
parseInt('12px')   // 12
parseInt('foo2')   // NaN      These last two may be different
parseInt('12a5')   // 12       from what you expected to see.

Drijft

Houd er rekening mee dat, in tegenstelling tot +num, parseInt(zoals de naam al doet vermoeden) een float in een geheel getal zal omzetten door alles achter de komma af te hakken (als u parseInt()vanwegedit gedrag wilt gebruiken, je kunt in plaats daarvan waarschijnlijk beter een andere methode gebruiken):

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

Lege strings

Lege strings zijn misschien een beetje contra-intuïtief. +numconverteert lege tekenreeksen of tekenreeksen met spaties naar nul, en isNaN()neemt hetzelfde aan:

+''                // 0
+'   '             // 0
isNaN('')          // false
isNaN('   ')       // false

Maar parseInt()is het er niet mee eens:

parseInt('')       // NaN
parseInt('   ')    // NaN

Antwoord 2, autoriteit 4%

Als je alleen probeert te controleren of een tekenreeks een geheel getal is (geen decimalen), is regex een goede manier om te gaan. Andere methoden zoals isNaNzijn te ingewikkeld voor zoiets eenvoudigs.

function isNumeric(value) {
    return /^-?\d+$/.test(value);
}
console.log(isNumeric('abcd'));         // false
console.log(isNumeric('123a'));         // false
console.log(isNumeric('1'));            // true
console.log(isNumeric('1234567890'));   // true
console.log(isNumeric('-23'));          // true
console.log(isNumeric(1234));           // true
console.log(isNumeric(1234n));          // true
console.log(isNumeric('123.4'));        // false
console.log(isNumeric(''));             // false
console.log(isNumeric(undefined));      // false
console.log(isNumeric(null));           // false

Als u alleen positievegehele getallen wilt toestaan, gebruikt u dit:

function isNumeric(value) {
    return /^\d+$/.test(value);
}
console.log(isNumeric('123'));          // true
console.log(isNumeric('-23'));          // false

Antwoord 3, autoriteit 2%

En je zou op de RegExp-manier kunnen gaan:

var num = "987238";
if(num.match(/^-?\d+$/)){
  //valid integer (positive or negative)
}else if(num.match(/^\d+\.\d+$/)){
  //valid float
}else{
  //not valid number
}

Antwoord 4, autoriteit 2%

Het geaccepteerde antwoord op deze vraag heeft nogal wat gebreken (zoals opgemerkt door een aantal andere gebruikers). Dit is een van de gemakkelijkste & bewezen manier om het in javascript te benaderen:

function isNumeric(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}

Hieronder staan enkele goede testcases:

console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric('2 '));                 // true
console.log(isNumeric('-32.2 '));             // true
console.log(isNumeric(-32.2));                // true
console.log(isNumeric(undefined));            // false
// the accepted answer fails at these tests:
console.log(isNumeric(''));                   // false
console.log(isNumeric(null));                 // false
console.log(isNumeric([]));                   // false

Antwoord 5, autoriteit 2%

Als je er echt zeker van wilt zijn dat een string alleen een getal, een willekeurig getal (geheel getal of drijvende komma) en precies een getal bevat, kuntparseInt()/ parseFloat(), Number()of !isNaN()afzonderlijk. Merk op dat !isNaN()feitelijk trueretourneert wanneer Number()een getal retourneert, en falsewanneer het zou NaNteruggeven, dus ik zal het uitsluiten van de rest van de discussie.

Het probleem met parseFloat()is dat het een getal retourneert als de string een getal bevat, zelfs als de string niet alleenen bevat precieseen nummer:

parseFloat("2016-12-31")  // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2

Het probleem met Number()is dat het een getal retourneert in gevallen waarin de doorgegeven waarde helemaal geen getal is!

Number("") // returns 0
Number(" ") // returns 0
Number(" \u00A0   \t\n\r") // returns 0

Het probleem met het rollen van je eigen regex is dat tenzij je de exacte regex maakt voor het matchen van een drijvende-kommagetal zoals Javascript het herkent, je gevallen zult missen of gevallen zult herkennen waar dat niet zou moeten. En zelfs als je je eigen regex kunt draaien, waarom? Er zijn eenvoudiger ingebouwde manieren om dit te doen.

Het blijkt echter dat Number()(en isNaN()) het juiste doet voor elk geval waarin parseFloat()geeft een getal terug wanneer het niet zou moeten, en vice versa. Dus om erachter te komen of een string echt precies is en alleen een getal, roept u beide functies aan en kijkt u of ze beidetrue retourneren:

function isNumber(str) {
  if (typeof str != "string") return false // we only process strings!
  // could also coerce to string: str = ""+str
  return !isNaN(str) && !isNaN(parseFloat(str))
}

Antwoord 6

Probeer de isNan-functie:

De functie isNaN() bepaalt of een waarde een ongeldig getal is (Not-a-Number).

Deze functie retourneert true als de waarde gelijk is aan NaN. Anders wordt false geretourneerd.

Deze functie verschilt van de nummerspecifieke Number.isNaN()methode.

  De globale functie isNaN() converteert de geteste waarde naar een Getal en test deze vervolgens.

Number.isNan() converteert de waarden niet naar een Getal en geeft geen true terug voor waarden die niet van het type Getal zijn…

Antwoord 7

Oude vraag, maar er ontbreken een aantal punten in de gegeven antwoorden.

Wetenschappelijke notatie.

!isNaN('1e+30')is true, maar in de meeste gevallen willen mensen, als ze om getallen vragen, niet overeenkomen met dingen als 1e+30.

Grote zwevende getallen kunnen raar gedragen

Waarnemen (met Node.js):

> var s = Array(16 + 1).join('9')
undefined
> s.length
16
> s
'9999999999999999'
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>

Aan de andere kant:

> var s = Array(16 + 1).join('1')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join('9')
undefined
> String(Number(s)) === s
true
>

Dus, als je String(Number(s)) === sverwacht, beperk je strings dan beter tot maximaal 15 cijfers (na het weglaten van voorloopnullen).

Oneindig

> typeof Infinity
'number'
> !isNaN('Infinity')
true
> isFinite('Infinity')
false
>

Gezien dat alles, controleren of de gegeven string een getal is dat aan al het volgende voldoet:

  • niet-wetenschappelijke notatie
  • voorspelbare conversie naar Numberen terug naar string
  • eindig

is niet zo’n gemakkelijke taak. Hier is een eenvoudige versie:

 function isNonScientificNumberString(o) {
    if (!o || typeof o !== 'string') {
      // Should not be given anything but strings.
      return false;
    }
    return o.length <= 15 && o.indexOf('e+') < 0 && o.indexOf('E+') < 0 && !isNaN(o) && isFinite(o);
  }

Maar zelfs deze is verre van compleet. Voorloopnullen worden hier niet behandeld, maar ze verpesten de lengtetest.

Antwoord 8

Ik heb het getest en de oplossing van Michael is de beste. Stem hierboven op zijn antwoord (zoek op deze pagina naar “Als je er echt zeker van wilt zijn dat een string” het vindt). In wezen is zijn antwoord dit:

function isNumeric(num){
  num = "" + num; //coerce num to be a string
  return !isNaN(num) && !isNaN(parseFloat(num));
}

Het werkt voor elke testcase, die ik hier heb gedocumenteerd:
https://jsfidddle.net/wgGehvp9/5/

Veel van de andere oplossingen mislukken voor deze randzaken:
”, null ‘,’, waar en [].
In theorie zou u ze kunnen gebruiken, met een goede foutafhandeling, bijvoorbeeld: 

return !isNaN(num);

of 

return (+num === +num);

met speciale afhandeling voor
/ \ s /, null, “”, true, false, [] (en anderen?)

Antwoord 9

U kunt het resultaat van nummer bij het passeren van een argument voor de constructor.

Als het argument (een string) niet kan worden omgezet in een cijfer, retourneert het NAN, zodat u kunt bepalen of de meegeleverde snaar een geldig nummer of niet is.

OPMERKINGEN: OPMERKING Bij het passeren van lege string of '\t\t'en '\n\t'als nummer retourneert 0; True true retourneert 1 en valse rendementen 0. 

   Number('34.00') // 34
    Number('-34') // -34
    Number('123e5') // 12300000
    Number('123e-5') // 0.00123
    Number('999999999999') // 999999999999
    Number('9999999999999999') // 10000000000000000 (integer accuracy up to 15 digit)
    Number('0xFF') // 255
    Number('Infinity') // Infinity  
    Number('34px') // NaN
    Number('xyz') // NaN
    Number('true') // NaN
    Number('false') // NaN
    // cavets
    Number('    ') // 0
    Number('\t\t') // 0
    Number('\n\t') // 0

Antwoord 10

Misschien zijn er een of twee mensen die deze vraag tegenkomen die een veel strengerecontrole nodig hebben dan normaal (zoals ik deed). In dat geval kan dit handig zijn:

if(str === String(Number(str))) {
  // it's a "perfectly formatted" number
}

Pas op! Hiermee worden tekenreeksen zoals .1, 40.000, 080, 00.1afgewezen. Het is erg kieskeurig – de tekenreeks moet overeenkomen met de “meest minimale perfecte vorm” van het getal om deze test te laten slagen.

Het gebruikt de stringen Numberconstructor om de string naar een getal en weer terug te casten en controleert dus of de “perfecte minimale vorm” van de JavaScript-engine (degene die het werd geconverteerd naar met de initiële Numberconstructor) overeenkomt met de originele tekenreeks.

Antwoord 11

2019: inclusief ES3, ES6 en TypeScript-voorbeelden

Misschien is dit te vaak herhaald, maar ik heb vandaag ook met deze gevochten en wilde mijn antwoord posten, omdat ik geen ander antwoord zag dat het zo eenvoudig of grondig doet:

ES3

var isNumeric = function(num){
    return (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);  
}

ES6

const isNumeric = (num) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num);

Schrijfschrift

const isNumeric = (num: any) => (typeof(num) === 'number' || typeof(num) === "string" && num.trim() !== '') && !isNaN(num as number);

Dit lijkt vrij eenvoudig en dekt alle basissen die ik in de vele andere berichten heb gezien en zelf heb bedacht:

// Positive Cases
console.log(0, isNumeric(0) === true);
console.log(1, isNumeric(1) === true);
console.log(1234567890, isNumeric(1234567890) === true);
console.log('1234567890', isNumeric('1234567890') === true);
console.log('0', isNumeric('0') === true);
console.log('1', isNumeric('1') === true);
console.log('1.1', isNumeric('1.1') === true);
console.log('-1', isNumeric('-1') === true);
console.log('-1.2354', isNumeric('-1.2354') === true);
console.log('-1234567890', isNumeric('-1234567890') === true);
console.log(-1, isNumeric(-1) === true);
console.log(-32.1, isNumeric(-32.1) === true);
console.log('0x1', isNumeric('0x1') === true);  // Valid number in hex
// Negative Cases
console.log(true, isNumeric(true) === false);
console.log(false, isNumeric(false) === false);
console.log('1..1', isNumeric('1..1') === false);
console.log('1,1', isNumeric('1,1') === false);
console.log('-32.1.12', isNumeric('-32.1.12') === false);
console.log('[blank]', isNumeric('') === false);
console.log('[spaces]', isNumeric('   ') === false);
console.log('null', isNumeric(null) === false);
console.log('undefined', isNumeric(undefined) === false);
console.log([], isNumeric([]) === false);
console.log('NaN', isNumeric(NaN) === false);

Je kunt ook je eigen isNumeric-functie proberen en deze gebruiksgevallen gewoon voorbij laten gaan en ze allemaal scannen op “true”.

Of, om de waarden te zien die elk terugkeren:

isNumeric()“>

Antwoord 12

Waarom is de implementatie van JQuery niet goed genoeg? 

function isNumeric(a) {
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};

Michael suggereerde zoiets (hoewel ik hier heb gestolen “user1691651 – John”‘s gewijzigde versie hier): 

function isNumeric(num){
    num = "" + num; //coerce num to be a string
    return !isNaN(num) && !isNaN(parseFloat(num));
}

Het volgende is een oplossing met meest waarschijnlijke slechte prestaties, maar solide resultaten. Het is een aftaking gemaakt van de jQuery 1.12.4-implementatie en het antwoord van Michael, met een extra cheque voor toonaangevende / achterliggende ruimtes (omdat de versie van Michael true weer voor numeriek met toonaangevende ruimtes): 

function isNumeric(a) {
    var str = a + "";
    var b = a && a.toString();
    return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
           !/^\s+|\s+$/g.test(str) &&
           !isNaN(str) && !isNaN(parseFloat(str));
};

De laatste versie heeft echter twee nieuwe variabelen. Men zou er een van hen kunnen vinden, door: 

function isNumeric(a) {
    if ($.isArray(a)) return false;
    var b = a && a.toString();
    a = a + "";
    return b - parseFloat(b) + 1 >= 0 &&
            !/^\s+|\s+$/g.test(a) &&
            !isNaN(a) && !isNaN(parseFloat(a));
};

Ik heb geen van deze veel getest, behalve handmatig de paar use-cases die ik tegenkom met mijn huidige hachelijke situatie, wat allemaal erg standaard is. Dit is een situatie van “op de schouders van reuzen staan”.

Antwoord 13

2019: praktische en strakke numerieke validiteitscontrole

Vaak betekent een ‘geldig getal’ een Javascript-nummer exclusief NaN en Infinity, dwz een ‘eindig getal’.

Als u de numerieke geldigheid van een waarde wilt controleren (bijvoorbeeld van een externe bron), kunt u in ESlint Airbnb-stijl definiëren:

/**
 * Returns true if 'candidate' is a finite number or a string referring (not just 'including') a finite number
 * To keep in mind:
 *   Number(true) = 1
 *   Number('') = 0
 *   Number("   10  ") = 10
 *   !isNaN(true) = true
 *   parseFloat('10 a') = 10
 *
 * @param {?} candidate
 * @return {boolean}
 */
function isReferringFiniteNumber(candidate) {
  if (typeof (candidate) === 'number') return Number.isFinite(candidate);
  if (typeof (candidate) === 'string') {
    return (candidate.trim() !== '') && Number.isFinite(Number(candidate));
  }
  return false;
}

en gebruik het op deze manier:

if (isReferringFiniteNumber(theirValue)) {
  myCheckedValue = Number(theirValue);
} else {
  console.warn('The provided value doesn\'t refer to a finite number');
}

Antwoord 14

Het is niet geldig voor TypeScript als:

declare function isNaN(number: number): boolean;

Voor TypeScript kunt u gebruiken:

/^\d+$/.test(key)

Antwoord 15

PARSEINT (), maar houd er rekening mee dat deze functie een beetje anders is in die zin dat het bijvoorbeeld 100 voor PARSEINT (“100px”) retourneert.

Antwoord 16

QUOTE:

ISNAN (NUM) // Keert uit als de variabele geen geldig nummer

bevat

is niet helemaal waar als u moet controleren op toonaangevende / volgruimtes – bijvoorbeeld wanneer een bepaalde hoeveelheid cijfers vereist is, en u moet, zeggen, ‘1111’ en niet ‘111’ of ‘111’ Misschien een PIN-ingang.

beter om te gebruiken: 

var num = /^\d+$/.test(num)

Antwoord 17

Als iemand ooit verlaagt, heb ik wat tijd doorgebracht met het proberen om Moment te patchen.js (https : //github.com/moment/moment ). Hier is iets dat ik er van heb weggenomen: 

function isNumeric(val) {
    var _val = +val;
    return (val !== val + 1) //infinity check
        && (_val === +val) //Cute coercion check
        && (typeof val !== 'object') //Array/object check
}

verwerkt de volgende gevallen:

waar! : 

isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))

false! : 

isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric('[1,2,3]'))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))

Ironisch genoeg, degene waar ik het meest mee worstel:

isNumeric(new Number(1)) => false

Alle suggesties zijn welkom. :]

Antwoord 18

Ik heb onlangs een artikel geschreven over manieren om ervoor te zorgen dat een variabele een geldig nummer is: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.mdHet artikel legt uit hoe je een drijvende komma of integer kunt garanderen, als dat belangrijk is (+xversus ~~x).

Het artikel gaat ervan uit dat de variabele een stringof een numberis om mee te beginnen en dat trimbeschikbaar/polyfill is. Het zou niet moeilijk zijn om het uit te breiden om ook andere typen aan te kunnen. Hier is het vlees van:

// Check for a valid float
if (x == null
    || ("" + x).trim() === ""
    || isNaN(+x)) {
    return false;  // not a float
}
// Check for a valid integer
if (x == null
    || ("" + x).trim() === ""
    || ~~x !== +x) {
    return false;  // not an integer
}

Antwoord 19

function isNumberCandidate(s) {
  const str = (''+ s).trim();
  if (str.length === 0) return false;
  return !isNaN(+str);
}
console.log(isNumberCandidate('1'));       // true
console.log(isNumberCandidate('a'));       // false
console.log(isNumberCandidate('000'));     // true
console.log(isNumberCandidate('1a'));      // false 
console.log(isNumberCandidate('1e'));      // false
console.log(isNumberCandidate('1e-1'));    // true
console.log(isNumberCandidate('123.3'));   // true
console.log(isNumberCandidate(''));        // false
console.log(isNumberCandidate(' '));       // false
console.log(isNumberCandidate(1));         // true
console.log(isNumberCandidate(0));         // true
console.log(isNumberCandidate(NaN));       // false
console.log(isNumberCandidate(undefined)); // false
console.log(isNumberCandidate(null));      // false
console.log(isNumberCandidate(-1));        // true
console.log(isNumberCandidate('-1'));      // true
console.log(isNumberCandidate('-1.2'));    // true
console.log(isNumberCandidate(0.0000001)); // true
console.log(isNumberCandidate('0.0000001')); // true
console.log(isNumberCandidate(Infinity));    // true
console.log(isNumberCandidate(-Infinity));    // true
console.log(isNumberCandidate('Infinity'));  // true
if (isNumberCandidate(s)) {
  // use +s as a number
  +s ...
}

Antwoord 20

Nou, ik gebruik deze die ik heb gemaakt…

Het werkt tot nu toe:

function checkNumber(value) {
    return value % 1 == 0;
}

Als je er een probleem mee opmerkt, vertel het me dan alsjeblieft.

Antwoord 21

Bij het beschermen tegen lege strings en null

// Base cases that are handled properly
Number.isNaN(Number('1')); // => false
Number.isNaN(Number('-1')); // => false
Number.isNaN(Number('1.1')); // => false
Number.isNaN(Number('-1.1')); // => false
Number.isNaN(Number('asdf')); // => true
Number.isNaN(Number(undefined)); // => true
// Special notation cases that are handled properly
Number.isNaN(Number('1e1')); // => false
Number.isNaN(Number('1e-1')); // => false
Number.isNaN(Number('-1e1')); // => false
Number.isNaN(Number('-1e-1')); // => false
Number.isNaN(Number('0b1')); // => false
Number.isNaN(Number('0o1')); // => false
Number.isNaN(Number('0xa')); // => false
// Edge cases that will FAIL if not guarded against
Number.isNaN(Number('')); // => false
Number.isNaN(Number(' ')); // => false
Number.isNaN(Number(null)); // => false
// Edge cases that are debatable
Number.isNaN(Number('-0b1')); // => true
Number.isNaN(Number('-0o1')); // => true
Number.isNaN(Number('-0xa')); // => true
Number.isNaN(Number('Infinity')); // => false 
Number.isNaN(Number('INFINITY')); // => true  
Number.isNaN(Number('-Infinity')); // => false 
Number.isNaN(Number('-INFINITY')); // => true

Als je NIET bewaakt tegen lege strings en null

Gebruik parseInt:

// Base cases that are handled properly
Number.isNaN(parseInt('1')); // => false
Number.isNaN(parseInt('-1')); // => false
Number.isNaN(parseInt('1.1')); // => false
Number.isNaN(parseInt('-1.1')); // => false
Number.isNaN(parseInt('asdf')); // => true
Number.isNaN(parseInt(undefined)); // => true
Number.isNaN(parseInt('')); // => true
Number.isNaN(parseInt(' ')); // => true
Number.isNaN(parseInt(null)); // => true
// Special notation cases that are handled properly
Number.isNaN(parseInt('1e1')); // => false
Number.isNaN(parseInt('1e-1')); // => false
Number.isNaN(parseInt('-1e1')); // => false
Number.isNaN(parseInt('-1e-1')); // => false
Number.isNaN(parseInt('0b1')); // => false
Number.isNaN(parseInt('0o1')); // => false
Number.isNaN(parseInt('0xa')); // => false
// Edge cases that are debatable
Number.isNaN(parseInt('-0b1')); // => false
Number.isNaN(parseInt('-0o1')); // => false
Number.isNaN(parseInt('-0xa')); // => false
Number.isNaN(parseInt('Infinity')); // => true 
Number.isNaN(parseInt('INFINITY')); // => true  
Number.isNaN(parseInt('-Infinity')); // => true 
Number.isNaN(parseInt('-INFINITY')); // => true

Gebruik parseFloat:

// Base cases that are handled properly
Number.isNaN(parseFloat('1')); // => false
Number.isNaN(parseFloat('-1')); // => false
Number.isNaN(parseFloat('1.1')); // => false
Number.isNaN(parseFloat('-1.1')); // => false
Number.isNaN(parseFloat('asdf')); // => true
Number.isNaN(parseFloat(undefined)); // => true
Number.isNaN(parseFloat('')); // => true
Number.isNaN(parseFloat(' ')); // => true
Number.isNaN(parseFloat(null)); // => true
// Special notation cases that are handled properly
Number.isNaN(parseFloat('1e1')); // => false
Number.isNaN(parseFloat('1e-1')); // => false
Number.isNaN(parseFloat('-1e1')); // => false
Number.isNaN(parseFloat('-1e-1')); // => false
Number.isNaN(parseFloat('0b1')); // => false
Number.isNaN(parseFloat('0o1')); // => false
Number.isNaN(parseFloat('0xa')); // => false
// Edge cases that are debatable
Number.isNaN(parseFloat('-0b1')); // => false
Number.isNaN(parseFloat('-0o1')); // => false
Number.isNaN(parseFloat('-0xa')); // => false
Number.isNaN(parseFloat('Infinity')); // => false 
Number.isNaN(parseFloat('INFINITY')); // => true  
Number.isNaN(parseFloat('-Infinity')); // => false 
Number.isNaN(parseFloat('-INFINITY')); // => true

Opmerkingen:

  • Alleen string, leeg en niet-geïnitialiseerde waarden worden beschouwd als bijhouden bij het aanpakken van de oorspronkelijke vraag. Extra randcases bestaan ​​als arrays en objecten de waarden worden overwogen.
  • Tekens in binary, octale, hexadecimale en exponentiële notatie zijn niet hoofdlettergevoelig (dat wil zeggen: ‘0xff’, ‘0xff’, ‘0xff’ enz. Zullen allemaal hetzelfde resultaat opgeven in de bovenstaande testcases ).
  • In tegenstelling tot Infinity(hoofdlettergevoelig) In sommige gevallen, constanten uit de Numberen MathObjecten Geschikt als Test Cases In tekenreeksformaat zal worden bepaald aan een van de bovenstaande methoden om niet nummers te zijn.
  • Zie hier voor een uitleg Van hoe argumenten worden geconverteerd naar een Numberen waarom de randgevallen voor nullen lege snaren bestaan.

Antwoord 22

PFB de werkoplossing: 

function(check){ 
    check = check + "";
    var isNumber =   check.trim().length>0? !isNaN(check):false;
    return isNumber;
    }

Antwoord 23

Sla jezelf op de hoofdpijn om een ​​”ingebouwde” oplossing te vinden.

Er is geen goed antwoord en het enorm geprefabriceerde antwoord in deze thread is verkeerd.

npm install is-number

In JavaScript is het niet altijd zo eenvoudig omdat het moet zijn om betrouwbaar te controleren of een waarde een getal is. Het is gebruikelijk voor Devs om +, – of nummer () te gebruiken om een ​​tekenreekswaarde te werpen naar een nummer (bijvoorbeeld wanneer waarden worden geretourneerd uit gebruikersinvoer, regex-overeenkomsten, parsers, enz.). Maar er zijn veel niet-intuïtieve randgevallen die onverwachte resultaten opleveren: 

console.log(+[]); //=> 0
console.log(+''); //=> 0
console.log(+'   '); //=> 0
console.log(typeof NaN); //=> 'number'

Antwoord 24

Dit is gebaseerd op enkele van de eerdere antwoorden en opmerkingen. Het volgende behandelt alle randgevallen en is ook redelijk beknopt:

const isNumRegEx = /^-?(\d*\.)?\d+$/;
function isNumeric(n, allowScientificNotation = false) {
    return allowScientificNotation ? 
                !Number.isNaN(parseFloat(n)) && Number.isFinite(n) :
                isNumRegEx.test(n);
}

Antwoord 25

Dit lijkt het schijnbaar oneindige aantal randgevallen te vangen:

function isNumber(x, noStr) {
    /*
        - Returns true if x is either a finite number type or a string containing only a number
        - If empty string supplied, fall back to explicit false
        - Pass true for noStr to return false when typeof x is "string", off by default
        isNumber(); // false
        isNumber([]); // false
        isNumber([1]); // false
        isNumber([1,2]); // false
        isNumber(''); // false
        isNumber(null); // false
        isNumber({}); // false
        isNumber(true); // false
        isNumber('true'); // false
        isNumber('false'); // false
        isNumber('123asdf'); // false
        isNumber('123.asdf'); // false
        isNumber(undefined); // false
        isNumber(Number.POSITIVE_INFINITY); // false
        isNumber(Number.NEGATIVE_INFINITY); // false
        isNumber('Infinity'); // false
        isNumber('-Infinity'); // false
        isNumber(Number.NaN); // false
        isNumber(new Date('December 17, 1995 03:24:00')); // false
        isNumber(0); // true
        isNumber('0'); // true
        isNumber(123); // true
        isNumber(123.456); // true
        isNumber(-123.456); // true
        isNumber(-.123456); // true
        isNumber('123'); // true
        isNumber('123.456'); // true
        isNumber('.123'); // true
        isNumber(.123); // true
        isNumber(Number.MAX_SAFE_INTEGER); // true
        isNumber(Number.MAX_VALUE); // true
        isNumber(Number.MIN_VALUE); // true
        isNumber(new Number(123)); // true
    */
    return (
        (typeof x === 'number' || x instanceof Number || (!noStr && x && typeof x === 'string' && !isNaN(x))) &&
        isFinite(x)
    ) || false;
};

Antwoord 26

Het hangt dus af van de testgevallen die u ermee wilt behandelen.

function isNumeric(number) {
  return !isNaN(parseFloat(number)) && !isNaN(+number);
}

Waar ik naar op zoek was, waren gewone soorten getallen in javascript.
0, 1 , -1, 1.1 , -1.1 , 1E1 , -1E1 , 1e1 , -1e1, 0.1e10, -0.1.e10 , 0xAF1 , 0o172, Math.PI, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY

En het zijn ook representaties als strings:
'0', '1', '-1', '1.1', '-1.1', '1E1', '-1E1', '1e1', '-1e1', '0.1e10', '-0.1.e10', '0xAF1', '0o172'

Ik wilde ze weglaten en niet markeren als numeriek
'', ' ', [], {}, null, undefined, NaN

Vanaf vandaag leken alle andere antwoorden te falen in een van deze testgevallen.

Antwoord 27

Het nummer in JS controleren:

  1. De beste manier om te controleren of het een getal is:

    isFinite(20)
//True

  2. Lees een waarde uit een string. CSS *:

    parseInt('2.5rem')
//2
parseFloat('2.5rem')
//2.5

  3. Voor een geheel getal:

    isInteger(23 / 0)
//False

  4. Als de waarde NaN is:

    isNaN(20)
//False

Antwoord 28

Mijn poging tot een enigszins verwarrende, misschien niet de beste oplossing

function isInt(a){
    return a === ""+~~a
}
console.log(isInt('abcd'));         // false
console.log(isInt('123a'));         // false
console.log(isInt('1'));            // true
console.log(isInt('0'));            // true
console.log(isInt('-0'));           // false
console.log(isInt('01'));           // false
console.log(isInt('10'));           // true
console.log(isInt('-1234567890'));  // true
console.log(isInt(1234));           // false
console.log(isInt('123.4'));        // false
console.log(isInt(''));             // false
// other types then string returns false
console.log(isInt(5));              // false
console.log(isInt(undefined));      // false
console.log(isInt(null));           // false
console.log(isInt('0x1'));          // false
console.log(isInt(Infinity));       // false

Antwoord 29

Ik gebruikte deze functie als een formuliervalidatietool en ik wilde niet dat gebruikers exponentiële functies konden schrijven, dus bedacht ik deze functie:

<script>
    function isNumber(value, acceptScientificNotation) {
        if(true !== acceptScientificNotation){
            return /^-{0,1}\d+(\.\d+)?$/.test(value);
        }
        if (true === Array.isArray(value)) {
            return false;
        }
        return !isNaN(parseInt(value, 10));
    }
    console.log(isNumber(""));              // false
    console.log(isNumber(false));           // false
    console.log(isNumber(true));            // false
    console.log(isNumber("0"));             // true
    console.log(isNumber("0.1"));           // true
    console.log(isNumber("12"));            // true
    console.log(isNumber("-12"));           // true
    console.log(isNumber(-45));             // true
    console.log(isNumber({jo: "pi"}));      // false
    console.log(isNumber([]));              // false
    console.log(isNumber([78, 79]));        // false
    console.log(isNumber(NaN));             // false
    console.log(isNumber(Infinity));        // false
    console.log(isNumber(undefined));       // false
    console.log(isNumber("0,1"));           // false
    console.log(isNumber("1e-1"));          // false
    console.log(isNumber("1e-1", true));    // true
</script>

Antwoord 30

In mijn toepassing staan we alleen a-z A-Z en 0-9 tekens toe. Ik vond het antwoord hierboven met behulp van ” string% 1 === 0″ werkte, tenzij de string begon met 0xnn (zoals 0x10) en dan zou het als numeriek worden geretourneerd als we dat niet wilden. De volgende eenvoudige valstrik in mijn numerieke controle lijkt de slag te slaan in onze specifieke gevallen. 

function isStringNumeric(str_input){   
    //concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up   
    //very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine   
    return '1'.concat(str_input) % 1 === 0;}

Waarschuwing : dit kan een langdurige bug in Javascript en ActionScript gebruiken [nummer (“1” + the_string)% 1 === 0)], ik kan daar niet voor spreken, maar Het is precies wat we nodig hadden.

Previous articlePython: AttributeError: ‘_io.textiowrapper’ object heeft geen attribuut ‘Split’
Next articleLees en schrijf naar binaire bestanden in C?

Other episodes

Is een functie die Math.random() puur aanroept?

javascript Code Expert - 0
Is het volgende een pure functie? function test(min,max) { return Math.random() * (max - min) + min; } Ik heb begrepen dat een pure...
Read more

Ik wil een tekst of regel met ellips afkappen met JavaScript

javascript Code Expert - 0
Ik ben op zoek naar een eenvoudig script dat een string kan afkappen met ellips (...) Ik wil iets als 'this is a very long...
Read more

firebase.firestore() is geen functie bij het initialiseren van Cloud Firestore

javascript Code Expert - 0
Toen ik Firebase Cloud Firestore probeerde te initialiseren, kwam ik de volgende fout tegen: Uncaught TypeError: WEBPACK_IMPORTED_MODULE_0_firebase.firestore is geen functie Ik heb eerder firebase...
Read more

Hoe krijg ik een hoogte van een toetsenbord in React-Native?

javascript Code Expert - 0
Ik gebruik React-Navigation in mijn app en de app bestaat uit StackNavigator met meerdere schermen, waarvan sommige schermen TextInput hebben met autoFocus={true} Probleem:op deze schermen...
Read more

ReferenceError: prestatie is niet gedefinieerd bij gebruik van performance.now()

javascript Code Expert - 0
Ik krijg een foutmelding ReferenceError: performance is not definedwanneer ik performance.now()om de uitvoeringstijd van een functieaanroep te meten: export async function find(someId: string, ctx: context.IContext)...
Read more

Herhaal een reeks objecten in Typescript

javascript Code Expert - 0
Ik moet de reeks objecten in hoek 2 herhalen en de weergave van de tekenreekslengte voor een bepaalde sleutel in het object beperken. this.productService.loadAllProducts(product).subscribe(data =>...
Read more

Zet lengtebeperking in een TextField in react js

javascript Code Expert - 0
Ik neem een ​​invoer van de gebruiker van het kaartnummer en wil dat de lengte die door de gebruiker wordt ingevoerd niet kleiner en...
Read more

© Copyright - Code Expert 2021