Deserializar un JSON en un objeto JavaScript

El objetivo de JSON es que las cadenas JSON se pueden convertir en objetos nativos sin hacer nada. Compruebe este enlace

Puede usar eval(string) o JSON.parse(string).

Sin embargo, eval es arriesgado. Desde json.org:

La función eval es muy rápida. Sin embargo, puede compilar y ejecutar cualquier programa JavaScript, así que puede haber problemas de seguridad. El uso de eval está indicado cuando la fuente es confiable y competente. Es mucho más seguro usar un analizador JSON. En aplicaciones web sobre XMLHttpRequest, solo se permite la comunicación al mismo origen que proporcione esa página, por lo que es de confianza. Pero podría no ser competente. Si el servidor no es riguroso en su codificación JSON, o si no valida escrupulosamente todas sus entradas, entonces podría entregar texto JSON no válido que podría llevar script peligroso. La función eval ejecutaría el script, desatando su malicia.

¡Haz lo mismo que jQuery! (la esencia)

function parseJSON(data) {
    return window.JSON && window.JSON.parse ? window.JSON.parse( data ) : (new Function("return " + data))(); 
}
// testing
obj = parseJSON('{"name":"John"}');
alert(obj.name);

De esta manera no necesita ninguna biblioteca externa y todavía funciona en navegadores antiguos.

PARA recopilar todos los elementos de una matriz y devolver un objeto json

collectData: function (arrayElements) {

        var main = [];

        for (var i = 0; i < arrayElements.length; i++) {
            var data = {};
            this.e = arrayElements[i];            
            data.text = arrayElements[i].text;
            data.val = arrayElements[i].value;
            main[i] = data;
        }
        return main;
    },

PARA analizar los mismos datos que pasamos así

dummyParse: function (json) {       
        var o = JSON.parse(json); //conerted the string into JSON object        
        $.each(o, function () {
            inner = this;
            $.each(inner, function (index) {
                alert(this.text)
            });
        });

}

También podrías usar eval() pero JSON.parse() es una forma más segura y fácil, así que ¿por qué lo harías?

El bien y las obras

var yourJsonObject = JSON.parse(json_as_text);

No veo ninguna razón por la que prefieras usar eval. Solo pone su aplicación en riesgo.

Dicho esto - esto es también posible.

Malo-pero también funciona

var yourJsonObject = eval(json_as_text);

¿Por qué es eval una mala idea?

Considere el siguiente ejemplo.

Algún tercero o usuario proporcionado Datos de cadena JSON.

var json = `
[{
    "adjacencies": [
        {
          "nodeTo": function(){
            return "delete server files - you have been hacked!";
          }(),
          "nodeFrom": "graphnode1",
          "data": {
            "$color": "#557EAA"
          }
        }
    ],
    "data": {
      "$color": "#EBB056",
      "$type": "triangle",
      "$dim": 9
    },
    "id": "graphnode1",
    "name": "graphnode1"
},{
    "adjacencies": [],
    "data": {
      "$color": "#EBB056",
      "$type": "triangle",
      "$dim": 9
    },
    "id": "graphnode2",
    "name": "graphnode2"
}]
`;

El script del lado del servidor procesa esos datos.

Usando JSON.parse:

window.onload = function(){
  var placeholder = document.getElementById('placeholder1');
  placeholder.innerHTML = JSON.parse(json)[0].adjacencies[0].nodeTo;
}

Lanzará:

Uncaught SyntaxError: Unexpected token u in JSON at position X. 

La función no se ejecutará.

Estás a salvo.

Usando eval():

window.onload = function(){
  var placeholder = document.getElementById('placeholder1');
  placeholder.innerHTML = eval(json)[0].adjacencies[0].nodeTo;
}

Ejecutará la función y devolverá el texto.

Si remplazo esa función inofensiva con una que elimina archivos de la carpeta de su sitio web, ha sido hackeado. Sin errores / advertencias se lanzará en este ejemplo.

No estás a salvo.

Pude manipular una cadena de texto JSON para que actúe como una función que se ejecutará en el servidor.

eval(JSON)[0].adjacencies[0].nodeTo espera procesar una cadena JSON pero, en realidad, acabamos de ejecutar una función en nuestro servidor.

Esto también podría evitarse si verificamos en el lado del servidor todos los datos proporcionados por el usuario antes de pasarlos a una función eval(), pero ¿por qué no usar la herramienta incorporada para analizar JSON y ¿evitar todos estos problemas y peligros?

Y si también quieres que el objeto deserializado tenga funciones, puedes usar mi pequeña herramienta: https://github.com/khayll/jsmix

//first you'll need to define your model
var GraphNode = function() {};
GraphNode.prototype.getType = function() {
   return this.$type;
}

var Adjacency = function() {};
Adjacency.prototype.getData =n function() {
    return this.data;
}

//then you could say:
var result = JSMix(jsonData)
    .withObject(GraphNode.prototype, "*")
    .withObject(Adjacency.prototype, "*.adjacencies")
    .build();

//and use them
console.log(result[1][0].getData());

Si pega la cadena en el lado del servidor en el html, no necesita hacer nada:

Para java simple en jsp:

var jsonObj=<%=jsonStringInJavaServlet%>;

Para puntales de ancho jsp:

var jsonObj=<s:property value="jsonStringInJavaServlet" escape="false" escapeHtml="false"/>;

Creo que esto debería ayudar:

También las documentaciones también prueban que puedes usar require () para archivos json: https://www.bennadel.com/blog/2908-you-can-use-require-to-load-json-javascript-object-notation-files-in-node-js.htm

var jsonfile = require("./path/to/jsonfile.json");
node = jsonfile.adjacencies.nodeTo;
node2 = jsonfile.adjacencies.nodeFrom;
node3 = jsonfile.adjacencies.data.$color;
//other things.