new Number() vs Number()

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:

+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

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.

case with instanceof

const a = new Number('123'); // a === 123 is false
const b = Number('123'); // b === 123 is true
a instanceof Number; // is true
b instanceof Number; // is false