Quelle est la différence entre String (value) et value.toString ()

Javascript a beaucoup de "trucs" autour des types et des conversions de type donc je me demande si ces 2 méthodes sont les mêmes ou s'il y a un cas de coin qui les rend différentes?

Ils ne sont pas tout à fait les mêmes, et en fait, le constructeur String appelé en tant que fonction (votre premier exemple), appellera à la fin la toStringméthode de l'objet passé, par exemple:

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

En revanche, si un identifiant fait référence à nullou undefined, vous ne pouvez pas utiliser la toStringméthode, il vous donnera une TypeErrorexception :

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

Le Stringconstructeur appelé en tant que fonction serait à peu près équivalent à:

value + '';

Les règles de conversion du type objet -à- primitif sont détaillées décrites sur le cahier des charges, le [[DefaultValue]]fonctionnement interne.

En bref, lors de la conversion d' Object- to- String , les étapes suivantes sont suivies :

1. Si disponible, exécutez la toStringméthode.
   • Si le resultest une primitive , retournez result, sinon passez à l'étape 2.
2. Si disponible, exécutez la valueOfméthode.
   • Si le resultest une primitive , retournez result, sinon passez à l'étape 3.
3. Jetez TypeError.

Compte tenu des règles ci-dessus, nous pouvons faire un exemple de la sémantique impliquée:

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 vous voulez en savoir plus sur ce mécanisme, je vous recommande de regarder le ToPrimitiveet les ToStringopérations internes.

Je recommande également de lire cet article:

• Conversions d'objet à primitif en JavaScript

value.toString()provoquera une erreur si valueest nul. String(value)ne devrait pas.

Par exemple:

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

échouera parce que value == null.

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

devrait afficher un message indiquant "null" (ou similaire), mais il ne plantera pas.

String(value)devrait avoir le même résultat que value.toString()dans tous les cas, sauf pour les valeurs sans propriétés comme nullou undefined. ''+valueproduira le même résultat.

String () [l' appel du constructeur ] appelle essentiellement le .toString ()

.toString () et String () peuvent être appelés sur des valeurs primitives (nombre, booléen, chaîne) et ne feront rien de spécial:

true => 'vrai'

false => 'faux'

17 => '17'

'hello' => 'bonjour'

Mais appeler ces fonctions sur des objets est là où les choses deviennent intéressantes:

si l'objet a sa propre fonction .toString (), il sera appelé chaque fois que vous aurez besoin que cet objet soit traité comme une chaîne (explicitement / implicitement)

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

Au fait, si vous voulez traiter cet objet comme un nombre, il devrait y avoir une fonction .valueOf () définie.

et si nous avons les deux dans un seul objet?

si nous voulons traiter cet objet comme une chaîne => utilisez .toString ()

si nous voulons traiter cet objet comme un nombre => utilisez .valueOf ()

Et si nous n'avions défini que .valueOf () ?

.valueOf () défini à l'intérieur de l'objet sera appelé si nous voulons traiter l'objet sous forme de chaîne ou de nombre