类似的东西：
var jsonString = '{ "Id": 1, "Name": "Coke" }';
//should be true
IsJsonString(jsonString);
//should be false
IsJsonString("foo");
IsJsonString("<div>foo</div>")
解决方案不应包含try / catch。我们中的一些人打开“中断所有错误”，他们不喜欢调试器打破那些无效的JSON字符串。
答案 0 :(得分：724)
使用JSON.parse之类的JSON解析器：
function IsJsonString(str) {
try {
JSON.parse(str);
} catch (e) {
return false;
}
return true;
}
答案 1 :(得分：399)
我知道我对这个问题已经迟了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;
};
答案 2 :(得分：140)
首先发表评论。问题是没有使用try/catch
如果您不介意使用它，请阅读以下答案。
在这里，我们只使用正则表达式检查JSON字符串，它在大多数情况下都有效，而不是所有情况。
浏览https://github.com/douglascrockford/JSON-js/blob/master/json2.js
中的第450行有一个正则表达式可以检查有效的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进行了比上面更高级的解析，但仍然基于正则表达式替换（来自comment of @Mrchief）
答案 3 :(得分：45)
// 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。
答案 4 :(得分：17)
我使用了一种非常简单的方法来检查字符串是否是有效的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，因为null变量的类型是object。
每次都有效。 ：）
答案 5 :(得分：11)
在原型js中我们有方法isJSON。试试那个
http://api.prototypejs.org/language/string/prototype/isjson/
偶http://www.prototypejs.org/learn/json
"something".isJSON();
// -> false
"\"something\"".isJSON();
// -> true
"{ foo: 42 }".isJSON();
// -> false
"{ \"foo\": 42 }".isJSON();
答案 6 :(得分：10)
这是我的工作代码：
function IsJsonString(str) {
try {
var json = JSON.parse(str);
return (typeof json === 'object');
} catch (e) {
return false;
}
}
答案 7 :(得分：4)
来自Prototype framework String.isJSON definition here
/**
* 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, \"key2@e\" : \"val\"}" ) )
console.log("this is not a json", isJSON( "{ \"key\" : 1, \"key2@e\" : pippo }" ) )
答案 8 :(得分：3)
isValidJsonString-检查有效的json字符串
JSON数据类型-字符串，数字，对象（JSON对象），数组，布尔值，空 （https://www.json.org/json-en.html）
虚假值-false，0，-0、0n，“，null，未定义，NaN -（https://developer.mozilla.org/en-US/docs/Glossary/Falsy）
JSON.parse
适用于number，boolean，null和有效的json字符串不会引起任何错误。请参考下面的示例
在解析undefined，对象，数组等时中断
function isValidJsonString(jsonString){
if(!(jsonString && typeof jsonString === "string")){
return false;
}
try{
JSON.parse(jsonString);
return true;
}catch(error){
return false;
}
}
答案 9 :(得分：3)
这个答案可以降低trycatch语句的成本。
我使用JQuery解析JSON字符串并使用trycatch语句来处理异常，但是为不可解析的字符串抛出异常会减慢我的代码，所以我使用简单的Regex来检查字符串是否是可能的JSON字符串通过检查它的语法而没有下降，然后我使用常规方法通过使用JQuery解析字符串：
if (typeof jsonData == 'string') {
if (! /^[\[|\{](\s|.*|\w)*[\]|\}]$/.test(jsonData)) {
return jsonData;
}
}
try {
jsonData = $.parseJSON(jsonData);
} catch (e) {
}
我将先前的代码包装在递归函数中以解析嵌套的JSON响应。
答案 10 :(得分：2)
您可以使用javascript eval()功能验证它是否有效。
e.g。
var jsonString = '{ "Id": 1, "Name": "Coke" }';
var json;
try {
json = eval(jsonString);
} catch (exception) {
//It's advisable to always catch an exception since eval() is a javascript executor...
json = null;
}
if (json) {
//this is json
}
或者，您可以使用json.org中的JSON.parse功能：
try {
json = JSON.parse(jsonString);
} catch (exception) {
json = null;
}
if (json) {
//this is json
}
希望这有帮助。
警告：eval() 危险如果有人添加了恶意JS代码，因为它会执行它。确保JSON字符串可信赖，即您从可靠来源获得它。
编辑对于我的第一个解决方案，建议执行此操作。
try {
json = eval("{" + jsonString + "}");
} catch (exception) {
//It's advisable to always catch an exception since eval() is a javascript executor...
json = null;
}
保证 json-ness。如果jsonString不是纯JSON，则eval将抛出异常。
答案 11 :(得分：2)
也许它会有用：
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：对象，对象，字符串，字符串
答案 12 :(得分：2)
我想我知道你为什么要避免这种情况。但也许试试＆amp;赶上！==尝试＆amp;抓住。 ; 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; }};
尽可能封装，但错误可能不会中断。
答案 13 :(得分：2)
if(resp) {
try {
resp = $.parseJSON(resp);
console.log(resp);
} catch(e) {
alert(e);
}
}
希望这也适合你
答案 14 :(得分：1)
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")
}
答案 15 :(得分：1)
以下是打字稿版本：
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;
};
答案 16 :(得分：1)
我从开头评论中推断，用例描述了响应是HTML还是JSON。在这种情况下，当你做接收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's 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's handle it.
}
} else {
// nope, we're working with non-json, no need to parse it fully
}
}
这应该可以避免异常处理有效的非JSON代码和同时处理duff json。
答案 17 :(得分：0)
哦，你绝对可以使用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}')
答案 18 :(得分：0)
使用IsJsonString(str)的函数JSON.parse(str)在我的情况下不起作用。
我尝试验证GraphiQL的json输出，该输出始终返回false。幸运的是，isJSON的效果更好：
fib 0示例输出：
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());
}
});
答案 19 :(得分：0)
适用于喜欢.NET约定的“ try”函数的人，这些函数返回布尔值并处理包含结果的byref参数。如果不需要out参数，则可以省略它，而只需使用返回值即可。
StringTests.js
2>&1StringUtils.js
var obj1 = {};
var bool1 = '{"h":"happy"}'.tryParse(obj1); // false
var obj2 = {};
var bool2 = '2114509 GOODLUCKBUDDY 315852'.tryParse(obj2); // false
var obj3 = {};
if('{"house_number":"1","road":"Mauchly","city":"Irvine","county":"Orange County","state":"California","postcode":"92618","country":"United States of America","country_code":"us"}'.tryParse(obj3))
console.log(obj3);
ObjectUtils.js
String.prototype.tryParse = function(jsonObject) {
jsonObject = jsonObject || {};
try {
if(!/^[\[{]/.test(this) || !/[}\]]$/.test(this)) // begin / end with [] or {}
return false; // avoid error handling for strings that obviously aren't json
var json = JSON.parse(this);
if(typeof json === 'object'){
jsonObject.merge(json);
return true;
}
} catch (e) {
return false;
}
}
答案 20 :(得分：0)
如果您要处理来自AJAX（或XMLHttpRequest）调用的响应，对我有用的是check the response content type并相应地解析或不解析内容。
答案 21 :(得分：0)
function get_json(txt)
{ var data
try { data = eval('('+txt+')'); }
catch(e){ data = false; }
return data;
}
如果有错误，请返回false。
如果没有错误，请返回json数据
答案 22 :(得分：0)
我认为我会在一个实际示例的背景下添加我的方法。在处理Memjs传入和传出的值时，我使用了类似的检查方法，因此，即使保存的值可能是字符串，数组或对象，Memjs也会期望使用字符串。该函数首先检查键/值对是否已经存在，如果存在，则进行预检查以确定在返回值之前是否需要解析值：
function checkMem(memStr) {
let first = memStr.slice(0, 1)
if (first === '[' || first === '{') return JSON.parse(memStr)
else return memStr
}
否则，将调用回调函数来创建值，然后对结果进行检查以查看是否需要在进入Memjs之前对值进行字符串化，然后返回来自回调的结果。
async function getVal() {
let result = await o.cb(o.params)
setMem(result)
return result
function setMem(result) {
if (typeof result !== 'string') {
let value = JSON.stringify(result)
setValue(key, value)
}
else setValue(key, result)
}
}
完整的代码如下。当然，这种方法假定输入/输出的数组/对象的格式正确（即不会出现“ {{key：'testkey']”之类的东西），因为所有正确的验证都是在键/值对到达之前完成的此功能）。而且，您只将字符串输入到memjs中，而不是整数或其他非对象/数组类型。
async function getMem(o) {
let resp
let key = JSON.stringify(o.key)
let memStr = await getValue(key)
if (!memStr) resp = await getVal()
else resp = checkMem(memStr)
return resp
function checkMem(memStr) {
let first = memStr.slice(0, 1)
if (first === '[' || first === '{') return JSON.parse(memStr)
else return memStr
}
async function getVal() {
let result = await o.cb(o.params)
setMem(result)
return result
function setMem(result) {
if (typeof result !== 'string') {
let value = JSON.stringify(result)
setValue(key, value)
}
else setValue(key, result)
}
}
}
答案 23 :(得分：0)
保持简单
function isValidJsonString(tester) {
//early existing
if(/^\s*$|undefined/.test(tester) || !(/number|object|array|string|boolean/.test(typeof tester)))
{
return false;
};
//go ahead do you parsing via try catch
return true;
};答案 24 :(得分：-8)
非常简单的单行代码（但采用Hacky方法）
if (expected_json.id === undefined){
// not a json
}
else{
// json
}
注意：仅当您期望某些内容是JSON字符串时，此方法才有效 像身份证我正在将其用于API并期望结果在 JSON或某些错误字符串。