new Number() vs Number()
Always worth consulting the spec; from Section 15.7.1:
When
Number
is called as a function rather than as a constructor, it performs a type conversion.
Similarly, using Boolean
as a function (15.6.1):
When Boolean is called as a function rather than as a constructor, it performs a type conversion.
...which means that you consult Section 9.2 ("ToBoolean"):
The abstract operation ToBoolean converts its argument to a value of type Boolean according to Table 11:
Undefined
=false
Null
=false
Boolean
= The result equals the input argument (no conversion).Number
= The result is false if the argument is +0, −0, or NaN; otherwise the result is true.String
= The result is false if the argument is the empty String (its length is zero); otherwise the result is true.Object
=true
The difference between new Boolean(value)
and Boolean(value)
is basically that the former returns an object, but the latter returns a primitive per the above. This matters, because objects are truthy:
var b = new Boolean(false);
display(b); // Displays "false"
if (b) {
display("true"); // This is the path that gets taken, displaying "true"
}
else {
display("false"); // This path does NOT get taken
}
Live example ...whereas you almost always want booleans for the purpose of testing them.
new Number( x )
creates a new wrapper object. I don't think that there is a valid reason to ever use this.
Number( x )
converts the passed argument into a Number value. You can use this to cast some variable to the Number type. However this gets the same job done:
+x
Generally:
You don't need those:
new Number()
new String()
new Boolean()
You can use those for casting:
Number( value )
String( value )
Boolean( value )
However, there are simpler solutions for casting:
+x // cast to Number
'' + x // cast to String
!!x // cast to Boolean
Boolean(expression)
will simply convert the expression into a boolean primitive value, while new Boolean(expression)
will create a wrapper object around the converted boolean value.
The difference can be seen with this:
// Note I'm using strict-equals
new Boolean("true") === true; // false
Boolean("true") === true; // true
And also with this (thanks @hobbs):
typeof new Boolean("true"); // "object"
typeof Boolean("true"); // "boolean"
Note: While the wrapper object will get converted to the primitive automatically when necessary (and vice versa), there is only one case I can think of where you would want to use new Boolean
, or any of the other wrappers for primitives - if you want to attach properties to a single value. E.g:
var b = new Boolean(true);
b.relatedMessage = "this should be true initially";
alert(b.relatedMessage); // will work
var b = true;
b.relatedMessage = "this should be true initially";
alert(b.relatedMessage); // undefined