如何在不使用Try / Catch的情况下检查字符串在JavaScript中是否为有效的JSON字符串

2020/09/24 05:01 · javascript ·  · 0评论

就像是:

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使用正则表达式检查字符串,它在大多数情况下(并非在所有情况下)都适用。

看看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的新版本比上面进行了更高级的解析,但仍基于正则表达式替换(来自@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({})falseisJSON('{}')true

要检查某物是否为ArrayObject已解析的 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({})trueisAO('{}')false

这是我的工作代码:

function IsJsonString(str) {
  try {
    var json = JSON.parse(str);
    return (typeof json === 'object');
  } catch (e) {
    return 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,因为null变量的类型是object。

每次都有效。:)

在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, \"key2@e\" : \"val\"}" ) )

console.log("this is not a json", isJSON( "{ \"key\" : 1, \"key2@e\" : pippo }" ) )

这个答案减少了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响应。

我想我知道您为什么要避免这种情况。但是也许尝试并抓住!==尝试并抓住。; 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; }};

由于已尽可能概括,因此可能不会因错误而中断。

也许会有用:

    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:对象,对象,字符串,字符串

这也是打字稿版本:

JSONTryParse(input: any) {
    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: any) {
    }

    return false;
};

您可以使用javascript eval()函数来验证其是否有效。

例如

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.parse函数从json.org

try {
  json = JSON.parse(jsonString);
} catch (exception) {
  json = null;
}

if (json) {
  //this is json
}

希望这可以帮助。

警告如果有人添加了恶意的JS代码,将eval()危险,因为它将执行该代码。确保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将引发异常。

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'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的麻烦。

if(resp) {
    try {
        resp = $.parseJSON(resp);
        console.log(resp);
    } catch(e) {
        alert(e);
    }
}

希望这也对你有用

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上测试

在函数内部使用function来测试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)不起作用。

我试图验证来自
GraphiQL的 json输出,它始终返回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

对于喜欢“尝试”函数的.Net约定的人,这些函数返回布尔值并处理包含结果的byref参数。如果不需要out参数,则可以省略它,而只需使用返回值即可。

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

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

ObjectUtils.js

Object.defineProperty(Object.prototype, 'merge', {
  value: function(mergeObj){
    for (var propertyName in mergeObj) {
      if (mergeObj.hasOwnProperty(propertyName)) {
        this[propertyName] = mergeObj[propertyName];
      }      
    }
    return this;
  },
  enumerable: false, // this is actually the default
});

如果您正在处理来自AJAX(或XMLHttpRequest)调用的响应,那么对我有用的是检查响应内容类型并相应地解析或不解析该内容。

非常简单的单行代码(但采用Hacky方法)

if (expected_json.id === undefined){
   // not a json
}
else{
   // json
}

注意:仅当您期望某些东西是像id这样的JSON字符串时,这才有效。我将其用于API,并期望结果为JSON或某些错误字符串。

本文地址:http://javascript.askforanswer.com/ruhezaibushiyongtry-catchdeqingkuangxiajianchazifuchuanzaijavascriptzhongshifouweiyouxiaodejsonzifu.html
文章标签: ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!