Modo corretto di gestire le variazioni nella serializzazione JSON

Question

Ho un servizio web che utilizza SimpleJSON di Python per serializzare JSON e un javascript / client che utilizza la visualizzazione di Google API . Quando provo a leggere la risposta JSON utilizzando il metodo Query di Google Data Table, ricevo un'etichetta "non valida" errore.

Ho notato che il foglio di calcolo di Google genera JSON senza virgolette attorno alle chiavi dell'oggetto. Ho provato a leggere in JSON senza le virgolette e funziona. Mi chiedevo quale fosse il modo migliore per leggere l'output di SimpleJSON su Google Datable usando

query = new google.visualization.Query (" http: //www.myuri.com/api/") .

Potrei usare una regex per rimuovere le virgolette, ma sembra sciatto. Le librerie di analisi JSON javascript che ho provato non leggeranno nella sintassi JSON senza virgolette attorno alle chiavi dell'oggetto.

Ecco alcune buone letture di sfondo relative a: virgolette attorno alle chiavi dell'oggetto:

http://simonwillison.net/2006/Oct/11/json/.

Answer 1

Sei sicuro che l'API di Google si aspetta JSON? Nella mia esperienza, le API di Google tendono a non essere massicciamente interrotte nel modo che stai descrivendo: potrebbe essere che si aspettino in realtà un formato diverso che assomiglia semplicemente a JSON.

---

Ulteriori informazioni rivelano le istruzioni per il recupero dei dati nel formato che Google si aspetta:

  

Ad esempio, per ottenere dataSourceUrl   da un foglio di calcolo di Google, eseguire le operazioni   seguenti:

     

  
1. Nel foglio di lavoro, seleziona l'intervallo di celle.
  
2. Seleziona 'Inserisci' e poi 'Gadget' dal menu.
  
3. Apri il menu del gadget facendo clic sul selettore in alto a destra.
  
4. Seleziona l'opzione di menu 'Ottieni URL origine dati'.
  

L'ho fatto e ho aperto l'URL nel mio browser. I dati che stava restituendo non erano certamente JSON:

google.visualization.Query.setResponse(
{requestId:'0',status:'ok',signature:'1464883469881501252',
table:{cols: [{id:'A',label:'',type:'t',pattern:''},
{id:'B',label:'',type:'t',pattern:''}],
rows: [[{v:'a'},{v:'h'}],[{v:'b'},{v:'i'}],[{v:'c'},{v:'j'}],[{v:'d'},{v:'k'}],[{v:'e'},{v:'l'}],[{v:'f'},{v:'m'}],[{v:'g'},{v:'n'}]]}});

Sembra che il risultato debba essere eseguito direttamente dal browser. Prova a modificare il codice per fare qualcosa del genere:

# old
return simplejson.dumps ({"requestId": 1, "status": "ok", ...})

# new
json = simplejson.dumps ({"requestId": 1, "status": "ok", ...})
return "google.visualization.Query.setResponse(%r);" % json

Answer 2

L'etichetta " non valida " l'errore è generalmente dovuto a un eval cieco () sulla stringa JSON, con conseguente errore nella denominazione dei nomi delle proprietà come etichette (poiché hanno la stessa sintassi - " foo: ").

eval("{ foo: 42, bar: 43 }"); // Results in invalid label

Il rimedio rapido è assicurarsi che la stringa JSON abbia parentesi che racchiudono le parentesi graffe:

eval("({ foo: 42, bar: 43 })"); // Works

Prova a racchiudere la stringa JSON tra parentesi per vedere se l'etichetta " non valida " l'errore scompare.

Answer 3

A quanto pare : mod: json soffocerebbe anche le stringhe tra virgolette singole. Questo risolverà le cose però:

Analizza oggetto JavaScript come JSON in python:

soluzione:

>>> from re import sub
>>> import json
>>> js = "{ a: 'a' }"
>>> json.loads(sub("'", '"', sub('\s(\w+):', r' "\1":', js)))
{u'a': u'a'}

Modifica: (casi limite esaminati)

Quindi è stato sollevato che la soluzione suggerita non avrebbe affrontato tutti i casi e in particolare qualcosa del genere

  

es. {pippo: " una frase: proprio qui! "} verrà modificato in {" pippo " ;: " a " frase " ;: proprio qui! "}
  & # 8211; Jason S, 12 aprile alle 18:03

Per risolvere il problema, dobbiamo semplicemente assicurarci che stiamo effettivamente lavorando con una chiave e non semplicemente con due punti in una stringa, quindi facciamo un piccolo sguardo dietro la magia per suggerire una virgola (,) o una parentesi graffa ({ ) presenza per garantire che l'abbiamo corretta, in questo modo:

due punti nella stringa:

>>> js = "{foo: 'a sentence: right here!'}"
>>> json.loads(sub("'", '"', sub('(?<={|,)\s*(\w+):', r' "\1":', js)))
{u'foo': u'a sentence: right here!'}

Il che ovviamente equivale a fare:

>>> js = "{foo: 'a sentence: right here!'}"
>>> json.loads(sub('(?<={|,)\s*(\w+):', r' "\1":', js).replace("'",'"'))
{u'foo': u'a sentence: right here!'} 

Ma poi ho sottolineato che questo non è l'unico difetto perché per quanto riguarda le virgolette:

Se siamo anche preoccupati per le virgolette sfuggite, dovremo essere leggermente più specifici su ciò che costituisce una stringa. La prima citazione seguirà una parentesi graffa ({) uno spazio (\ s) o due punti (:) mentre l'ultima citazione corrispondente verrà prima di una virgola (,) o una parentesi graffa di chiusura (}), quindi possiamo considerare tutto nel mezzo come parte della stessa stringa, in questo modo:

virgolette aggiuntive nella stringa:

>>> js = "{foo: 'a sentence: it\'s right here!'}"
>>> json.loads(
...     sub("(?<=\s|{|:)'(.*?)'(?=,|})", 
...         r'"\1"', 
...         sub('(?<={|,)\s*(\w+):', r' "\1":', js))
...     )
{u'foo': u"a sentence: it's right here!"}

Guarda questo spazio mentre vengono rivelati e risolti più casi limite. Riesci a individuarne un altro?

O forse per qualcosa di più complesso, un esempio reale come restituito da npm view :

Da:

  

{ name: 'chuck',
      description: 'Chuck Norris joke dispenser.',
      'dist-tags': { latest: '0.0.3' },
      versions: '0.0.3',
      maintainers: 'qard ',
      time: { '0.0.3': '2011-08-19T22:00:54.744Z' },
      author: 'Stephen Belanger ',
      repository: 
           { type: 'git',
             url: 'git://github.com/qard/chuck.git' },
          version: '0.0.3',
          dependencies: { 'coffee-script': '>= 1.1.1' },
          keywords: 
               [ 'chuck',
                 'norris',
                 'jokes',
                 'funny',
                 'fun' ],
              bin: { chuck: './bin/chuck' },
              main: 'index',
              engines: { node: '>= 0.4.1 < 0.5.0' },
              devDependencies: {},
              dist: 
                   { shasum: '3af700056794400218f99b7da1170a4343f355ec',
                     tarball: 'http://registry.npmjs.org/chuck/-/chuck-0.0.3.tgz' },
                  scripts: {},
                  directories: {},
                  optionalDependencies: {} }

A:

  

{u'author': u'Stephen Belanger ',
     u'bin': {u'chuck': u'./bin/chuck'},
     u'dependencies': {u'coffee-script': u'>= 1.1.1'},
     u'description': u'Chuck Norris joke dispenser.',
     u'devDependencies': {},
     u'directories': {},
     u'dist': {u'shasum': u'3af700056794400218f99b7da1170a4343f355ec',
      u'tarball': u'http://registry.npmjs.org/chuck/-/chuck-0.0.3.tgz'},
     u'dist-tags': {u'latest': u'0.0.3'},
     u'engines': {u'node': u'>= 0.4.1 < 0.5.0'},
     u'keywords': [u'chuck', u'norris', u'jokes', u'funny', u'fun'],
     u'main': u'index',
     u'maintainers': u'qard ',
     u'name': u'chuck',
     u'optionalDependencies': {},
     u'repository': {u'type': u'git', u'url': u'git://github.com/qard/chuck.git'},
     u'scripts': {},
     u'time': {u'0.0.3': u'2011-08-19T22:00:54.744Z'},
     u'version': u'0.0.3',
     u'versions': u'0.0.3'}

Funziona per me =)

nJoy!