I want to parse a user input which contains longitude and latitude. What I want to do is to coerce a string to a number, preserving its sign and decimal places. But what I want to do is to display a message when user's input is invalid. Which one should I follow
parseFloat(x)
second
new Number(x)
third
~~x
fourth
+x
I'd use Number(x), if I had to choose between those two, because it won't allow trailing garbage. (Well, it "allows" it, but the result is a NaN.)
That is, Number("123.45balloon") is NaN, but parseFloat("123.45balloon") is 123.45 (as a number).
As Mr. Kling points out, which of those is "better" is up to you.
edit — ah, you've added back +x and ~~x. As I wrote in a comment, +x is equivalent to using the Number() constructor, but I think it's a little risky because of the syntactic flexibility of the + operator. That is, it'd be easy for a cut-and-paste to introduce an error. The ~~x form is good if you know you want an integer (a 32-bit integer) anyway. For lat/long that's probably not what you want however.
+x?
Number() but personally I would stay away from it as it's "syntactically fragile" (I just made that term up). That's just me being paranoid however.
+ :) The behaviour is well defined but it might not be obvious to everyone what it means/does (similar to ~~).+ is so crazy. Just a personal quirk I guess.
+ is the speed, as is shown in my answer's link.The first one is better. It is explicit, and it is correct. You said you want to parse floating point numbers. ~~x will give you an integer.
~~x limit the readability of your code and should be avoided unless you're really tight on space for some reason (like a short JavaScript coding compo). And in your case ~~x is not even a valid solution because it gives you an integer.
~~ is not confusing? I guess "confusing" depends on the developer...parseFloat() is that it ignores non-numeric characters after the number. Thus a string that starts with digits but then ends with random other characters can still be parsed, and it won't be a NaN. For some applications that may be OK of course.parseFloat("-42.42")+x is shorter and there's nothing wrong with using it. (Using it in parentheses (+x) would solve the syntax issue anyway, and that's still shorter than Number(x) :-)To test whether input is number, use this:
function isNumeric(obj){
return !isNaN( parseFloat(obj) ) && isFinite( obj );
}
To cast String to Number, use + ,it's the fastest method:
the unary + operator also type-converts its operand to a number and because it does not do any additional mathematical operations it is the fastest method for type-converting a string into a number
So overall, probably you need this:
if(!isNumeric(inputValue)){
alert('invalid number');
}else{
var num = +inputValue;
}
isNumeric borrowed from jQuery
isNumeric test, the efficiency of +x will become moot :) Maybe a isNaN(num) check after the conversion is better.isNaN), what I have posted is already proved.So I will choose the reliable way.This is the code I would write to repeatedly take input until the correct one is obtained.
var d;
do {
d = prompt("Enter a number");
d = new Number(d);
} while( isNaN(d) );
document.write( d );
Note: new Number(d) will always give NaN if any character is non-numeric while parseFloat(d) will ignore trailing invalid characters.
new Number(), if any, useNumber(). It depends on what kind of input you consider is valid. E.g.parseFloatwill accept"123foo"and return123butNumber(or the unary+) will returnNaN.Number()constructor as a plain function though.