Getallen zijn een primitief type in JavaScript, maar met alleen typeof maak je geen onderscheid tussen getallen en NaN of Oneindig.
Het is handig om te weten hoe je kunt controleren of een waarde van het primitieve type getal is, aangezien JavaScript een dynamisch getypeerde taal is.
De eenvoudigste manier om te controleren of een waarde een getal is, is met typeof, die de string "number" zal retourneren voor elke waarde van het primitieve type getal, inclusief NaNInfinity, en -Infinity.
Een voorbeeld waarbij een getal als een ander type zou kunnen verschijnen, wat op een fout in mijn code zou duiden, is bij het parsen van valuta:
In dit geval zou ik weten dat ik ben vergeten de string in een getal te parsen wanneer ik de waarde “string” terugkrijg van typeof.
Als ik parseFloat() gebruik om de valutawaarde te controleren, maar ik ben vergeten het valutasymbool te verwijderen, krijg ik een mislukte parse en een vreemd resultaat:
Oh, nee. In dit geval lijkt het erop dat typeof niet werkt zoals ik had verwacht – omdat NaN waarden in JavaScript als getallen worden beschouwd.
Wanneer het trefwoord typeof “getal”
Een voor de hand liggende oplossing om te controleren of het primitieve type getal is, is om het trefwoord typeof te gebruiken, zoals ik hierboven heb laten zien.
Maar typeof is een onvolledige oplossing, vanwege twee speciale waarden in JavaScript: NaN (“Not a Number”) en Infinity.
Voor mijn valuta-voorbeeld weet ik dat ik een fout heb als mijn monetaire waarde NaN of Infinity is, maar typeof retourneert "number" voor deze beide waarden.
Misschien is mijn invoer geschreven met een valutasymbool, en heb ik gewoon geprobeerd om parseFloat() te gebruiken om de waarde vast te leggen. Dat zou resulteren in NaN:
Een aangepaste isNumber()-functie
Arobust, aangepaste isNumber() functie zou typeof gebruiken om te controleren op het primitieve type, controleren op NaN waarden, en controleren op Infinity:
Of, in het geval dat men er zeker van is dat NaN en Infinity niet zullen opduiken, zou alleen een controle van typeof==="number" al voldoende zijn.
De one-liner
Ik ben dol op oneliners. Ik vind dat ze gedocumenteerd moeten worden met commentaar, maar ik denk dat ze ook echt nuttig zijn, niet alleen maar fancy.
Hier is de one-liner voor hoe je een getal kunt controleren in JavaScript:
Er is echter een betere manier om in JavaScript op een eindig getal te controleren – de helper-functie Number.isFinite() heeft hetzelfde gedrag als de aangepaste isNumber() functie die ik heb geschreven. Ik voeg een voorbeeld toe in de volgende sectie.
De eenvoudigste manier om te controleren of een getal: Number.isFinite()
Het is eigenlijk niet nodig om aangepaste functies te schrijven om op een getal te controleren, hoewel het een leerzame manier is om te onthouden dat de JavaScript-waarden Infinity-Infinity, en NaN allemaal van het primitieve type getal zijn.
“De methode
Number.isFinite()bepaalt of de doorgegeven waarde een eindig getal is.” – MDN Docs
De methode Number.isFinite() zal true teruggeven voor eindige getallen, en false voor Infinity-Infinity, en NaN – precies wat we willen:
Er is ook de globale isFinite() functie, die type coercion zal uitvoeren (zoals het dwingen van strings naar getallen), zoals hierboven getoond.
Ik bespreek deze methoden uitgebreid in mijn artikel over Infinity in The Startup:
Controleer of een variabele een geheel getal is
Om te controleren of variabele A een geheel getal is, zou ik de losse gelijkheidsoperator == kunnen gebruiken om te zien of de geparseerde waarde gelijk is aan zichzelf.
Het volgende codefragment geeft een voorbeeld van hoe je kunt controleren op een geheel getal:
Het gebruik van typeof zou een string die wordt omgevormd tot een getal onderscheiden van een werkelijk getal, net als de strikte gelijkheidsoperator ===.
Valutasymbolen wegstrepen
Voor een betere, robuustere functie zou ik valutasymbolen (zoals het dollarteken en eventuele komma’s) er eerst uit willen halen.
Het grondig ontleden van geld met reguliere expressies in JavaScript valt buiten het bestek van dit artikel, maar deze code verwijdert $ en , voordat het wordt ontleed:
Merk op dat de globale functies parseInt() en parseFloat() waardes zullen coercen naar strings, indien nodig, en zullen NaN teruggeven als coercion mislukt.
Er zijn ook de functies Numbers.parseInt() en Number.parseFloat(), die exact hetzelfde gedrag hebben.
Volgens de MDN Docs zijn die dubbele functies toegevoegd aan ECMAScript 2015 voor het “doel modularisatie van globals.”
Heeft JavaScript eigenlijk afzonderlijke gehele getallen?
Nee, JavaScript kent maar één type getal, dat intern wordt weergegeven als een 64-bits drijvende komma.
Die drijvende komma is het primitieve gegevenstype getal, en er is ook een type dat BigInt wordt genoemd en dat kan worden gebruikt voor willekeurig grote getallen.
De globale functies parseInt() en parseFloat() verschillen in wat ze verwachten en zullen uitvoeren, maar niet omdat er eigenlijk afzonderlijke integer- en floating point-typen zijn in JavaScript.
Conclusie
Het controleren van een getal in JavaScript is niet bijzonder ingewikkeld – typeof werkt in principe zoals het zou moeten, zolang men zich er maar van bewust is dat zowel NaN als Infinity het typeof nummer hebben.
De eenvoudigste manier om te controleren op een eindig getal (d.w.z. niet NaN of Infinity) in JavaScript is met behulp van Number.isFinite(), dat geen waarden naar getallen coerceert, of het globale isFinite(), dat wel type coercion uitvoert.
Bij het controleren op een geheel getal wordt de functie parseInt() gebruikt, gevolgd door het vergelijken van de geparsede waarde met zichzelf met == (die waarden die geen getallen zijn, zoals strings, naar getallen codeert) of === (die alleen waar teruggeeft als beide waarden getallen zijn).
Onder de motorkap zijn gehele getallen en vlottende getallen allemaal hetzelfde: JavaScript kent maar één type getal, het primitieve getaltype.
Verder lezen
- De functie
Number.isInteger()coereert strings niet naar getallen:
- Sumit Kumar Pradhan schreef over het controleren op getallen op Dev.to:
- Chris Ferdinandi bespreekt het ontleden van getallen op zijn vanilla JS-blog:
- De reguliere expressie
^+(\.{1,2})?$komt overeen met geld:
- Sarah Dayan heeft op frontstuff geschreven over het ontleden van geld in JavaScript: