JSON.stringify sans les guillemets sur les propriétés?

Je suis en utilisant un service qui utilise le mauvais format JSON (pas de guillemets autour de propriétés). J'ai donc besoin d'envoyer

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

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

Quelqu'un connais un stringify de routage pour formater un objet JavaScript, comme ci-dessus?

InformationsquelleAutor jadent | 2012-06-27

javascript json

84
```
var json = '{ "name": "John Smith" }';       //Let's say you got this
json = json.replace(/\"([^(\")"]+)\":/g,"$1:");  //This will remove all the quotes
json;                                        //'{ name: "John Smith" }'
```
La regex va supprimer toutes les citations, et la chose la plus importante est, il n'a pas besoin d'une bibliothèque!

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" }'
```
Spécial merci à Rob W pour le fixer.

Mise à jour:

Dans la plupart des cas susmentionnés regexp va fonctionner, mais mathématiquement, il est impossible de décrire le format JSON avec une expression régulière telle qu'elle fonctionne dans tous les cas (en comptant le même nombre d'accolades est impossible avec des regexp.) Donc, j'ai créer une nouvelle fonction pour supprimer des citations officiellement l'analyse de la chaîne JSON via la fonction native et reserialize c':
```
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/

Noter que le code est écrit dans l'ES6 et peut nécessiter transpilation ou de traduction du manuel pour les anciens navigateurs.
- Le premier était bien, n'est-ce pas? var x = eval(str);
- Est revenue.
- D'où le -1 viennent de..? Comment est-ce pas une bonne réponse?
- Je ne sais pas.
- -1 n'était pas moi, je pense que cela peut effectivement être le seul moyen pour ce faire. Mais c'est une mauvaise pratique à utiliser eval (il échouera automatiquement jsLint). C'est probablement surtout d'une mauvaise pratique lorsque la chaîne eval avais provient d'un douteux source externe.
- -1 n'était pas moi non plus, mais vous devez lire attentivement la question. L'OP doit coder un objet (cassé) json, de ne pas analyser/évaluer.
- Oh! La fixation...
- Fixe.
- Cette méthode est pas fiable. Par exemple, prenez cette entrée: {"foo":"e\":bar"} (JSON valide) devient {foo:e:bar"} (...)!
- J'ai pensé à ça aussi. Pour le fixer, il suffit d'ajouter no \" in between the quotes à la regex
- Voir mise à jour.
- peut être simplifié à /\\"/. N'oubliez pas d'ajouter l'indicateur global, /\\"/g, ou il va se casser sur les cordes avec plusieurs \". Comme pour le caractère aléatoire, jamais utiliser un littéral U+FFFF, dans le cas où l'éditeur étouffe, mais une séquence d'échappement. La regex pour revenir deviendrait /\uFFFF/g.
- Derek c'est génial!!! Parce que maintenant, je n'ai pas besoin d'envoyer le devis sur le websocket pipe. Pouvez économiser une tonne de bande passante pour mon jeu, merci u sir!
- Notez que le + doit être remplacé par un * si vous souhaitez supprimer des citations de chaînes vides ""
- Cela va également supprimer les citations sur l'un des paramètres avec un point (par exemple: "adr.ville"), si ce n'est la totalité, de fonction correcte à mon humble avis: .replace(/\\"/g,"\uFFFF").remplacer(/\"([^(\"\.)"]+)\":/g,"$1:").replace( /,(\S)/g, ", $1").replace(/\uFFFF/g,"\\\"") (à noter que j'ai aussi ajouté un espace après les virgules pour des raisons de lisibilité - de le supprimer si vous avez besoin d' "stricte" de la vérité 😉
- votre regex /\"([^(\")"]+)\":/g peut être simplifié à /"([^"]+)":/g, voir regex101.com/r/qnz0ld/2
- il échoue si la valeur est null.
- Dans ce cas il suffit d'ajouter un contrôle supplémentaire pour les valeurs null.
- Il est possible de décrire l'ensemble du JSON de la grammaire comme une regex, voir cette réponse
InformationsquelleAutor Derek 朕會功夫
10

Il ressemble à ceci est une simple méthode toString de l'Objet que vous recherchez.

Dans Node.js ce problème est résolu en utilisant le menu util objet et l'appel util.inspecter(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 à la base un inspecteur d'objet, pas un JSON convertisseur. Format JSON spécifie que toutes les propriétés doivent être entourés de guillemets doubles. Donc il n'y aura pas de JSON convertisseurs de faire ce que vous voulez tant que ce n'est tout simplement pas un format JSON.Les Specs ici:
https://developer.mozilla.org/en-US/docs/Using_native_JSON

Objet string ou inspection est ce que vous avez besoin en fonction de la langue de votre serveur.
- Merci u tellement! C'est exactement ce que je cherchais. J'utilise json pour émettre des données sur le serveur ws à mon jeu et croyez-le ou pas, ne pas avoir à traiter avec le supplément de guillemets autour des noms de propriété enregistre une immense quantité de données! Juste pour clarifier, .toSource() fonctionne bien au sein de nodejs, mais ne fonctionne pas d'objets dans des tableaux. Le util inspecter les travaux pour les tableaux et les objets dans les tableaux de ce qui est merveilleux, l'amour.
- util.inspect() fonctionne simplement génial pour moi lors de l'écriture d'un objet dans un Neo4j requête, pour définir plusieurs paramètres à la fois.
- À partir de la nodejs lien: > Le menu util.inspecter() la méthode retourne une chaîne de caractères de la représentation de l'objet qui est destiné à des fins de débogage. La sortie de l'util.inspecter peuvent changer à tout moment et ne doit pas être tributaire de la programmation.
InformationsquelleAutor fino
5

Vous pouvez regarder le code source de json2.js ^{un analyseur créé par celui qui a défini le format JSON}. Recherchez quote appels de fonction: ces entourent une valeur entre guillemets. Les touches sont indiqués aux lignes Trois cent vingt six et Trois cent trente huit.

Ne pas inclure la bibliothèque après la modification. Au lieu de prendre uniquement les (stringify) une partie, ou au moins de remplacer JSON avec autre chose, par exemple. FAKEJSON.

Par exemple, un objet FAKEJSON qui défini stringify: http://jsfiddle.net/PYudw/
- Pourquoi auriez-vous besoin d'une aide supplémentaire bibliothèque de quand vous pouvez le faire en JavaScript?
- C'est une bonne idée. Je voudrais fourche le repo, supprimer les guillemets, et de renommer l'objet JSON à quelque chose facétieux comme FAILJSON de préciser que vous êtes pas travailler avec le réel de l'objet JSON, réels ou JSON.
- La bibliothèque ne doit pas être compris comme ensemble. Ne prendre que la JSON.stringify partie, et de supprimer les guillemets. Puisque la bibliothèque est créé par celui qui l'a défini JSON, nous pouvons être à peu près sûr que le résultat est très JSON valide.
- W - je vois.
- Il semble que ce soit la meilleure approche.
- Ouais, d'accord avec Derek. Bien que son remplacement qui fonctionne très bien, je me sens plus à l'aise avec crawford code, pas de manque de respect à derek lol. .toSource() fonctionne bien, mais n'inclut pas si votre objet est dans la gamme qui est une déception (et je suis sur le nœud de sorte navigateur compat n'est pas un problème :P) donc je vais utiliser cette méthode merci @RobW aussi, le jsfiddle lien semble être bloqué au chargement de la page 🙁
InformationsquelleAutor Rob W
4

Trouvé un bon MNP paackage pour faire juste cela:

https://www.npmjs.com/package/stringify-object
```
const stringify = require('stringify-object')

let prettyOutput = stringify(json);
```
Fonctionne assez bien.

InformationsquelleAutor user1543276
3

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

D'autre, fichier détail un rapport de bug, y compris une bonne argumentation pourquoi le devrait se conformer à la norme. Toute autre solution que d'éliminer la source du problème n'est pas de réelle solution.

Un quick-n-sale correctif pourrait être le tuyau de la chaîne à travers une regex avant de l'analyser:
```
var obj = JSON.parse(str.replace(/(\{|,)\s*(.+?)\s*:/g, '$1 "$2":'));
```
Ou vous essayez de régler un code javascript JSON parser (comme cette une) si vous voulez plus de syntaxe analyser.

InformationsquelleAutor Bergi
2

Votre hérité de la syntaxe devrait être facilement consommés par les YAML, qui est un sur-ensemble de JSON.

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

InformationsquelleAutor user1649339
0

CSVJSON de formatage automatique de la requête JSON a une option pour déplacer les citations sur les touches. Si vous voulez juste le code, vous pouvez le copier depuis le dépôt GitHub. Je modifié Douglas Crockford de JSON2 pour ajouter le support pour que.
- Juste cliqué sur csvjson.com/json_beautifier et a obtenu une manière différente de celle que j'attendais... hacked by AnoaGhost
- Nettoyer jusqu'à maintenant. Désolé pour la gêne occasionnée.
InformationsquelleAutor Martin Drapeau

@Derek朕會功夫 Merci pour le partage de cette méthode, je souhaitez partager mon code qui prend en charge stringifying 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"){
        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(",")
            }}`;
};

Vous devez utiliser JSON.stringify pour instanceof Date trop. Également de retour 'null' si obj_from_json est null.

InformationsquelleAutor Adel Bachene

Vous devez vous connecter pour publier un commentaire.