¿Cuál es la diferencia entre String (valor) y value.toString ()

Javascript tiene muchos “trucos” en torno a los tipos y las conversiones de tipos, por lo que me pregunto si estos 2 métodos son iguales o si hay algún caso de esquina que los haga diferentes.

No son completamente iguales y, de hecho, el constructor String llamado como una función (su primer ejemplo), al final, llamará al toString método del objeto pasado, por ejemplo:

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

Por otro lado, si un identificador se refiere a null o undefinedno puedes usar el toString método, le dará una TypeError excepción:

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

los String constructor llamado como una función sería más o menos equivalente a:

value + '';

Las reglas de conversión de tipo de Objeto-a-Primitivo se describen detalladamente en la especificación, el [[DefaultValue]] operación interna.

Resumido brevemente, al convertir de Objeto-a-Cuerdase siguen los siguientes pasos:

1. Si está disponible, ejecute el toString método.
   • Si el result es un primitivodevolver resultde lo contrario vaya al Paso 2.
2. Si está disponible, ejecute el valueOf método.
   • Si el result es un primitivodevolver resultde lo contrario vaya al Paso 3.
3. Lanzar TypeError.

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

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
}

Si quieres saber más sobre este mecanismo te recomiendo mirar el ToPrimitive y el ToString operaciones internas.

También recomiendo leer este artículo:

• Conversiones de objeto a primitivo en JavaScript

value.toString() provocará un error si value es nulo o indefinido. String(value) no debe.

Por ejemplo:

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

fallará porque value == null.

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

debería mostrar un mensaje que dice “nulo” (o similar), pero no fallará.

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

Cuerda() [the constructor call] básicamente está llamando a la .Encadenar()

.Encadenar() y Cuerda() se puede llamar en valores primitivos (número, booleano, cadena) y básicamente no hará nada especial:

verdadero => ‘verdadero’

falso => ​​’falso’

17 => ’17’

‘hola’ => ‘hola’

Pero llamar a estas funciones en objetos es donde las cosas se ponen interesantes:

si el objeto tiene su propia función .toString(), se llamará cuando necesite que este objeto se trate como una cadena (explícita/implícitamente)

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 desea tratar este objeto como un número, debe tener un .valor de() función definida en él.

¿Qué pasa si tenemos ambos en un objeto?

si queremos tratar este objeto como una cadena => use .Encadenar()

si queremos tratar este objeto como un número => use .valor de()

¿Qué pasa si solo tenemos .valor de() definido?

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

Acabo de probar esto con ES6 y descubrí que para String() para mirar valueOf() dentro del objeto, el objeto tiene que tener toString() método. Si el objeto no tiene toString() luego vuelve la consola '[object Object]' independientemente de tener valueOf() O no. Así que en el primer “paso”, siempre tenemos que tener toString() independientemente, de lo contrario String() el método no miraría valueOf.

Por favor, chequee esto:

let obj = {
    name:'b',
    age:22,
    valueOf: function(){
        return 'heeee';
    }
}

String(obj); // prints '[object Object]'

Por otra parte,

let obj = {
    name:'b',
    age:22,
    toString:null,
    valueOf: function(){
        return 'heeee';
    }
}
String(obj); // prints 'heeee'

let obj = {
  name: 'b',
  age: 22,
  valueOf: function() {
    return 'heeee';
  }
}

console.log(String(obj));

let obj2 = {
  name: 'b',
  age: 22,
  toString: null,
  valueOf: function() {
    return 'heeee';
  }
}

console.log(String(obj2));