从文本中提取 JSON

您不能使用正则表达式从任意文本中提取 JSON。由于正则表达式通常不足以验证 JSON(除非您可以使用 PCRE(，它们也无法匹配它 - 如果可以的话，它们也可以验证 JSON。

但是，如果您知道 JSON 的顶级元素始终是对象或数组，则可以采用以下方法：

• 找到字符串中的第一个开口({或[(和最后一个结束(}或](大括号。
• 尝试使用 JSON.parse() 解析该文本块(包括大括号(。如果成功，则完成并返回解析的结果。
• 使用上一个右大括号并尝试解析该字符串。如果成功，您将再次完成。
• 重复此操作，直到没有大括号或当前左大括号之前的大括号。
• 找到步骤 1 中的第一个左大括号之后的第一个左大括号。如果未找到任何字符串，则字符串不包含 JSON 对象/数组，您可以停止。
• 转到步骤 2。

下面是一个提取 JSON 对象并返回该对象及其位置的函数。如果你真的也需要顶级数组，它应该是扩展：

function extractJSON(str) {
    var firstOpen, firstClose, candidate;
    firstOpen = str.indexOf('{', firstOpen + 1);
    do {
        firstClose = str.lastIndexOf('}');
        console.log('firstOpen: ' + firstOpen, 'firstClose: ' + firstClose);
        if(firstClose <= firstOpen) {
            return null;
        }
        do {
            candidate = str.substring(firstOpen, firstClose + 1);
            console.log('candidate: ' + candidate);
            try {
                var res = JSON.parse(candidate);
                console.log('...found');
                return [res, firstOpen, firstClose + 1];
            }
            catch(e) {
                console.log('...failed');
            }
            firstClose = str.substr(0, firstClose).lastIndexOf('}');
        } while(firstClose > firstOpen);
        firstOpen = str.indexOf('{', firstOpen + 1);
    } while(firstOpen != -1);
}
var obj = {'foo': 'bar', xxx: '} me[ow]'};
var str = 'blah blah { not {json but here is json: ' + JSON.stringify(obj) + ' and here we have stuff that is } really } not ] json }} at all';
var result = extractJSON(str);
console.log('extracted object:', result[0]);
console.log('expected object :', obj);
console.log('did it work     ?', JSON.stringify(result[0]) == JSON.stringify(obj) ? 'yes!' : 'no');
console.log('surrounding str :', str.substr(0, result[1]) + '<JSON>' + str.substr(result[2]));

演示(在nodejs环境中执行，但也应该在浏览器中工作(：https://paste.aeum.net/show/81/

对于其他正在寻找(像我一样(从文本中提取 JSON 字符串的人(即使它们无效(，您可以查看此 Gulp 插件 https://www.npmjs.com/package/gulp-extract-json-like。它搜索所有看起来格式类似于 JSON 字符串的字符串。

创建文件夹并安装包。

mkdir project && cd project
npm install gulp gulp-extract-json-like

创建一个文件./gulpfile.js并将以下内容放入其中：

var gulp = require('gulp');
var extractJsonLike = require('gulp-extract-json-like');
gulp.task('default', function () {
  return gulp.src('file.txt')
    .pipe(extractJsonLike())
    .pipe(gulp.dest('dist'));
});

创建一个名为 ./file.txt 的文件，其中包含您的文本并运行以下命令。

gulp

找到的 JSON 字符串将位于./dist/file.txt 中。

作为 ajax 响应的一部分返回，为什么不使用浏览器的原生 JSON 解析(小心陷阱(？还是jQuery JSON Parsing？

如果 JSON 完全被文本弄乱，恕我直言，这确实是一个设计问题 - 如果你可以更改它，我强烈建议这样做(即返回单个 JSON 对象作为响应，文本作为对象的属性(。

如果没有，那么使用正则表达式将绝对是一场噩梦。JSON自然非常灵活，确保准确的解析不仅耗时，而且浪费。我可能会在开头/结尾放置内容标记，并希望最好。但是您将对验证错误等敞开大门。

我以自己的方式做了这件事。这当然不是万无一失的，但为了提高查看包含单行 JSON 对象的日志的能力，这对我有用。我不是JavaScript开发人员，所以请随时告诉我为什么这很糟糕哈哈。

//PrettyPrint() will attempt to find JSON strings in the log message. If it finds them, it will replace the raw ugly JSON with pretty printted JSON
function PrettyPrint() {
    var jsonStrings = [];
    var prettyLogElement = document.getElementById('PrettyLogDisplayOnly');
    try {
        var rawLogMessage = $("textarea[id^='LogMessage']").val();
        if (rawLogMessage == null) {
            throw "Failed to extract original log message.";
        }
        jsonStrings = ExtractJsonStrings(rawLogMessage);
        
        var modifiedLogMessage = "<pre>" + rawLogMessage + "'"</pre>";
        for (const jsonString of jsonStrings) {
            try {
                var jsonObject = JSON.parse(jsonString);
                var prettyPrintJsonString = JSON.stringify(jsonObject, null, 2);
                modifiedLogMessage = modifiedLogMessage.replace(jsonString, prettyPrintJsonString);
            }
            catch (err) {
                modifiedLogMessage += "Failed to pretty print: " + jsonString;
            }
        }
    }
    catch (err) {
        if (err == null || err == undefined) {
            err = "Failed to parse.";
        }
        else
        {
            err = "Failed to parse. Details: " + err;
        }
        
        //TODO: instead of showing the error here, show it as an error banner?
        rawLogMessage = "<br/>Failed to beautify JSON objects. Details: " + err + " Displaying raw log message.<br/>" +
            "<br/>-------------------------------------------------------------------------------------<br/><br/>"
            + rawLogMessage;;
        prettyLogElement.innerHTML += rawLogMessage;
        return;
    }
    prettyLogElement.innerHTML = modifiedLogMessage;
}
function ExtractJsonStrings(rawLogMessage) {
    var jsonStrings = [];
    var locationOfCurrentCurly = -1;
    
    while (true) {
        var countOfOpenCurlyBraces = 0;
        var countOfClosedCurlyBraces = 0;
        var locationOfFirstUnescapedOpeningCurly = GetLocationOfNextUnescapedOpeningCurlyBrace(rawLogMessage, locationOfCurrentCurly + 1);
        if (locationOfFirstUnescapedOpeningCurly == -1) {
            break; //we found all the JSON strings
        }
        else
        {
            locationOfCurrentCurly = locationOfFirstUnescapedOpeningCurly;
            countOfOpenCurlyBraces++;
        }
        
        while (countOfOpenCurlyBraces != countOfClosedCurlyBraces)
        {
            if (countOfClosedCurlyBraces > countOfOpenCurlyBraces)
            {
                throw "Found more closing curly braces than opening curly braces.";
            }
            
            var startSearchAtIndex = locationOfCurrentCurly + 1
            locationOfCurrentCurly = GetLocationOfNextUnescapedCurlyBrace(rawLogMessage, startSearchAtIndex);
            if (locationOfCurrentCurly == -1) {
                throw "Failed to find the 'next' curly brace.";
            }
            var curly = rawLogMessage.charAt(locationOfCurrentCurly);
            if (curly === '{') {
                countOfOpenCurlyBraces++;
            } else if (curly === '}') {
                countOfClosedCurlyBraces++;
            } else {
                throw "Unknown character found when curly brace expected.";
            }
        }
        
        var possiblyCorrectlyFormattedJsonString = rawLogMessage.substring(locationOfFirstUnescapedOpeningCurly, locationOfCurrentCurly + 1);
        jsonStrings.push(possiblyCorrectlyFormattedJsonString);
    }
    return jsonStrings;
}
//this will only find the next opening brace {
function GetLocationOfNextUnescapedOpeningCurlyBrace(rawLogMessage, startIndex) {
    var regexNextUnescapedOpeningCurly = /(?<!'')({)/i;
    return RegexStringExtract(rawLogMessage, startIndex, regexNextUnescapedOpeningCurly)
}
//this will find the next opening OR closing brace { }
function GetLocationOfNextUnescapedCurlyBrace(rawLogMessage, startIndex) {
    var regexNextUnescapedCurly = /(?<!'')({|})/i;
    return RegexStringExtract(rawLogMessage, startIndex, regexNextUnescapedCurly)
}
function RegexStringExtract(stringToSearch, startIndex, regex) {
    var substring = stringToSearch.substring(startIndex);
    var regexMatch = regex.exec(substring);
    if (regexMatch) {
        return startIndex + regexMatch.index;
    }
    else {
        return -1;
    }
}