JSON


JavaScript Object Notation (JSON) es un formato de intercambio de datos ligero. Esta basado en el objeto de notación literal de JavaScript, una de los mejores partes de JavaScript. Aunque se trata de un subconjunto de JavaScript, que es independiente al lenguaje. Se puede utilizar para intercambiar datos entre programas escritos en todos los lenguajes de programación modernos. Es un formato de texto, por lo que es legible por humanos y máquinas. Es fácil de aplicar y fácil de usar. Existe una gran cantidad de material sobre JSON en http://www.JSON.org/.

Sintaxis JSON

JSON tiene seis tipos de valores: objetos, matrices, cadenas, números, booleanos (true y false), y el valor especial null. Los espacios en blanco (espacios, tabuladores, retornos de carro y caracteres de nueva línea) se pueden insertar antes o después de cualquier valor. Esto puede hacer que los textos JSON sean más fácil para los seres humanos de leer. Los espacios en blanco se puedenn omitir para reducir los costos de transmisión o de almacenamiento.
Un objeto JSON es un contenedor desordenado de pares nombre/valor. Un nombre puede ser cualquier cadena. Un valor puede ser cualquier valor JSON, incluidas las matrices y objetos. Los objetos JSON se pueden anidar a cualquier profundidad, pero por lo general es más eficaz mantenerlos relativamente planos. La mayoría de los lenguajes tienen una característica que permiten mapear fácilmente objetos JSON, como un objeto , estructura, registro, diccionario, tabla hash, lista de propiedades, o matriz asociativa.
La matriz JSON es una secuencia ordenada de valores. Un valor puede ser cualquier valor JSON, incluyendo matrices y objetos. La mayoría de los lenguajes tienen características que permiten mapear fácilmente matrices JSON, como una matriz, vector, lista o secuencia.
Una cadena JSON se envuelve entre comillas dobles. El carácter \ se utiliza para el escape. JSON permite que el / carácter que se escapó para que JSON se puede incrustar en HTML etiquetas <script>. HTML no permite la secuencia </ excepto para iniciar la etiqueta </ script> . JSON permite <\/, que produce el mismo resultado, pero no confunde HTML.
Los números JSON son como los números de JavaScript. No se permiten ceros a la izquierda en números entero anque algunos lenguajes los utilizan para indicar un número octal. Ese tipo de confusión raiz no es deseable en un formato de intercambio de datos. Un número puede ser un número entero, real, o científico.
Eso es todo. Eso es todo de JSON. Los objetivos de diseño de JSON debían ser mínimos, portátiles, textual, y un subconjunto de JavaScript. Cuanto menos tenemos que acordar con el fin de interactuar, más fácilmente podemos interoperar.

[
    {
        "first": "Jerome",
        "middle": "Lester",
        "last": "Howard",
        "nick-name": "Curly",
        "born": 1903,
        "died": 1952,
        "quote": "nyuk-nyuk-nyuk!"
    },
    {
        "first": "Harry",
        "middle": "Moses",
        "last": "Howard",
        "nick-name": "Moe",
        "born": 1897,
        "died": 1975,
        "quote": "Why, you!"
    },
    {
        "first": "Louis",
        "last": "Feinberg",
        "nick-name": "Larry",
        "born": 1902,
        "died": 1975,
        "quote": "I'm sorry. Moe, it was an accident!"
    }
]

Utilizando JSON de forma segura

JSON es particularmente fácil de usar en aplicaciones web dado que JSON es JavaScript. UN texto JSON puede convertirse en una útil estructura de datos con la función eval:

var myData = eval('(' + myJSONText + ')');

(La concatenación de los paréntesis alrededor del texto JSON es una solución para una ambigüedad en la gramática de JavaScript.)

La función eval tiene terribles problemas de seguridad, sin embargo. Es seguro usar eval para analizar un texto JSON? Actualmente, la mejor técnica para obtener los datos de un servidor en un navegador de web es mediante XMLHttpRequest. XMLHttpRequest puede obtener datos sólo desde el mismo servidor que produjo el HTML. evaling texto de ese servidor no es menos seguro que el código HTML original. Pero, eso supone que el servidor es malicioso. ¿Qué sucede si el servidor es simplemente incompetente?
Un servidor incompetente podría hacer la codificación JSON de forma incorrecta. Si se construyen textos JSON a bofetadas junto a algunas cadenas en lugar de utilizar un codificador JSON adecuado, entonces se podría enviar involuntariamente material peligroso. Si actúa como proxy y simplemente pasa a través texto JSON sin determinar si está bien formado, entonces nuevamente podría estar enviar material peligroso. 
Utilizando el método JSON.parse podemos evitar el peligro en lugar de utilizar eval (ver http://www.JSON.org/json2.js). JSON.parse lanzará una excepción si el texto contiene algo peligroso. Se recomienda utilizar siempre JSON.parse en lugar de eval para defenderse de la incompetencia del servidor. También es una buena práctica el día en que el explorador proporcione acceso seguro a datos de otros servidores.
Hay otro peligro en la interacción entre datos externos y innerHTML. Un patrón comunes de Ajax es que el servidor envíe un fragmento de texto HTML que es el que se asigna a la propiedad innerHTML de un elemento HTML. Esta es una muy mala práctica. Si el texto HTML contiene una etiqueta <script> o su equivalente, a continuación un script malvado podrá ejecutarse. Una vez más, esto puede ser debido a la incompetencia del servidor.
¿Cuál es específicamente el peligro? Si un script malvado llega a ejecutarse en su página, obtiene acceso a todo el estado y las capacidades de la página.
Puede interactuar con el servidor y el servidor no será capaz de distinguir las peticiones malvadas de las solicitudes legítimas.
El script maligno tiene acceso al objeto global, lo que le da acceso a todos los datos de la aplicación, excepto a las variables ocultas en los closures.
Tiene acceso al objeto de documento, lo que le da acceso a todo lo que ve el usuario.
También da al script maligno la capacidad de diálogo con el usuario.
La barra de direcciones del navegador y todos los anti-phishing de chromo indican al usuario que el diálogo deberían ser de confianza.
El objeto document también da acceso al script maligno para acceder a la red, lo que le permite cargar más scripts malignos, o para investigar los sitios dentro del servidor de seguridad, o para enviar secretos que ha aprendido a cualquier servidor en el mundo.
Este peligro es una consecuencia directa del objeto global de JavaScript, que es de lejos la peor parte de JavaScript de muchas partes malas. Estos peligros no son causados por Ajax o JSON o XMLHttpRequest o Web 2.0 (sea lo que sea). Estos peligros han sido en el navegador desde la introducción de JavaScript, y se mantendrán hasta que JavaScript sea sustituido.
Ten cuidado.

Un analizador JSON

Esta es una implementación de un analizador JSON en JavaScript:

var json_parse = function () {
// This is a function that can parse a JSON text, producing a JavaScript
// data structure. It is a simple, recursive descent parser.

// We are defining the function inside of another function to avoid creating
// global variables.

        var at,    // The index of the current character
            ch,    // The current character
            escapee = {
                '"':   '"',
                '\\':  '\\',
                '/':   '/',
                b:     'b',
                f:     '\f',
                n:     '\n',
                r:     '\r',
                t:     '\t',
            },

            text,

            error = function (m) {
// Call error when something is wrong.
                throw {
                    name:    'SyntaxError',
                    message: m,
                    at:      at,
                    text:    text
                };
            },

            next = function (c) {
// If a c parameter is provided, verify that it matches the current character.
                if (c && c !== ch) {
                    error("Expected '" + c + "' instead of '" + ch + "'");
                }
// Get the next character. When there are no more characters,
// return the empty string.
                ch = text.charAt(at);
                at += 1;
                return ch;
            },

            number = function () {
// Parse a number value.
                var number,
                    string = '';
                
                if (ch === '-') {
                    string = '-';
                    next('-');
                }

                while (ch >= '0' && ch <= '9') {
                    string += ch;
                    next();
                }

                if (ch === '.') {
                    string += '.';
                    while (next() && ch >= '0' && ch <= '9') {
                    string += ch;
                    }
                }

                if (ch === 'e' || ch === 'E') {
                    string += ch;
                    next();
                
                if (ch === '-' || ch === '+') {
                    string += ch;
                    next();
                }


                while (ch >= '0' && ch <= '9') {
                    string += ch;
                    next();
                }
            }
            number = + string;
            if (isNaN(number)) {
                error("Bad number");
            } else {
                return number;
            }
        },

        string = function () {
// Parse a string value.

            var hex,
                i,
                string = '',
                uffff;

// When parsing for string values, we must look for " and \ characters.
            if (ch === '"') {
                while (next()) {
                    if (ch === '"') {
                        next();
                        return string;
                    } else if (ch === '\\') {
                        next();
                        if (ch === 'u') {
                            uffff = 0;
                            for (i = 0; i < 4; i += 1) {
                                hex = parseInt(next(), 16);
                                if (!isFinite(hex)) {
                                    break;
                                }
                                uffff = uffff * 16 + hex;
                            }
                            string += String.fromCharCode(uffff);
                        } else if (typeof escapee[ch] === 'string') {
                            string += escapee[ch];
                        } else {
                            break;
                        }
                    } else {
                        string += ch;
                    }
                }
            }
            error('Bad string');
        },

        white = function () {
// Skip whitespace.
            while (ch && ch <= ' ') {
                next();
            }
        },

        word = function () {
// true, false, or null.

        switch (ch) {
        case 't':
            next('t');
            next('r');
            next('u');
            next('e');
            return true;
        case 'f':
            next('f');
            next('a');
            next('l');
            next('s');
            next('e');
            return false;
        case 'n':
            next('n');
            next('u');
            next('l');
            next('l');
            return null;
        }
        error("Unexpected '" + ch + "'");
    },


    value,  // Place holder for the value function.

    array = function () {
// Parse an array value.
        var array = [];

        if (ch === '[') {
            next('[');
            white();
            if (ch === ']') {
                next(']');
                return array;  // empty array
            }

            while (ch) {
                array.push(value());
                white();

                if (ch === ']') {
                    next(']');
                    return array;
                }
                next(',');
                white();
            }
        }
        error("Bad array");
    },

    object = function () {
// Parse an object value.

    var key,
        object = {};

        if (ch === '{') {
            next('{');
            white();
            if (ch === '}') {
                next('}');
                return object;  // empty object
            }

            while (ch) {
                key = string();
                white();
                next(':');
                object[key] = value();
                white();

                if (ch === '}') {
                    next('}');
                    return object;
                }
                next(',');
                white();
            }
        }

        error("Bad object");
    };

    value = function () {
// Parse a JSON value. It could be an object, an array, a string, a number,
// or a word.
        white();
        switch (ch) {
        case '{':
            return object();
        case '[':
            return array();
        case '"':
            return string();
        case '-':
            return number();
        default:
            return ch >= '0' && ch <= '9' ? number() : word();
        }
    };

// Return the json_parse function. It will have access to all of the above
// functions and variables.

    return function (source, reviver) {
        var result;

        text = source;
        at = 0;
        ch = ' ';
        result = value();
        white();
        if (ch) {
            error("Syntax error");
        }
// If there is a reviver function, we recursively walk the new structure,
// passing each name / value pair to the reviver function for possible
// transformation, starting with a temporary boot object that holds the result
// in an empty key.If there is not a reviver function, we simply return the
// result.
    return typeof reviver === 'function' ?
        function walk(holder, key) {
            var k, v, value = holder[key];
            if (value && typeof value === 'object') {
                for (k in value) {
                    if (Object.hasOwnProperty.call(value, k)) {
                        v = walk(value, k);
                        if (v !== undefined) {
                            value[k] = v;
                        } else {
                            delete value[k];
                        }
                    }
                }
            }
            return reviver.call(holder, key, value);
        }({'': result}, '') : result;
    };
}();

Añadir nuevo comentario

CAPTCHA
Esta pregunta es para comprobar si usted es un visitante humano y prevenir envíos de spam automatizado.
3 + 0 =
Resuelva este simple problema matemático y escriba la solución; por ejemplo: Para 1+3, escriba 4.