Perché Javascript utilizza JSON.stringify invece di JSON.serialize?

Mi sto solo chiedendo "stringify" vs "serialize" . Per me sono la stessa cosa (anche se potrei sbagliarmi), ma nella mia esperienza passata (principalmente con asp.net ) uso Serialize()e non uso mai Stringify().

So di poter creare un semplice alias in Javascript,

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

// or
JSON.serialize = JSON.stringify;

http://jsfiddle.net/HKKUb/

ma mi sto solo chiedendo quale sia la differenza tra i due e perché sia ​​stato scelto stringify.

a scopo di confronto, ecco come serializzare XML su una stringa in 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();
}

Dai un'occhiata più da vicino ai due commenti che hai posto sulla domanda:

Suppongo che dopo aver riletto la mia domanda, sto vedendo che nel mio esempio C #, sto serializzando XML e POI convertendo l'oggetto serializzato ToString () ;. C'è dentro il problema.

e

Immagino per la continuità, sarebbe meglio (per me) avere un metodo che assomiglia a questo ... JSON.serialize (obj) .toString (); o jsonObject (). toString (); ... in questo modo sembrerebbe molto simile al mio C # ... ma ora sto complicando troppo.

Ora ricorda che in Javascript, un oggetto è un hash (piuttosto, se si utilizza Prototype o un altro framework, dovrebbe essere qualificato come "tipo speciale di hash" - ma il modulo semplice funziona per questo esempio):

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

L'unico motivo per cui serialize()potrebbe essere necessario in Javascript è tagliare le funzioni, i riferimenti ad altri oggetti, ecc.

Quindi, per tornare al tuo esempio C #, abbiamo appena ritagliato .Serialize()inutile. Un oggetto è un hash, è già serializzato, ulteriori "serializzazioni" dovrebbero comunque essere eseguite manualmente nel proprio codice. Tutto ciò che ti lascia è .ToString().

Ha .stringify()più senso ora?

Questo perché quella notazione JSON è stata specificata nel 1999 non dopo il 2002 ( asp.netè stata rilasciata in quell'anno). quindi immagino che non sapessero del serialize.

Scherzi a parte,

Sentendo la parola serialization, la prima cosa che mi viene in mente è come convertire i dati in byte, qui JSON.stringify ha perfettamente senso in quanto converte l'oggetto in una rappresentazione di stringa e non in una rappresentazione di byte.

PS:

@Chase Florell, non puoi semplicemente aggiungere JSON.serialize, come in modalità rigorosa, questo codice potrebbe non riuscire in alcuni browser.

come JSONnon è il tuo oggetto medio.