修复无效JSON的最有效方法

Question

修复无效JSON的最有效方法

12

我陷入了一个不可能的境地。我有来自外太空的JSON数据（他们绝对不会改变它）。以下是JSON数据：

{
    user:'180111',
    title:'I\'m sure "E pluribus unum" means \'Out of Many, One.\' \n\nhttp://en.wikipedia.org/wiki/E_pluribus_unum.\n\n\'',
    date:'2007/01/10 19:48:38',
    "id":"3322121",
    "previd":112211,
    "body":"\'You\' can \"read\" more here [url=http:\/\/en.wikipedia.org\/?search=E_pluribus_unum]E pluribus unum[\/url]'s. Cheers \\*/ :\/",
    "from":"112221",
    "username":"mikethunder",
    "creationdate":"2007\/01\/10 14:04:49"
}

我说：“这根本不是有效的JSON。”他们回答道：“嗯！但JavaScript可以读取它而没有投诉。”

<html>
<script type="text/javascript">
    var obj = {"PUT JSON FROM UP THERE HERE"};

    document.write(obj.title);
    document.write("<br />");
    document.write(obj.creationdate + " " + obj.date);
    document.write("<br />");
    document.write(obj.body);
    document.write("<br />");
</script>
<body>
</body>
</html>

问题

我需要通过.NET(4)读取和解析这个字符串，但它破坏了Json.org C#部分中提到的14个库中的3个（没有尝试其他库）。为了解决这个问题，我编写了以下函数来修复单引号和双引号的问题。

public static string JSONBeautify(string InStr){
    bool inSingleQuote = false;
    bool inDoubleQuote = false;
    bool escaped = false;

    StringBuilder sb = new StringBuilder(InStr);
    sb = sb.Replace("`", "<°)))><"); // replace all instances of "grave accent" to "fish" so we can use that mark later. 
                                        // Hopefully there is no "fish" in our JSON
    for (int i = 0; i < sb.Length; i++) {
        switch (sb[i]) {

            case '\\':
                if (!escaped)
                    escaped = true;
                else 
                    escaped = false;
                break;
            case '\'':
                if (!inSingleQuote && !inDoubleQuote) {
                    sb[i] = '"';            // Change opening single quote string markers to double qoute
                    inSingleQuote = true;
                } else if (inSingleQuote && !escaped) {
                    sb[i] = '"';            // Change closing single quote string markers to double qoute
                    inSingleQuote = false;
                } else if (escaped) {
                    escaped = false;
                }
                break;
            case '"':
                if (!inSingleQuote && !inDoubleQuote) {
                    inDoubleQuote = true;   // This is a opening double quote string marker
                } else if (inSingleQuote && !escaped) {
                    sb[i] = '`';            // Change unescaped double qoute to grave accent
                } else if (inDoubleQuote && !escaped) {
                    inDoubleQuote = false; // This is a closing double quote string marker
                } else if (escaped) {
                    escaped = false;
                }
                break;
            default:
                escaped = false;
                break;
        }
    }
    return sb.ToString()
        .Replace("\\/", "/")        // Remove all instances of escaped / (\/) .hopefully no smileys in string
        .Replace("`", "\\\"")       // Change all "grave accent"s to escaped double quote \"
        .Replace("<°)))><", "`")   // change all fishes back to "grave accent"
        .Replace("\\'","'");        // change all escaped single quotes to just single quote
}

现在JSONlint只会抱怨属性名称，我可以使用JSON.NET和SimpleJSON库来解析上述JSON。

问题：我确信我的代码不是修复上述JSON的最佳方式。是否存在任何可能导致我的代码出错的情况？有更好的方法吗？

- AaA

那个 JSON 在很多方面都是错误的。不过我们可以修复它。 - Mouser

2

我完全同意你的观点，但是由于他们来自外太空，不会说我们的语言，让他们理解这是错误的...嗯，几乎是不可能的。 - AaA

如果你需要一个库来完成这个任务，你可以尝试使用https://www.npmjs.com/package/jsonrepair，或者你也可以尝试https://ray.run/tools/json-repairer - undefined

@LucGagan，就像Bistro的回答中的3行代码那样简单的事情，我觉得你不需要用到库。顺便说一句，那是一次性的数据迁移，已经完成8年了。 - undefined

3个回答

2

这个怎么样：

 string AlienJSON = "your alien JSON";
 JavaScriptSerializer js = new JavaScriptSerializer();
 string ProperJSON = js.Serialize(js.DeserializeObject(AlienJSON));

或者在反序列化后直接使用对象，而不是将其转换回字符串并传递给JSON解析器以获得额外的麻烦。

正如Mouser也提到的那样，您需要使用System.Web.Script.Serialization，该模块可以通过在项目中包含system.web.extensions.dll来获得，并且为此您需要将项目属性中的目标框架更改为.NET Framework 4。

编辑

消耗反序列化对象的技巧是使用dynamic。

JavaScriptSerializer js = new JavaScriptSerializer();
dynamic obj = js.DeserializeObject(AlienJSON);

在你的问题中要使用 JSON，只需要简单地使用：

string body = obj["body"];

如果你的 JSON 是一个数组

if (obj is Array) {
    foreach(dynamic o in obj){
        string body = obj[0]["body"];
        // ... do something with it
    }
}

- Bistro

我如何在反序列化后使用对象？ - AaA

你尝试过将JavaScript字符串放入.Net字符串中吗？这是行不通的。你需要从外部加载它，因此需要使用WebClient。 - Mouser

0

这是一个我写的函数，可以修复损坏的 JSON：

function fixJSON(json){
    function bulkRegex(str, callback){
        if(callback && typeof callback === 'function'){
            return callback(str);
        }else if(callback && Array.isArray(callback)){
            for(let i = 0; i < callback.length; i++){
                if(callback[i] && typeof callback[i] === 'function'){
                    str = callback[i](str);
                }else{break;}
            }
            return str;
        }
        return str;
    }
    if(json && json !== ''){
        if(typeof json !== 'string'){
            try{
                json = JSON.stringify(json);
            }catch(e){return false;}
        }
        if(typeof json === 'string'){
            json = bulkRegex(json, false, [
                str => str.replace(/[\n\t]/gm, ''),
                str => str.replace(/,\}/gm, '}'),
                str => str.replace(/,\]/gm, ']'),
                str => {
                    str = str.split(/(?=[,\}\]])/g);
                    str = str.map(s => {
                        if(s.includes(':') && s){
                            let strP = s.split(/:(.+)/, 2);
                            strP[0] = strP[0].trim();
                            if(strP[0]){
                                let firstP = strP[0].split(/([,\{\[])/g);
                                firstP[firstP.length-1] = bulkRegex(firstP[firstP.length-1], false, p => p.replace(/[^A-Za-z0-9\-_]/, ''));
                                strP[0] = firstP.join('');
                            }
                            let part = strP[1].trim();
                            if((part.startsWith('"') && part.endsWith('"')) || (part.startsWith('\'') && part.endsWith('\'')) || (part.startsWith('`') && part.endsWith('`'))){
                                part = part.substr(1, part.length - 2);
                            }
                            part = bulkRegex(part, false, [
                                p => p.replace(/(["])/gm, '\\$1'),
                                p => p.replace(/\\'/gm, '\''),
                                p => p.replace(/\\`/gm, '`'),
                            ]);
                            strP[1] = ('"'+part+'"').trim();
                            s = strP.join(':');
                        }
                        return s;
                    });
                    return str.join('');
                },
                str => str.replace(/(['"])?([a-zA-Z0-9\-_]+)(['"])?:/g, '"$2":'),
                str => {
                    str = str.split(/(?=[,\}\]])/g);
                    str = str.map(s => {
                        if(s.includes(':') && s){
                            let strP = s.split(/:(.+)/, 2);
                            strP[0] = strP[0].trim();
                            if(strP[1].includes('"') && strP[1].includes(':')){
                                let part = strP[1].trim();
                                if(part.startsWith('"') && part.endsWith('"')){
                                    part = part.substr(1, part.length - 2);
                                    part = bulkRegex(part, false, p => p.replace(/(?<!\\)"/gm, ''));
                                }
                                strP[1] = ('"'+part+'"').trim();
                            }
                            s = strP.join(':');
                        }
                        return s;
                    });
                    return str.join('');
                },
            ]);
            try{
                json = JSON.parse(json);
            }catch(e){return false;}
        }
        return json;
    }
    return false;
}

- SwiftNinjaPro

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Mouser · Accepted Answer

您需要通过JavaScript来运行此操作。在.net中启动一个JavaScript解析器。将字符串作为输入传递给JavaScript，并使用JavaScript的本地JSON.stringify进行转换：

obj = {
    "user":'180111',
    "title":'I\'m sure "E pluribus unum" means \'Out of Many, One.\' \n\nhttp://en.wikipedia.org/wiki/E_pluribus_unum.\n\n',
    "date":'2007/01/10 19:48:38',
    "id":"3322121",
    "previd":"112211",
    "body":"\'You\' can \"read\" more here [url=http:\/\/en.wikipedia.org\/?search=E_pluribus_unum]E pluribus unum[\/url]'s. Cheers \\*/ :\/",
    "from":"112221",
    "username":"mikethunder",
    "creationdate":"2007\/01\/10 14:04:49"
}

console.log(JSON.stringify(obj));
document.write(JSON.stringify(obj));

请注意，你得到的字符串（或者说对象）并不是有效的JSON格式，不能使用JSON库进行解析。它需要先被转换为有效的JSON格式。但它是有效的JavaScript。

为了完成这个回答：你可以在.NET中使用JavaScriptSerializer。对于这个解决方案，你需要以下程序集：

System.Net

System.Web.Script.Serialization

var webClient = new WebClient();
string readHtml = webClient.DownloadString("uri to your source (extraterrestrial)");
var a = new JavaScriptSerializer();

Dictionary<string, object> results = a.Deserialize<Dictionary<string, object>>(readHtml);