Arrrgh!  Don't listen to the regular expression answers.  RegEx is icky for this, and I'm not talking just performance.  It's so easy to make subtle, impossible to spot mistakes with your regular expression.  

If you can't use `isNaN()`, this should work much better:

    function IsNumeric(input)
    {
        return (input - 0) == input && (input+'').replace(/^\s+|\s+$/g, "").length > 0;
    }

Here's how it works:

The `(input - 0)` expression forces JavaScript to do type coercion on your input value; it must first be interpreted as a number for the subtraction operation.  If that conversion to a number fails, the expression will result in `NaN`.  This _numeric_ result is then compared to the original value you passed in.  Since the left hand side is now numeric, type coercion is again used.  Now that the input from both sides was coerced to the same type from the same original value, you would think they should always be the same (always true). However, there's a special rule that says `NaN` is never equal to `NaN`, and so a value that can't be converted to a number (and only values that cannot be converted to numbers) will result in false. 

The check on the length is of course for the empty string special case.  Also note that it falls down on your 0x89f test, but that's because in many environments that's an okay way to define a number literal.  If you want to catch that specific scenario you could add an additional check.  Even better, if that's your reason for not using `isNaN()` then just wrap your own function around `isNaN()` that can also do the additional check.

In summary, ***if you want to know if a value can be converted to a number, actually try to convert it to a number.***

---

I went back and did some research for _why_ a whitespace string did not have the expected output, and I think I get it now: an empty string is coerced to `0` rather than `NaN`. Simply trimming the string before the length check will handle this case. Note that I opted for a regex-based trim rather than the .trim() function in order to support IE8. About this time next year when Windows XP is no longer supported I'll come back and update it to use the .trim() function (and remove these two sentences... if I remember).

Running the unit tests against the new code and it only fails on the infinity and boolean literals, and the only time that should be a problem is if you're generating code (really, who would type in a literal and check if it's numeric? You should _know_), and that would be some strange code to generate.

But, again, **the only reason ever to use this is if for some reason you have to avoid isNaN().**