Что-то вроде:
var jsonString = '{ "Id": 1, "Name": "Coke" }';
//should be true
IsJsonString(jsonString);
//should be false
IsJsonString("foo");
IsJsonString("<div>foo</div>")
Решение не должно содержать try/catch. Некоторые из нас включили "разрыв всех ошибок", и им не нравится, как отладчик разбивается на эти недопустимые строки JSON.
Сначала комментарий. Вопрос был о том, чтобы не использовать try/catch.
Если вы не против использовать его, прочитайте ответ ниже. Здесь мы просто проверяем строку JSON с помощью регулярного выражения, и она будет работать в большинстве случаев, а не во всех.
Посмотрите вокруг линии 450 в https://github.com/douglascrockford/JSON-js/blob/master/json2.js
Существует регулярное выражение, которое проверяет правильность JSON, что-то вроде:
if (/^[\],:{}\s]*$/.test(text.replace(/\\["\\\/bfnrtu]/g, '@').
replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
//the json is ok
}else{
//the json is not ok
}
РЕДАКТИРОВАТЬ: новая версия json2.js делает более сложный синтаксический анализ, чем выше, но все еще основанный на замене регулярного выражения (из комментария @Mrchief)
Используйте парсер JSON, например JSON.parse:
function IsJsonString(str) {
try {
JSON.parse(str);
} catch (e) {
return false;
}
return true;
}
Я знаю, что я на 3 года опоздал на этот вопрос, но мне захотелось вздрогнуть.
В то время как решение Gumbo отлично работает, оно не обрабатывает несколько случаев, когда исключение не возникает для JSON.parse({something that isn't JSON})
Я также предпочитаю возвращать разобранный JSON одновременно, поэтому вызывающему коду не нужно вызывать JSON.parse(jsonString) второй раз.
Это, кажется, хорошо работает для моих нужд:
function tryParseJSON (jsonString){
try {
var o = JSON.parse(jsonString);
// Handle non-exception-throwing cases:
// Neither JSON.parse(false) or JSON.parse(1234) throw errors, hence the type-checking,
// but... JSON.parse(null) returns null, and typeof null === "object",
// so we must check for that, too. Thankfully, null is falsey, so this suffices:
if (o && typeof o === "object") {
return o;
}
}
catch (e) { }
return false;
};
// vanillaJS
function isJSON(str) {
try {
return (JSON.parse(str) && !!str);
} catch (e) {
return false;
}
}
Использование isJSON({}) будет false, isJSON('{}') будет true.
Чтобы проверить, есть ли что-то Array или Object (проанализированный JSON):
// vanillaJS
function isAO(val) {
return val instanceof Array || val instanceof Object ? true : false;
}
// ES2015
var isAO = (val) => val instanceof Array || val instanceof Object ? true : false;
Использование isAO({}) будет true, isAO('{}') будет false.
Я использовал очень простой метод, чтобы проверить строку, насколько она действительна в формате JSON или нет.
function testJSON(text){
if (typeof text!=="string"){
return false;
}
try{
JSON.parse(text);
return true;
}
catch (error){
return false;
}
}
Результат с правильной строкой JSON:
var input='["foo","bar",{"foo":"bar"}]';
testJSON(input); // returns true;
Результат с простой строкой;
var input='This is not a JSON string.';
testJSON(input); // returns false;
Результат с объектом:
var input={};
testJSON(input); // returns false;
Результат с нулевым вводом:
var input=null;
testJSON(input); // returns false;
Последний возвращает false, потому что типом нулевых переменных является объект.
Это работает каждый раз. :)
Вот мой рабочий код:
function IsJsonString(str) {
try {
var json = JSON.parse(str);
return (typeof json === 'object');
} catch (e) {
return false;
}
}
В prototypeJS у нас есть метод isJSON. Вы можете попробовать это. Даже json может помочь.
"something".isJSON();
// -> false
"\"something\"".isJSON();
// -> true
"{ foo: 42 }".isJSON();
// -> false
"{ \"foo\": 42 }".isJSON();
Из определения прототипа String.isJSON определение здесь
/**
* String#isJSON() -> Boolean
*
* Check if the string is valid JSON by the use of regular expressions.
* This security method is called internally.
*
* ##### Examples
*
* "something".isJSON();
* // -> false
* "\"something\"".isJSON();
* // -> true
* "{ foo: 42 }".isJSON();
* // -> false
* "{ \"foo\": 42 }".isJSON();
* // -> true
**/
function isJSON() {
var str = this;
if (str.blank()) return false;
str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
return (/^[\],:{}\s]*$/).test(str);
}
поэтому это версия, которая может использоваться для передачи строкового объекта
function isJSON(str) {
if ( /^\s*$/.test(str) ) return false;
str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
return (/^[\],:{}\s]*$/).test(str);
}
function isJSON(str) {
if ( /^\s*$/.test(str) ) return false;
str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
return (/^[\],:{}\s]*$/).test(str);
}
console.log ("this is a json", isJSON( "{ \"key\" : 1, \"[email protected]\" : \"val\"}" ) )
console.log("this is not a json", isJSON( "{ \"key\" : 1, \"[email protected]\" : pippo }" ) )Может быть, это будет полезно:
function parseJson(code)
{
try {
return JSON.parse(code);
} catch (e) {
return code;
}
}
function parseJsonJQ(code)
{
try {
return $.parseJSON(code);
} catch (e) {
return code;
}
}
var str = "{\"a\":1,\"b\":2,\"c\":3,\"d\":4,\"e\":5}";
alert(typeof parseJson(str));
alert(typeof parseJsonJQ(str));
var str_b = "c";
alert(typeof parseJson(str_b));
alert(typeof parseJsonJQ(str_b));
выход:
IE7: строка, объект, строка, строка
CHROME: объект, объект, строка, строка
Этот ответ уменьшит стоимость инструкции trycatch.
Я использовал JQuery для синтаксического анализа строк JSON, и я использовал оператор trycatch для обработки исключений, но исключение исключений для строк un-parsable замедляло мой код, поэтому я использовал простое Regex для проверки строки, если это возможная строка JSON или нет не переходя пером, проверив его синтаксис, я использовал обычный способ, анализируя строку с помощью JQuery:
if (typeof jsonData == 'string') {
if (! /^[\[|\{](\s|.*|\w)*[\]|\}]$/.test(jsonData)) {
return jsonData;
}
}
try {
jsonData = $.parseJSON(jsonData);
} catch (e) {
}
Я завернул предыдущий код в рекурсивную функцию для анализа вложенных ответов JSON.
Думаю, я знаю, почему ты хочешь этого избежать. Но, может быть, попробуй и поймай! o) Это пришло мне в голову:
var json_verify = function(s){ try { JSON.parse(s); return true; } catch (e) { return false; }};
Таким образом, вы можете также использовать грязный клип для объекта JSON, например:
JSON.verify = function(s){ try { JSON.parse(s); return true; } catch (e) { return false; }};
По мере того, как это возможно, оно может не прерываться при ошибке.
if(resp) {
try {
resp = $.parseJSON(resp);
console.log(resp);
} catch(e) {
alert(e);
}
}
надеюсь, что это работает и для вас
var jsonstring='[{"ConnectionString":"aaaaaa","Server":"ssssss"}]';
if(((x)=>{try{JSON.parse(x);return true;}catch(e){return false}})(jsonstring)){
document.write("valide json")
}else{
document.write("invalide json")
}Из вступительного комментария я делаю вывод, что вариант использования определяет, является ли ответ HTML или JSON. В этом случае, когда вы получаете JSON, вам, вероятно, следует проанализировать его и обработать неверный JSON в какой-то момент в вашем коде. Помимо всего прочего, я полагаю, что вы хотели бы, чтобы ваш браузер информировал вас о том, следует ли ожидать JSON, но получен неверный JSON (как и пользователи по доверенности с каким-либо значимым сообщением об ошибке)!
Поэтому выполнять полное регулярное выражение для JSON не нужно (как было бы - по моему опыту - для большинства случаев использования). Возможно, вам лучше использовать что-то вроде ниже:
function (someString) {
// test string is opened with curly brace or machine bracket
if (someString.trim().search(/^(\[|\{){1}/) > -1) {
try { // it is, so now let see if its valid JSON
var myJson = JSON.parse(someString);
// yep, we're working with valid JSON
} catch (e) {
// nope, we got what we thought was JSON, it isn't; let handle it.
}
} else {
// nope, we're working with non-json, no need to parse it fully
}
}
это избавит вас от необходимости обрабатывать исключительные коды, отличные от JSON, и одновременно заботиться о duff json.
Вот версия для машинописи тоже:
JSONTryParse(input) {
try {
//check if the string exists
if (input) {
var o = JSON.parse(input);
//validate the result too
if (o && o.constructor === Object) {
return o;
}
}
}
catch (e) {
}
return false;
};
Вы можете использовать функцию javascript eval(), чтобы проверить, действительно ли она.
например.
var jsonString = '{ "Id": 1, "Name": "Coke" }';
var json;
try {
json = eval(jsonString);
} catch (exception) {
//It advisable to always catch an exception since eval() is a javascript executor...
json = null;
}
if (json) {
//this is json
}
В качестве альтернативы вы можете использовать функцию JSON.parse из json.org:
try {
json = JSON.parse(jsonString);
} catch (exception) {
json = null;
}
if (json) {
//this is json
}
Надеюсь, что это поможет.
ПРЕДУПРЕЖДЕНИЕ: eval() опасно, если кто-то добавляет вредоносный JS-код, так как он выполнит его. Убедитесь, что строка JSON заслуживает доверия, т.е. Вы получили ее из надежного источника.
Изменить. Для моего первого решения рекомендуется сделать это.
try {
json = eval("{" + jsonString + "}");
} catch (exception) {
//It advisable to always catch an exception since eval() is a javascript executor...
json = null;
}
Чтобы гарантировать json-ness. Если jsonString не является чистым JSON, eval выдаст исключение.
function get_json(txt)
{ var data
try { data = eval('('+txt+')'); }
catch(e){ data = false; }
return data;
}
Если есть ошибки, верните false.
Если ошибок нет, верните данные json
О, вы определенно можете использовать try catch, чтобы проверить, является ли это действительным JSON
Проверено на Firfox Quantom 60.0.1
используйте функцию внутри функции, чтобы протестировать JSON, и используйте этот вывод для проверки строки. слышит пример.
function myfunction(text){
//function for validating json string
function testJSON(text){
try{
if (typeof text!=="string"){
return false;
}else{
JSON.parse(text);
return true;
}
}
catch (error){
return false;
}
}
//content of your real function
if(testJSON(text)){
console.log("json");
}else{
console.log("not json");
}
}
//use it as a normal function
myfunction('{"name":"kasun","age":10}')
Функция IsJsonString(str), которая использует JSON.parse(str), в моем случае не работает.
Я пытался проверить вывод json из GraphiQL, он всегда возвращал false. К счастью, isJSON работает лучше:
var test = false;
$('body').on('DOMSubtreeModified', '.resultWrap', function() {
if (!test) {
var resultWrap = "{" + $('#graphiql .resultWrap').text().split("{").pop();
if isJSON(resultWrap) {test = !test;}
console.log(resultWrap);
console.log(resultWrap.isJSON());
}
});
Пример вывода:
THREE.WebGLRenderer 79
draw.js:170 {xxxxxxxxxx
draw.js:170 false
draw.js:170 {xxxxxxxxxx
draw.js:170 false
draw.js:170 {xxxxxxxxxx
draw.js:170 false
draw.js:170 {xxxxxxxxxx
draw.js:170 false
draw.js:170 {
draw.js:170 false
draw.js:170 { "PI": 3.141592653589793,
draw.js:170 false
draw.js:170 { "PI": 3.141592653589793, "time": 1570751209006,
draw.js:170 false
draw.js:170 { "PI": 3.141592653589793, "time": 1570751209006, "tick": 156,
draw.js:170 false
draw.js:170 { "PI": 3.141592653589793, "time": 1570751209006, "tick": 156, "tickr": 1.56,
draw.js:170 false
draw.js:170 { "PI": 3.141592653589793, "time": 1570751209006, "tick": 156, "tickr": 1.56, "fps": 41.666666666666664,
draw.js:170 false
draw.js:170 { "PI": 3.141592653589793, "time": 1570751209006, "tick": 156, "tickr": 1.56, "fps": 41.666666666666664, "width": 396.984,
draw.js:170 false
draw.js:170 { "PI": 3.141592653589793, "time": 1570751209006, "tick": 156, "tickr": 1.56, "fps": 41.666666666666664, "width": 396.984, "height": 327
draw.js:170 false
draw.js:170 { "PI": 3.141592653589793, "time": 1570751209006, "tick": 156, "tickr": 1.56, "fps": 41.666666666666664, "width": 396.984, "height": 327}
draw.js:170 false
draw.js:170 { "PI": 3.141592653589793, "time": 1570751209006, "tick": 156, "tickr": 1.56, "fps": 41.666666666666664, "width": 396.984, "height": 327}
draw.js:170 true
Я предпочитаю этот способ:
if (!typeof arg == 'object') {
//Not JSon
} else {
//Json
}