isNumber would make for a legit package. Is there a good way in javascript to determine confidently if an arbitrary input is a number?

e.g: [1, "one", true, false, 0, "zero", null, undefined]

edit: also ["1", "0", etc]

edit 2: also [NaN]

Looks like the author of these packages agrees. While the is-even and is-odd packages are under the i-voted-for-trump user with the description "This is a joke", the is-number package [1] is still kept under the main profile of the author, the repository is still active on GitHub and there are active issues.

[1] https://github.com/jonschlinkert/is-number

    typeof v === "number"

The rest is parsing territory.

  “number" == typeof variable

Works for decimals, too.

Although maybe you meant to include

  "1"

In your examples?

Unfortunately "not a number" is typeof "number"

    "number" === typeof NaN

Returns true.

I mean, it depends on context what “numbers” are acceptable. For an overly general solution:

  const allowNumbers = {
    all: () => true,
    notNaN: n => !Number.isNaN(n),
    finite: Number.isFinite,
    integer: Number.isInteger,
    smol: n => Math.abs(n) < Number.EPSILON,
    lorge: n => n > Number.MAX_SAFE_INTEGER || n < Number.MIN_SAFE_INTEGER,
  }

  function isNumber(n, allow = allowNumbers.all) {
    return ("number" === typeof n) && allow(n);
  }

This isn't bad, but for maintainability, it should be split into at least nine packages.

In the type of things that Javascript considers 'numbers', it's a value used to indicate that it's not of the type of things that math considers 'numbers'.

That's a tricky one that I think would depend on use case. Yes, of course NaN isn't a number, but it's still kind of a number, depending on context.

NaN is a float according to IEEE754. All numbers in Javascript being floats, it makes sense that typeof NaN === "number".

Now, the fact that IEEE754 is insane is something else, but JS does nothing wrong (aside from not having not-floats)

> Now, the fact that IEEE754 is insane is something else, but JS does nothing wrong (aside from not having not-floats)

JS has BigInt - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

BigInt is relatively recent, all things considered. JS only having floats is a conception flaw.

typeof x === 'number' && !Number.isNaN(x)

This seems like the best solution.

Any weird edge cases against this one?

Comparing it against the list of examples given in is-number, this solution does not properly handle numbers represented as strings, and it also recognizes Infinity as a number.

Because strings aren't numbers and Infinity is a number

Strings are the safest way to hold big numbers in JavaScript due to how JavaScript represents numbers. Also no, infinity is not a number. It's a concept.

Numbers is a concept. For some purposes it is useful to consider a number that is infinite, which is why concepts like the extended real number line have been invented.

+/- Infinity, better to use Number.isFinite.

Infinities.

Number.isFinite() does very well in most cases

... typeof foo === 'number'

that is odd