Pourquoi Javascript utilise-t-il JSON.stringify au lieu de JSON.serialize?

Je me demande simplement "stringifier" vs "sérialiser" . Pour moi, c'est la même chose (même si je peux me tromper), mais dans mon expérience passée (principalement avec asp.net ), j'utilise Serialize()et je n'utilise jamais Stringify().

Je sais que je peux créer un alias simple en Javascript,

// either
JSON.serialize = function(input) {
    return JSON.stringify(input);
};

// or
JSON.serialize = JSON.stringify;

http://jsfiddle.net/HKKUb/

mais je me demande juste la différence entre les deux et pourquoi stringify a été choisi.

à des fins de comparaison, voici comment sérialiser XML en une chaîne en C #

public static string SerializeObject<T>(this T toSerialize)
{
    XmlSerializer xmlSerializer = new XmlSerializer(toSerialize.GetType());
    StringWriter textWriter = new StringWriter();

    xmlSerializer.Serialize(textWriter, toSerialize);
    return textWriter.ToString();
}

Examinez de plus près les deux commentaires que vous avez mis sur la question:

Je suppose qu'après avoir relu ma question, je vois que dans mon exemple C #, je sérialise le XML et PUIS convertis l'objet sérialisé ToString () ;. Là se mêle le hic.

et

Je suppose que pour la continuité, il serait préférable (pour moi) d'avoir une méthode qui ressemble à ceci ... JSON.serialize (obj) .toString (); ou jsonObject (). toString (); ... de cette façon, cela ressemblerait beaucoup à mon C # ... mais maintenant je suis trop compliqué.

Souvenez-vous maintenant qu'en Javascript, un objet est un hachage (plutôt, si vous utilisez Prototype ou un autre framework, il devrait être qualifié de "type spécial de hachage" - mais le formulaire simple fonctionne pour cet exemple):

var obj = {
   foo: 1,
   bar: function() { console.log(this.foo); }
}
obj.foo; // 1
obj.bar; // function reference
obj.bar(); // function call
obj['foo']; // 1
obj['bar']; // function reference
obj['bar'](); // function call

La seule raison pour laquelle un serialize()code pourrait être nécessaire en Javascript est de supprimer les fonctions, les références à d'autres objets, etc.

Donc, pour revenir à votre exemple C # - nous venons de couper .Serialize()comme inutile. Un objet est un hachage, il est déjà sérialisé, une "sérialisation" supplémentaire devrait de toute façon être effectuée manuellement dans votre propre code. Tout ce qui vous laisse est .ToString().

Est- .stringify()ce plus logique maintenant?

Cela est dû au fait que la notation JSON a été spécifiée en 1999 et non après 2002 ( asp.netest publiée cette année-là). donc je suppose qu'ils ne connaissaient pas le serialize.

Blagues à part,

En entendant le mot serialization, la première chose qui me vient à l'esprit est comme la conversion des données en octets, ici JSON.stringify est parfaitement logique car il convertit l'objet en une représentation de chaîne et non une représentation d'octet.

PS:

@Chase Florell, vous ne pouvez pas simplement ajouter JSON.serialize, car en mode strict, ce code peut en fait échouer dans certains navigateurs.

comme ce JSONn'est pas votre objet moyen.