J'utilise un service qui utilise un format JSON incorrect (pas de guillemets doubles autour des propriétés). Alors j'ai besoin d'envoyer

{ name: "John Smith" } au lieu de { "name": "John Smith" }

Ce format ne peut pas être modifié car ce n'est pas mon service.

Quelqu'un connaît-il un routage stringify pour formater un objet JavaScript comme ci-dessus?

Cette solution d'expression régulière simple fonctionne pour décompresser les noms de propriété JSON dans la plupart des cas:

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"}

Cas extrême:

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 merci spécial à Rob W pour l'avoir réparé.

Limites

Dans des cas normaux, l'expression rationnelle susmentionnée fonctionnera, mais mathématiquement, il est impossible de décrire le format JSON avec une expression régulière telle qu'elle fonctionnera dans tous les cas (compter le même nombre d'accolades est impossible avec l'expression rationnelle). Par conséquent, j'ai créer une nouvelle fonction pour supprimer les guillemets en analysant formellement la chaîne JSON via la fonction native et la resérialiser:

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}}`;
}

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

Il semble que ce soit une méthode Object toString simple que vous recherchez.

Dans Node.js, cela est résolu en utilisant l'objet util et en appelant util.inspect (yourObject). Cela vous donnera tout ce que vous voulez. suivez ce lien pour plus d'options, y compris la profondeur de l'application de la méthode. http://nodejs.org/api/util.html#util_util_inspect_object_options

Donc, ce que vous recherchez est essentiellement un inspecteur d'objets et non un convertisseur JSON. Le format JSON spécifie que toutes les propriétés doivent être placées entre guillemets. Par conséquent il n'y aura pas de convertisseurs JSON pour faire ce que vous voulez que cela est tout simplement pas un JSON format.Specs ici: https://developer.mozilla.org/en-US/docs/Using_native_JSON

Objet à chaîne ou inspection est ce dont vous avez besoin en fonction de la langue de votre serveur.

Vous pouvez consulter le code source d' ^{un analyseur créé par celui qui a défini le format JSON} . Recherchez les appels de fonction: ceux-ci entourent une valeur entre guillemets. Les clés sont citées aux lignes 326 et 338 .json2.js quote

N'incluez pas la bibliothèque après la modification. Au lieu de cela, prenez uniquement la partie pertinente ( stringify), ou au moins remplacez-la JSONpar autre chose, par exemple. FAKEJSON.

Par exemple, un objet FAKEJSONqui ne définit que stringify: http://jsfiddle.net/PYudw/

Essayez d'utiliser le servive avec JSONP, je suppose qu'ils l'offrent lors de l'utilisation de ce format.

Sinon, déposez-leur un rapport de bogue détaillé comprenant une bonne argumentation pour expliquer pourquoi le devrait être conforme à la norme. Toute autre solution que l'élimination du problème source n'est pas une vraie solution.

Une solution rapide et sale pourrait être de diriger la chaîne à travers une expression régulière avant de l'analyser:

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

Ou vous essayez d'ajuster un analyseur javascript JSON existant (comme celui-ci ) si vous voulez une analyse plus syntaxique.

J'ai trouvé un bon paquet NPM pour faire exactement cela:

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

const stringify = require('stringify-object')

let prettyOutput = stringify(json);

Fonctionne plutôt bien.

Votre syntaxe héritée devrait être facilement mangée par YAML, qui est un sur-ensemble de JSON.

Essayez l'analyseur et le dumper JavaScript YAML: http://nodeca.github.com/js-yaml/

@Derek 朕 會 功夫 Merci d'avoir partagé cette méthode, j'aime partager mon code qui prend également en charge la stringification d'un tableau d'objets.

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(",")
            }}`;
};

Utilisation JSON5.stringify

JSON5 est un sur-ensemble de JSON qui autorise la syntaxe ES5, y compris les clés de propriété sans guillemets . L'implémentation de référence JSON5 ( json5package npm ) fournit un JSON5objet qui a les mêmes méthodes avec les mêmes arguments et sémantique que l' JSONobjet intégré .

Il est fort probable que le service que vous utilisez utilise cette bibliothèque.

JSON Beautifier de CSVJSON a une option pour déposer des citations sur les clés. Si vous ne voulez que le code, vous pouvez le copier à partir du dépôt GitHub. J'ai modifié le JSON2 de Douglas Crockford pour ajouter un support pour cela.