Trasformazione sicura di una stringa JSON in un oggetto

Data una stringa di dati JSON, come posso trasformare quella stringa in modo sicuro in un oggetto JavaScript?

Ovviamente posso farlo in modo non sicuro con qualcosa del tipo:

var obj = eval("(" + json + ')');

ma questo mi rende vulnerabile alla stringa JSON contenente altro codice, che sembra molto pericoloso semplicemente valutare.

JSON.parse(jsonString) è un puro approccio JavaScript purché sia ​​possibile garantire un browser ragionevolmente moderno.

Il metodo jQuery è ora obsoleto. Utilizzare invece questo metodo:

let jsonObject = JSON.parse(jsonString);

Risposta originale utilizzando la funzionalità jQuery obsoleta :

Se stai usando jQuery basta usare:

jQuery.parseJSON( jsonString );

È esattamente quello che stai cercando (vedi la documentazione di jQuery ).

Questa risposta è per IE <7, per i browser moderni controlla la risposta di Jonathan sopra.

Questa risposta è obsoleta e la risposta di Jonathan sopra ( JSON.parse(jsonString)) è ora la risposta migliore .

JSON.org ha parser JSON per molte lingue, tra cui quattro diverse per JavaScript. Credo che la maggior parte delle persone considererebbe json2.js la loro implementazione goto.

Utilizzare l'esempio di codice semplice in " JSON.parse () ":

var jsontext = '{"firstname":"Jesper","surname":"Aaberg","phone":["555-0100","555-0120"]}';
var contact = JSON.parse(jsontext);

e invertendolo:

var str = JSON.stringify(arr);

Non sono sicuro di altri modi per farlo, ma ecco come lo fai in Prototype (tutorial JSON) .

new Ajax.Request('/some_url', {
  method:'get',
  requestHeaders: {Accept: 'application/json'},
  onSuccess: function(transport){
    var json = transport.responseText.evalJSON(true);
  }
});

La chiamata evalJSON()con vero come argomento disattiva la stringa in arrivo.

Questo sembra essere il problema:

Un input che viene ricevuto tramite websocket Ajax ecc. E sarà in formato String, ma è necessario sapere se lo è JSON.parsable. Il problema è che, se lo esegui sempre JSON.parse, il programma PU continue continuare "con successo" ma vedrai ancora un errore generato nella console con il temuto "Error: unexpected token 'x'".

var data;

try {
  data = JSON.parse(jqxhr.responseText);
} catch (_error) {}

data || (data = {
  message: 'Server error, please retry'
});

Se stai usando jQuery , puoi anche usare:

$.getJSON(url, function(data) { });

Quindi puoi fare cose come

data.key1.something
data.key1.something_else

eccetera.

$.ajax({
  url: url,
  dataType: 'json',
  data: data,
  success: callback
});

Al callback vengono passati i dati restituiti, che saranno un oggetto JavaScript o un array come definito dalla struttura JSON e analizzati utilizzando il $.parseJSON()metodo.

Solo per divertimento, ecco un modo per usare una funzione:

 jsonObject = (new Function('return ' + jsonFormatData))()

L'uso JSON.parseè probabilmente il modo migliore.

Ecco un esempio demo live .

var jsonRes = '{ "students" : [' +
          '{ "firstName":"Michel" , "lastName":"John" ,"age":18},' +
          '{ "firstName":"Richard" , "lastName":"Joe","age":20 },' +
          '{ "firstName":"James" , "lastName":"Henry","age":15 } ]}';
var studentObject = JSON.parse(jsonRes);

Il modo più semplice usando il parse()metodo:

var response = '{"result":true,"count":1}';
var JsonObject= JSON.parse(response);

Quindi è possibile ottenere i valori degli elementi JSON, ad esempio:

var myResponseResult = JsonObject.result;
var myResponseCount = JsonObject.count;

Utilizzando jQuery come descritto nella jQuery.parseJSON()documentazione:

JSON.parse(jsonString);

Prova a utilizzare il metodo con questo oggetto Data. ex: Data='{result:true,count:1}'

try {
  eval('var obj=' + Data);
  console.log(obj.count);
}
catch(e) {
  console.log(e.message);
}

Questo metodo aiuta davvero in Nodejs quando si lavora con la programmazione della porta seriale

Ho trovato un modo "migliore":

In CoffeeScript:

try data = JSON.parse(jqxhr.responseText)
data ||= { message: 'Server error, please retry' }

In Javascript:

var data;

try {
  data = JSON.parse(jqxhr.responseText);
} catch (_error) {}

data || (data = {
  message: 'Server error, please retry'
});

L'analisi JSON è sempre un dolore. Se l'input non è come previsto, genera un errore e blocca ciò che si sta facendo.

Puoi utilizzare la seguente minuscola funzione per analizzare in modo sicuro i tuoi input. Trasforma sempre un oggetto anche se l'input non è valido o è già un oggetto che è migliore nella maggior parte dei casi:

JSON.safeParse = function (input, def) {
  // Convert null to empty object
  if (!input) {
    return def || {};
  } else if (Object.prototype.toString.call(input) === '[object Object]') {
    return input;
  }
  try {
    return JSON.parse(input);
  } catch (e) {
    return def || {};
  }
};

JSON.parse(jsonString);

json.parse cambierà in oggetto.

Se abbiamo una stringa come questa:

"{\"status\":1,\"token\":\"65b4352b2dfc4957a09add0ce5714059\"}"

allora possiamo semplicemente usare JSON.parsedue volte per convertire questa stringa in un oggetto JSON:

var sampleString = "{\"status\":1,\"token\":\"65b4352b2dfc4957a09add0ce5714059\"}"
var jsonString= JSON.parse(sampleString)
var jsonObject= JSON.parse(jsonString)

E possiamo estrarre valori dall'oggetto JSON usando:

// instead of last JSON.parse:
var { status, token } = JSON.parse(jsonString);

Il risultato sarà:

status = 1 and token = 65b4352b2dfc4957a09add0ce5714059

JSON.parse() converte qualsiasi stringa JSON passata nella funzione in un oggetto JSON.

Per capirlo meglio, premi F12per aprire "Ispeziona elemento" nel tuo browser e vai alla console per scrivere i seguenti comandi:

var response = '{"result":true,"count":1}'; //sample json object(string form)
JSON.parse(response); //converts passed string to JSON Object.

Ora esegui il comando:

console.log(JSON.parse(response));

Otterrai l'output come oggetto {result: true, count: 1}.

Per usare quell'oggetto, puoi assegnarlo alla variabile, forse obj:

var obj = JSON.parse(response);

Utilizzando obje l' .operatore punto ( ) è possibile accedere alle proprietà dell'oggetto JSON.

Prova a eseguire il comando:

console.log(obj.result);

Documentazione ufficiale :

Il JSON.parse()metodo analizza una stringa JSON, costruendo il valore JavaScript o l'oggetto descritto dalla stringa. È reviverpossibile fornire una funzione opzionale per eseguire una trasformazione sull'oggetto risultante prima che venga restituito.

Sintassi:

JSON.parse(text[, reviver])

parametri:

text : La stringa da analizzare come JSON. Vedere l'oggetto JSON per una descrizione della sintassi JSON.

reviver (optional) : Se una funzione, questo prescrive come viene trasformato il valore originariamente prodotto dall'analisi prima di essere restituito.

Valore di ritorno

L'oggetto corrispondente al testo JSON dato.

eccezioni

Genera un'eccezione SyntaxError se la stringa da analizzare non è JSON valida.

La conversione dell'oggetto in JSON e quindi l'analisi, funziona per me, come:

JSON.parse(JSON.stringify(object))

Analizzare la stringa JSON con JSON.parse()e i dati diventano un oggetto JavaScript:

JSON.parse(jsonString)

Qui, JSON rappresenta l'elaborazione del set di dati JSON.

Immagina di aver ricevuto questo testo da un web server:

'{ "name":"John", "age":30, "city":"New York"}'

Per analizzare un oggetto JSON:

var obj = JSON.parse('{ "name":"John", "age":30, "city":"New York"}'); 

Ecco objil rispettivo oggetto JSON che assomiglia a:

{ "name":"John", "age":30, "city":"New York"}

Per recuperare un valore utilizzare l' .operatore:

obj.name // John
obj.age //30

Converti un oggetto JavaScript in una stringa con JSON.stringify().

Solo per l'analisi della copertina per diversi tipi di input

Analizzare i dati con JSON.parse () e i dati diventano un oggetto JavaScript.

var obj = JSON.parse('{ "name":"John", "age":30, "city":"New York"}');

Quando si utilizza JSON.parse () su un JSON derivato da un array, il metodo restituirà un array JavaScript anziché un oggetto JavaScript.

var myArr = JSON.parse(this.responseText);
console.log(myArr[0]);

Gli oggetti data non sono consentiti in JSON. Per le date fai qualcosa del genere

var text = '{ "name":"John", "birth":"1986-12-14", "city":"New York"}';
var obj = JSON.parse(text);
obj.birth = new Date(obj.birth);

Le funzioni non sono consentite in JSON. Se devi includere una funzione, scrivila come stringa.

var text = '{ "name":"John", "age":"function () {return 30;}", "city":"New York"}';
var obj = JSON.parse(text);
obj.age = eval("(" + obj.age + ")");

Domanda precedente, lo so, tuttavia nessuno nota questa soluzione utilizzando new Function(), una funzione anonima che restituisce i dati.

Solo un esempio:

 var oData = 'test1:"This is my object",test2:"This is my object"';

 if( typeof oData !== 'object' )
  try {
   oData = (new Function('return {'+oData+'};'))();
  }
  catch(e) { oData=false; }

 if( typeof oData !== 'object' )
  { alert( 'Error in code' ); }
 else {
        alert( oData.test1 );
        alert( oData.test2 );
      }

Questo è un po 'più sicuro perché viene eseguito all'interno di una funzione e non viene compilato direttamente nel codice. Quindi, se contiene una dichiarazione di funzione, non sarà associata all'oggetto finestra predefinito.

Lo uso per "compilare" le impostazioni di configurazione degli elementi DOM (ad esempio l'attributo di dati) semplici e veloci.

Sommario:

Javascript (sia browser che NodeJS) hanno un JSONoggetto incorporato . Su questo oggetto ci sono 2 metodi convenienti per affrontare JSON. Sono i seguenti:

1. JSON.parse() Prende JSONcome argomento, restituisce l'oggetto JS
2. JSON.stringify() Prende l'oggetto JS come argomento restituisce l' JSONoggetto

Altre applicazioni:

Inoltre, per gestire in modo molto conveniente JSON, possono essere utilizzati per altri mezzi. La combinazione di entrambi i JSONmetodi ci consente di rendere molto facili la creazione di cloni profondi di matrici o oggetti. Per esempio:

let arr1 = [1, 2, [3 ,4]];
let newArr = arr1.slice();

arr1[2][0] = 'changed'; 
console.log(newArr); // not a deep clone

let arr2 = [1, 2, [3 ,4]];
let newArrDeepclone = JSON.parse(JSON.stringify(arr2));

arr2[2][0] = 'changed'; 
console.log(newArrDeepclone); // A deep clone, values unchanged

Puoi anche usare la reviverfunzione per filtrare.

var data = JSON.parse(jsonString, function reviver(key, value) {
   //your code here to filter
});

Per maggiori informazioni leggi JSON.parse.

JSON.parse è il modo giusto per convertire una stringa in un oggetto ma se la stringa analizzata non è un oggetto o se la stringa non è corretta, verrà generato un errore che causerà l'interruzione del resto del codice, quindi è ideale per avvolgere la funzione JSON.parse all'interno di try-catch come

try{
   let obj = JSON.parse(string);
}catch(err){
   console.log(err);
}

Prova questo. Questo è scritto in dattiloscritto.

         export function safeJsonParse(str: string) {
               try {
                 return JSON.parse(str);
                   } catch (e) {
                 return str;
                 }
           }

/**
 * Safely turning a JSON string into an object
 *
 * @param {String} str - JSON String
 * @returns deserialized object, false if error
 */
export function jsonParse(str) {
  let data = null;
  try {
    data = JSON.parse(str);
  } catch (err) {
    return false;
  }
  return data;
}