¿Por qué Javascript usa JSON.stringify en lugar de JSON.serialize?

Me pregunto sobre "stringify" vs "serialize" . Para mí son lo mismo (aunque podría estar equivocado), pero en mi experiencia pasada (principalmente con asp.net ) uso Serialize()y nunca uso Stringify().

Sé que puedo crear un alias simple en Javascript,

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

// or
JSON.serialize = JSON.stringify;

http://jsfiddle.net/HKKUb/

pero me pregunto sobre la diferencia entre los dos y por qué se eligió stringify.

para fines de comparación, así es como serializa XML a una cadena 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();
}

Eche un vistazo más de cerca a los dos comentarios que ha puesto sobre la pregunta:

Supongo que después de volver a leer mi pregunta, veo que en mi ejemplo de C #, estoy serializando el XML y ENTONCES convirtiendo el objeto serializado ToString () ;. Ahí está el roce.

y

Supongo que para la continuidad, sería mejor (para mí) tener un método que se vea así ... JSON.serialize (obj) .toString (); o jsonObject (). toString (); ... de esta manera se parecería mucho a mi C # ... pero ahora estoy más complicada.

Ahora recuerde que en Javascript, un objeto es un hash (más bien, si usa Prototype u otro marco, debe calificarse como un "tipo especial de hash", pero la forma simple funciona para este ejemplo):

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 única razón por la que serialize()puede ser necesario en Javascript es para cortar las funciones, referencias a otros objetos, etc.

Entonces, para volver a su ejemplo de C #, acabamos de eliminarlo .Serialize()como innecesario. Un objeto es un hash, ya está serializado, de todos modos la "serialización" adicional debería realizarse manualmente en su propio código. Todo lo que te deja es .ToString().

¿Tiene .stringify()más sentido ahora?

Esto se debe a que la notación JSON se especificó en 1999, no después de 2002 ( asp.netse lanzó en ese año). así que supongo que no sabían sobre el serialize.

Bromas aparte,

Al escuchar la palabra serialization, lo primero que me viene a la mente es como convertir los datos a bytes, aquí JSON.stringify tiene mucho sentido ya que convierte el objeto en una representación de cadena, no en una representación de bytes.

PD:

@Chase Florell, no puede simplemente agregar JSON.serialize, ya que en modo estricto, este código puede fallar en algunos navegadores.

como JSONno es tu objeto promedio.