Difference Between String() And New String() In Javascript

In JavaScript is there any difference between using String() and new String()? console.log(String('word')); // word console.log(new String('word')); // word

Solution 1:

Using the String() constructor withoutnew gives you the string (primitive) value of the passed parameter. It's like boxing the parameter in a native object if necessary (like a Number or Boolean), and then calling .toString() on it. (Of course if you pass a plain object reference it just calls .toString() on that.)

Calling new String(something) makes a String instance object.

The results look the same via console.log() because it'll just extract the primitive string from the String instance you pass to it.

So: just plain String() returns a string primitive. new String(xyz) returns an object constructed by the String constructor.

It's rarely necessary to explicitly construct a String instance.

Solution 2:

String() returns a string primitive and new String() returns a Object String. This has some real consequences for your code.

1. Using String() returns 'true' with other primitives both with == and === operator.
2. Using String() gives you a primitive so it cannot use the "instanceOf" method to check its type. You can check only value type with "typeof" operator
3. Using new String() with "instanceOf" method with String or Object prototypes - both assert to true.
4. Using new String() will return 'true' with string primitives only by calling valueOf() method. String() has also this method and returns true when compared to string of the same value.
5. Using new String() allows you to add some other properties and methods to the Object to allow more complex behaviour.

From my coding experience you should avoid using new String() if you have no need for adding special methods to your String Object.

var x = String('word');
    console.log(typeof x); // "string"var y = newString('word');
    console.log(typeof y); // "object"// compare two objects !!!console.log(newString('') === newString('')) // false!!!// compare with string primitiveconsole.log('' == String('')) // trueconsole.log('' === String('')) // true//compare with string Objectconsole.log('' == newString('')) // true//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!console.log('' === newString('')) // false !!!!//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// instance of behaviorconsole.log(x instanceofString); // falseconsole.log(x instanceofObject); // false// please note that only new String() is a instanceOf Object and Stringconsole.log(y instanceofString); // trueconsole.log(y instanceofObject); // true//valueOf behaviorconsole.log('word' == x.valueOf()); // trueconsole.log('word' === x.valueOf()); // trueconsole.log('word' == y.valueOf()); // trueconsole.log('word' === y.valueOf()); // true//create smart stringvar superString = newString('Voice')
    superString.powerful = 'POWERFUL'String.prototype.shout = function () {
        return`${this.powerful}${this.toUpperCase()}`
    };

    console.log(superString.shout()) //"POWERFUL VOICE"

Solution 3:

Strings returned from String calls in a non-constructor context (i.e., without using the new keyword) are primitive strings.

Strings created with new String() (constructor mode) is an object and can store property in them.

Demonstrating the difference:

var strPrimitive = String('word');
strPrimitive.prop = "bar";
console.log(strPrimitive.prop); // undefinedvar strObject = newString('word');
strObject.prop = "bar";
console.log(strObject.prop); // bar

Solution 4:

Here is an example in addition to the good answers already provided:

var x = String('word');
console.log(typeof x); // "string"var y = newString('word');
console.log(typeof y); // "object"

The exact answer to your question is here in the documentation.

String literals (denoted by double or single quotes) and strings returned from String calls in a non-constructor context (i.e., without using the new keyword) are primitive strings.

Solution 5:

Generally it's not recommended to use constructor functions (i.e. using new keyword) because it can lead to unpredictable results.

For example:

if (newNumber(0)) { // console.log('It will be executed because object always treated as TRUE in logical contexts. If you want to treat 0 as falsy value then use Number(0)')
}

Also, as mentioned above, there is another potential problem:

typeof0; // numbertypeofNumber(0) // numbertypeofnewNumber(0) // object