Безопасное превращение строки JSON в объект

Учитывая строку данных JSON, как я могу безопасно превратить эту строку в объект JavaScript?

Очевидно, что я могу сделать это небезопасно с чем-то вроде:

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

но это делает меня уязвимым для строки JSON, содержащей другой код, который кажется очень опасным для простой оценки.

JSON.parse(jsonString) это чистый подход JavaScript, если вы можете гарантировать достаточно современный браузер.

Метод jQuery устарел. Используйте этот метод вместо:

let jsonObject = JSON.parse(jsonString);

Исходный ответ с использованием устаревшей функциональности jQuery :

Если вы используете jQuery, просто используйте:

jQuery.parseJSON( jsonString );

Это именно то, что вы ищете (см. Документацию jQuery ).

Этот ответ для IE <7, для современных браузеров проверьте ответ Джонатана выше.

Этот ответ устарел, и ответ Джонатана выше ( JSON.parse(jsonString)) теперь является лучшим ответом .

JSON.org имеет парсеры JSON для многих языков, включая четыре различных для JavaScript. Я считаю, что большинство людей считают json2.js своей реализацией.

Используйте простой пример кода в " JSON.parse () ":

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

и наоборот:

var str = JSON.stringify(arr);

Я не уверен насчет других способов сделать это, но вот как вы это делаете в Prototype (учебник по JSON) .

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

Вызов evalJSON()с истиной в качестве аргумента дезинфицирует входящую строку.

Это, кажется, проблема:

Ввод, полученный через веб-сокет Ajax и т. Д., И он будет в формате String, но вам необходимо знать, так ли это JSON.parsable. Двойным является то, что, если вы всегда запускаете его JSON.parse, программа МОЖЕТ продолжаться «успешно», но вы все равно увидите ошибку, выданную в консоли с ужасом "Error: unexpected token 'x'".

var data;

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

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

Если вы используете jQuery , вы также можете использовать:

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

Тогда вы можете делать такие вещи, как

data.key1.something
data.key1.something_else

и т.п.

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

Обратному вызову передаются возвращенные данные, которые будут объектом или массивом JavaScript, как определено структурой JSON, и проанализированы с использованием $.parseJSON()метода.

Просто для удовольствия, вот способ использования функции:

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

Использование JSON.parse, вероятно, лучший способ.

Вот пример живой демонстрации .

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);

Самый простой способ с использованием parse()метода:

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

Затем вы можете получить значения элементов JSON, например:

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

Используя jQuery, как описано в jQuery.parseJSON()документации:

JSON.parse(jsonString);

Попробуйте использовать метод с этим объектом данных. например: Data='{result:true,count:1}'

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

Этот метод действительно помогает в Nodejs, когда вы работаете с программированием последовательного порта

Я нашел «лучший» способ:

В CoffeeScript:

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

В Javascript:

var data;

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

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

Разбор JSON - это всегда боль. Если ввод не такой, как ожидалось, он выдает ошибку и вылетает, что вы делаете.

Вы можете использовать следующую крошечную функцию для безопасного анализа вашего ввода. Он всегда поворачивает объект, даже если ввод недействителен или уже является объектом, что лучше для большинства случаев:

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 превратится в объект.

Если у нас есть такая строка:

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

тогда мы можем просто использовать JSON.parseдважды, чтобы преобразовать эту строку в объект JSON:

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

И мы можем извлечь значения из объекта JSON, используя:

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

Результатом будет:

status = 1 and token = 65b4352b2dfc4957a09add0ce5714059

JSON.parse() преобразует любую строку JSON, переданную в функцию, в объект JSON.

Чтобы лучше это понять, нажмите, F12чтобы открыть «Проверка элемента» в браузере и перейти к консоли, чтобы написать следующие команды:

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

Теперь запустите команду:

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

Вы получите вывод как объект {result: true, count: 1} .

Чтобы использовать этот объект, вы можете присвоить его переменной, возможно, obj :

var obj = JSON.parse(response);

Используя obj и точку (. оператор ), вы можете получить доступ к свойствам объекта JSON.

Попробуйте запустить команду:

console.log(obj.result);

Официальная документация :

JSON.parse()Метод анализирует строку JSON, конструируя значение JavaScript или объект , описанный в строке. reviverМожет быть предоставлена необязательная функция для выполнения преобразования результирующего объекта перед его возвращением.

Синтаксис:

JSON.parse(text[, reviver])

Параметры:

text : Строка для анализа в формате JSON. См. Объект JSON для описания синтаксиса JSON.

reviver (optional) : Если функция, это предписывает, как значение, первоначально произведенное синтаксическим анализом, преобразовано, прежде чем будет возвращено.

Возвращаемое значение

Объект, соответствующий заданному тексту JSON.

Исключения

Выдает исключение SyntaxError, если строка для анализа недопустима в формате JSON.

Преобразование объекта в JSON, а затем его разбор работает для меня, например:

JSON.parse(JSON.stringify(object))

Синтаксически проанализируйте строку JSON JSON.parse(), и данные станут объектом JavaScript:

JSON.parse(jsonString)

Здесь JSON представляет для обработки набора данных JSON.

Представьте, что мы получили этот текст с веб-сервера:

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

Для анализа в объект JSON:

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

Вот objсоответствующий объект JSON, который выглядит следующим образом:

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

Чтобы получить значение, используйте .оператор:

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

Преобразуйте объект JavaScript в строку с помощью JSON.stringify().

Просто на разбор обложки для разных типов ввода

Выполните синтаксический анализ данных с помощью JSON.parse (), и данные станут объектом JavaScript.

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

При использовании JSON.parse () в JSON, производном от массива, метод возвращает массив JavaScript вместо объекта JavaScript.

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

Объекты даты не допускаются в JSON. Для Даты сделать что-то вроде этого

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

Функции не допускаются в JSON. Если вам нужно включить функцию, напишите ее в виде строки.

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

Я знаю, что это более старый вопрос, однако никто не замечает этого решения, используя new Function()анонимную функцию, которая возвращает данные.

Просто пример:

 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 );
      }

Это немного более безопасно, потому что он выполняется внутри функции и не компилируется в вашем коде напрямую. Поэтому, если внутри него есть объявление функции, оно не будет привязано к объекту окна по умолчанию.

Я использую это для простой и быстрой «компиляции» настроек конфигурации элементов DOM (например, атрибута данных).

Резюме:

Javascript (как браузер, так и NodeJS) имеют встроенный JSONобъект. На этом объекте есть 2 удобных способа борьбы с JSON. Они следующие:

1. JSON.parse() принимает JSON качестве аргумента, возвращает объект JS
2. JSON.stringify() Принимает объект JS в качестве аргумента, возвращает JSONобъект

Другие приложения:

К тому же для очень удобного обращения с JSONними можно использовать другие средства. Сочетание обоих JSONметодов позволяет очень легко сделать глубокие клоны массивов или объектов. Например:

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

Вы также можете использовать reviverфункцию для фильтрации.

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

Для получения дополнительной информации читайте JSON.parse.

JSON.parse - это правильный способ преобразования строки в объект, но если анализируемая строка не является объектом или строка неверна, она выдаст ошибку, которая приведет к разрыву остальной части кода, поэтому идеально подходит для переноса функции JSON.parse внутри try-catch

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

Попробуйте это. Это написано в машинописи.

         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;
}