Sto utilizzando un servizio che utilizza un formato JSON errato (senza virgolette doppie attorno alle proprietà). Quindi devo inviare

{ name: "John Smith" } invece di { "name": "John Smith" }

Questo formato non può essere modificato perché non è il mio servizio.

Qualcuno sa di un routing stringify per formattare un oggetto JavaScript come sopra?

Questa semplice soluzione di espressioni regolari funziona per deselezionare i nomi delle proprietà JSON nella maggior parte dei casi:

const object = { name: 'John Smith' };
const json = JSON.stringify(object);  // {"name":"John Smith"}
console.log(json);
const unquoted = json.replace(/"([^"]+)":/g, '$1:');
console.log(unquoted);  // {name:"John Smith"}

Caso estremo:

var json = '{ "name": "J\\":ohn Smith" }'
json.replace(/\\"/g,"\uFFFF");  // U+ FFFF
json = json.replace(/"([^"]+)":/g, '$1:').replace(/\uFFFF/g, '\\\"');
// '{ name: "J\":ohn Smith" }'

Un ringraziamento speciale a Rob W per averlo riparato.

Limitazioni

In casi normali la summenzionata regexp funzionerà, ma matematicamente è impossibile descrivere il formato JSON con un'espressione regolare tale che funzioni in ogni singolo caso (contare lo stesso numero di parentesi graffe è impossibile con regexp.) Pertanto, ho creare una nuova funzione per rimuovere le virgolette analizzando formalmente la stringa JSON tramite la funzione nativa e riserializzandola:

function stringify(obj_from_json) {
    if (typeof obj_from_json !== "object" || Array.isArray(obj_from_json)){
        // not an object, stringify using native function
        return JSON.stringify(obj_from_json);
    }
    // Implements recursive object serialization according to JSON spec
    // but without quotes around the keys.
    let props = Object
        .keys(obj_from_json)
        .map(key => `${key}:${stringify(obj_from_json[key])}`)
        .join(",");
    return `{${props}}`;
}

Esempio: https://jsfiddle.net/DerekL/mssybp3k/

Sembra che questo sia un semplice metodo Object toString che stai cercando.

In Node.js questo viene risolto utilizzando l'oggetto util e chiamando util.inspect (yourObject). Questo ti darà tutto ciò che desideri. seguire questo collegamento per ulteriori opzioni, inclusa la profondità dell'applicazione del metodo. http://nodejs.org/api/util.html#util_util_inspect_object_options

Quindi, quello che stai cercando è fondamentalmente un ispettore di oggetti non un convertitore JSON. Il formato JSON specifica che tutte le proprietà devono essere racchiuse tra virgolette doppie. Quindi non ci saranno convertitori JSON per fare quello che vuoi in quanto semplicemente non è un formato JSON.Specs qui: https://developer.mozilla.org/en-US/docs/Using_native_JSON

Oggetto da stringa o ispezione è ciò di cui hai bisogno a seconda della lingua del tuo server.

Puoi guardare il codice sorgente di ^{un parser creato da colui che ha definito il formato JSON} . Cerca le chiamate di funzione: racchiudono un valore tra virgolette. Le chiavi sono citate alle righe 326 e 338json2.js quote .

Non includere la libreria dopo la modifica. Invece prendi solo la parte rilevante ( stringify), o almeno sostituisci JSONcon qualcos'altro, ad es.FAKEJSON.

Ad esempio, un oggetto FAKEJSONche ha definito solo stringify: http://jsfiddle.net/PYudw/

Prova a utilizzare il servizio con JSONP, immagino che lo offrano quando si utilizza questo formato.

Altrimenti, inviagli un rapporto dettagliato sui bug che includa una buona argomentazione sul perché dovrebbe essere conforme allo standard. Qualsiasi altra soluzione che eliminare il problema di origine non è una vera soluzione.

Una soluzione rapida e sporca potrebbe essere quella di collegare la stringa attraverso una regex prima di analizzarla:

var obj = JSON.parse(str.replace(/(\{|,)\s*(.+?)\s*:/g, '$1 "$2":'));

Oppure provi a modificare un parser JSON javascript esistente (come questo ) se desideri un'analisi più sintattica.

Ho trovato un buon pacchetto NPM per fare proprio questo:

https://www.npmjs.com/package/stringify-object

const stringify = require('stringify-object')

let prettyOutput = stringify(json);

Funziona abbastanza bene.

La sintassi ereditata dovrebbe essere facilmente mangiata da YAML, che è un superset di JSON.

Prova il parser e il dumper YAML JavaScript: http://nodeca.github.com/js-yaml/

@Derek 朕 會 功夫 Grazie per aver condiviso questo metodo, mi piacerebbe condividere il mio codice che supporta anche la stringa di un array di oggetti.

export const stringifyObjectWithNoQuotesOnKeys = (obj_from_json) => {
    // In case of an array we'll stringify all objects.
    if (Array.isArray(obj_from_json)) {
        return `[${
                    obj_from_json
                        .map(obj => `${stringifyObjectWithNoQuotesOnKeys(obj)}`)
                        .join(",")
                }]` ;
    }
    // not an object, stringify using native function
    if(typeof obj_from_json !== "object" || obj_from_json instanceof Date || obj_from_json === null){
        return JSON.stringify(obj_from_json);
    }
    // Implements recursive object serialization according to JSON spec
    // but without quotes around the keys.
    return `{${
            Object
                .keys(obj_from_json)
                .map(key => `${key}:${stringifyObjectWithNoQuotesOnKeys(obj_from_json[key])}`)
                .join(",")
            }}`;
};

Uso JSON5.stringify

JSON5 è un superset di JSON che consente la sintassi ES5, comprese le chiavi di proprietà non quotate . L'implementazione di riferimento JSON5 ( json5pacchetto npm ) fornisce un JSON5oggetto che ha gli stessi metodi con gli stessi argomenti e la stessa semantica JSONdell'oggetto incorporato .

È molto probabile che il servizio che stai utilizzando utilizzi questa libreria.

Il Beautifier JSON di CSVJSON ha un'opzione per rilasciare le virgolette sulle chiavi. Se vuoi solo il codice, puoi copiarlo dal repository GitHub. Ho modificato JSON2 di Douglas Crockford per aggiungere il supporto per questo.