new Number() vs Number()

What is the difference between new Number() and Number()? I get that new Number() creates a Number object and Number() is just a function, but when should I call which, and why?

On a related note, Mozilla says:

Do not use a Boolean object to convert a non-boolean value to a boolean value. Instead, use Boolean as a function to perform this task.

x = Boolean(expression);     // preferred
x = new Boolean(expression); // don't use

Why is that? I thought the results were the same?



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
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:



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

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.


Recent Questions

Top Questions

Home Tags Terms of Service Privacy Policy DMCA Contact Us Javascript

©2020 All rights reserved.