Is there any difference in creating string object

Question

What is the difference between creating a string object like this

var txt = new String("Hello World");

and this

var txt = "Heloo World";

Answer 1

First of all let's bust some myths. String literal is not a syntactic sugar.

> var txt = new String("Hello World");
> typeof x
"string"
> var txt2 = "Hello World";
> typeof txt2
"object"

As you can see these two things are of different type. Even more: one of them is object and the second is not. This has a practical consequence, like:

> new String("Hello World") == new String("Hello World")
false
> "Hello World" == "Hello World"
true

Another difference is that primitives are passed by value while objects by reference. This might save some memory if you are passing around lots of big strings. However both objects and literals are immutable so it really isn't a big deal (why would you pass lots of big strings if you're not going to modify them?).

Also you can add attributes to objects while you can't add them to primitive types. But that's not 100% true. You can add an attribute to the prototype of a primitive. Note that both literals and objects have the same prototype:

> String.prototype.test = 11;
> var x = new String("x");
> x.test;
11
> var y = "x":
> y.test;
11

Answer 2

There's very little practical use for String objects as created by new String("foo"). The only advantage a String object has over a primitive string value is that as an object it can store properties:

var str = "foo";
str.prop = "bar";
alert(str.prop); // undefined

var str = new String("foo");
str.prop = "bar";
alert(str.prop); // "bar"

Hope this helps..

Answer 3

The String constructor function returns an object of type String. Usually, you want a literal string value, because strictly comparing an object to a literal will always return false.

Answer 4

One is a string primitive and the other is a String object. The advantage of String object over string primitive is that it can store properties

var x = "foobar"
x.y = "hello"
console.log(x.hello) /* Undefinded*/

var z = new String("foobar")
z.y = "hello"
console.log(z.y) /* hello*/

typeof x = "string"
typeof z = object.

also

x==z //true
x===z // false

Answer 5

Nothing much but beware of this,

var s = new String('A');
var s1 = String('A');
var s2 = 'A';


console.log(s === 'A');//fasle -- since type is Object
console.log(s1 === 'A');//true
console.log(s2 === 'A');//true

Answer 6

The first returns a String object, the second returns a string.

typeof txt; //object
typeof txt2; //string

While they may act similar, txt !== txt2

Answer 7

var txt = "Heloo World";

here 'txt' is a primitive data type. It has no methods, it is nothing more than a pointer to a raw data memory reference, which explains the much faster random access speed.

var txt = new String("Hello World");

If you use new, you're explicitly stating that you want to create an instance of an Object. Therefore, new String is producing an Object wrapping the String primitive, which means any action on it involves an extra layer of work.

Answer 8

The primitive data types are:

• String
• Number
• Boolean

If you using:

var txt = "Heloo World";

this is primitive type data type alert(typeof txt); will give you string type.

In JavaScript all variable can be of object type, for each primitive their is a Object type.

var txt = new String("Heloo World");

here typeof will give you object.

For difference see jsfiddle

var str="text"; 
alert(typeof str);     //string

var str2="text";
alert(str === str2);   //true

str = new String("text changed");
alert(typeof str);     //object

var str2 = new String("text changed");
alert(str === str2);   //false

Answer 9

Nothing, really. In the first example you call the constructor of class String and put as a parameter the body of the string, where as in the second example it is done automatically at the interpretation phase.

So basically the second is syntactic sugar, where as the first isn't.

There is no difference in the functionality.