Cuál es la diferencia entre String (value) vs value.toString()

Question

Javascript tiene muchos "trucos" sobre los tipos y las conversiones de tipo, así que me pregunto si estos 2 métodos son iguales o si hay algún caso de esquina que haga ellos diferentes?

Answer 1

Ellos no son del todo la misma, y, de hecho, the String constructor called as a function (el primer ejemplo), será al final, llame al método toString del objeto pasado, por ejemplo:

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

Por otro lado, Si un identificador hace referencia a null o undefined, no se puede utilizar, evidentemente, el método toString, se le dará un TypeError excepción:

var value = null; 
String(null); //  "null" 
value.toString(); // TypeError 

El constructor String llamado como una función sería aproximadamente equivalente a:

reglas de conversión

value+''; 

El tipo de Objeto -a-- Primitive están detalladas descritas en la especificación, el funcionamiento interno [[DefaultValue]].

En un breve, cuando se convierte de Objeto -a-- cadena, se toman los pasos siguientes:

1. Si está disponible, ejecute el método toString.
   • Si el result es no una primitiva, vaya al paso 2, de lo contrario devolver el result
2. Si está disponible, ejecute el método valueOf.
   • Si el resultes una primitiva, volver result, de lo contrario Paso 3.
3. Throw TypeError.

Dadas las reglas anteriores, podemos hacer un ejemplo de la semántica involucrados:

var o = { 
    toString:function() { return "foo"; }, 
    valueOf: function() { return "bar"; } 
}; 

String(o); // "foo" 

// Make the toString method unavailable: 
o.toString = null; 

String(o); // "bar" 

// Now make the valueOf method also unavailable: 
o.valueOf = null; 

try { 
    String(o); 
} catch (e) { 
    alert(e); // TypeError! 
} 

Si desea digg-en más en este mecanismo le recomiendo que para dar un vistazo a la ToPrimitive y las operaciones internas ToString.

También te recomendaría este artículo:

• Object-to-Primitive Conversions in JavaScript

Answer 2

value.toString() causará un error si value es nulo. String(value) no debería.

Por ejemplo:

var value = null; 
alert(value.toString()); 

fallará porque value == null.

var value = null; 
alert(String(value)); 

debe mostrar un mensaje que dice "nulo" (o similar), pero no se bloqueará.

Answer 3

String(value) deberían tener el mismo resultado que value.toString() en todos los casos, excepto para los valores sin propiedades como null o undefined. ''+value producirá el mismo resultado.

Answer 4

String() [la llamada de constructor ] es básicamente llamando a la .toString()

.toString() y String() puede ser llamado en los valores primitivos (número, booleano, string) y básicamente va a hacer nada especial:

cierto => 'verdadera'

falsa => 'falsa'

17 => '17'

'hola' => 'hola'

Pero llamar a estas funciones en los objetos es donde las cosas se pone interesante:

si el objeto tiene su función propia .toString() será llamada cuando cada vez que necesita este objeto a ser tratado como una cadena (de forma explícita/implícita)

let obj = { 
      myName:"some object", 
      toString:function(){ return this.myName; } 
      } 

//implicitly treating this obj as a string 
"hello " + obj; //"hello some object" 

//OR (explicitly) 
"hello " + String(obj) //calling the existent toString function 

//OR 
"hello " + obj.toString(); //calling toString directly 

Por cierto, si usted quiere tratar este objeto como un número que debería tiene una función .valueOf() definido en ella.

¿qué pasa si tenemos ambos en un objeto?

si queremos tratar este objeto como una cadena => utilizar .toString()

si queremos tratar este objeto como un número => utilizar .valueOf()

¿qué ocurre si solo tenemos .valueOf() definido?

.valueOf() definido dentro del objeto se llamará si queremos manejar el objeto como una cadena o como un número