They are not completely the same, and actually, the String constructor called as a function (your first example), will at the end, call the toString method of the object passed, for example:

var o = { toString: function () { return foo; } };

String(o); // foo

On the other hand, if an identifier refers to null or undefined, you can't use the toString method, it will give you a TypeError exception:

var value = null;

String(null);     // null

value.toString(); // TypeError

The String constructor called as a function would be roughly equivalent to:

value + '';

The type conversion rules from Object-to-Primitive are detailed described on the specification, the [[DefaultValue]] internal operation.

Briefly summarized, when converting from Object-to-String, the following steps are taken:

1. If available, execute the toString method.
   
   
   
   
   • If the result is a primitive, return result, else go to Step 2.
   
   


2. If available, execute the valueOf method.
   
   
   
   
   • If the result is a primitive, return result, else go to Step 3.
   
   


3. Throw TypeError.

Given the above rules, we can make an example of the semantics involved:

var o = {

  toString: function () { return foo; },

  valueOf:  function () { return bar; }

};



String(o); // foo



// Make the toString method unavailable:

o.toString = null;



String(o); // bar



// Also make the valueOf method unavailable:

o.valueOf = null;



try { 

  String(o); 

} catch (e) {

  alert(e); // TypeError

}

If you want to know more about this mechanism I would recommend looking at the ToPrimitive and the ToString internal operations.

I also recommend reading this article:

• Object-to-Primitive Conversions in JavaScript