Question

我有一个字符串包含（不是是）JSON编码的数据，如下例所示：

foo([1, 2, 3], "some more stuff")
    |        |
  start     end   (of JSON-encoded data)

我们在应用程序中使用的完整语言嵌套了JSON编码的数据，而其他语言则是微不足道的（只是递归的东西）。在递归解析器中从左到右解析这样的字符串时，我知道当我遇到JSON编码的值时，就像这里从索引4开始的[1, 2, 3]一样。解析这个子字符串后，我需要知道结束位置继续解析字符串的其余部分。

我想将这个子字符串传递给Qt5中经过充分测试的JSON解析器，如QJsonDocument。但是当读取the documentation时，不可能只将子字符串解析为JSON，这意味着只要解析的数据结束（在此处使用]之后）控制返回而不报告解析错误。另外，我需要知道结束位置以继续解析我自己的东西（这里剩下的字符串是, "some more stuff")）。

为此，我习惯使用自定义JSON解析器，它通过引用获取当前位置，并在完成解析后更新它。但由于它是业务应用程序的安全关键部分，我们不想再坚持使用我自己设计的解析器了。我的意思是QJsonDocument，所以为什么不使用它。（我们已经使用过Qt5。）

作为一种解决方法，我正在考虑这种方法：

让QJsonDocument解析从当前位置开始的子字符串（无效的JSON）
错误报告意外字符，这是JSON之外的某个位置
让QJsonDocument再次解析，但这次是具有正确结束位置的子字符串

第二个想法是编写一个“JSON end scanner”，它接受整个字符串，一个起始位置并返回JSON编码数据的结束位置。这也需要解析，因为不匹配的括号/括号可以出现在字符串值中，但与完全手工制作的JSON解析器相比，编写（和使用）这样的类应该更容易（也更安全）。

有没有人有更好的主意？

Answer 1

我使用Spirit Qi基于http://www.ietf.org/rfc/rfc4627.txt推出了一个快速解析器[*]。

它实际上并不解析为AST，但是它会解析所有JSON有效负载，这实际上比这里要求的要多一些。

示例 here (http://liveworkspace.org/code/3k4Yor$2) 输出：

Non-JSON part of input starts after valid JSON: ', "some more stuff")'

基于OP给出的测试：

const std::string input("foo([1, 2, 3], \"some more stuff\")");

// set to start of JSON
auto f(begin(input)), l(end(input));
std::advance(f, 4);

bool ok = doParse(f, l); // updates f to point after the start of valid JSON

if (ok) 
    std::cout << "Non-JSON part of input starts after valid JSON: '" << std::string(f, l) << "'\n";

我已经测试了其他几个更复杂的JSON文档（包括多行）。

一些评论：

我使用基于迭代器的解析器，因此很容易使用Qt字符串（？）
如果您要禁止多行片段，请将该队长从qi::space更改为qi::blank
有一个关于数字解析的一致性快捷方式（请参阅TODO）不会影响此答案的有效性（请参阅注释）。

[*]从技术上讲，这更像是一个解析器 stub ，因为它不会转化为其他东西。它基本上是一个lexer承担了太多的工作：）

完整的样本代码：

// #define BOOST_SPIRIT_DEBUG
#include <boost/spirit/include/qi.hpp>

namespace qi = boost::spirit::qi;

template <typename It, typename Skipper = qi::space_type>
    struct parser : qi::grammar<It, Skipper>
{
    parser() : parser::base_type(json)
    {
        // 2.1 values
        value = qi::lit("false") | "null" | "true" | object | array | number | string;

        // 2.2 objects
        object = '{' >> -(member % ',') >> '}';
        member = string >> ':' >> value;

        // 2.3 Arrays
        array = '[' >> -(value % ',') >> ']';

        // 2.4.  Numbers
        // Note out spirit grammar takes a shortcut, as the RFC specification is more restrictive:
        //
        // However non of the above affect any structure characters (:,{}[] and double quotes) so it doesn't
        // matter for the current purpose. For full compliance, this remains TODO:
        //
        //    Numeric values that cannot be represented as sequences of digits
        //    (such as Infinity and NaN) are not permitted.
        //     number = [ minus ] int [ frac ] [ exp ]
        //     decimal-point = %x2E       ; .
        //     digit1-9 = %x31-39         ; 1-9
        //     e = %x65 / %x45            ; e E
        //     exp = e [ minus / plus ] 1*DIGIT
        //     frac = decimal-point 1*DIGIT
        //     int = zero / ( digit1-9 *DIGIT )
        //     minus = %x2D               ; -
        //     plus = %x2B                ; +
        //     zero = %x30                ; 0
        number = qi::double_; // shortcut :)

        // 2.5 Strings
        string = qi::lexeme [ '"' >> *char_ >> '"' ];

        static const qi::uint_parser<uint32_t, 16, 4, 4> _4HEXDIG;

        char_ = ~qi::char_("\"\\") |
               qi::char_("\x5C") >> (       // \ (reverse solidus)
                   qi::char_("\x22") |      // "    quotation mark  U+0022
                   qi::char_("\x5C") |      // \    reverse solidus U+005C
                   qi::char_("\x2F") |      // /    solidus         U+002F
                   qi::char_("\x62") |      // b    backspace       U+0008
                   qi::char_("\x66") |      // f    form feed       U+000C
                   qi::char_("\x6E") |      // n    line feed       U+000A
                   qi::char_("\x72") |      // r    carriage return U+000D
                   qi::char_("\x74") |      // t    tab             U+0009
                   qi::char_("\x75") >> _4HEXDIG )  // uXXXX                U+XXXX
               ;

        // entry point
        json = value;

        BOOST_SPIRIT_DEBUG_NODES(
                (json)(value)(object)(member)(array)(number)(string)(char_));
    }

  private:
    qi::rule<It, Skipper> json, value, object, member, array, number, string;
    qi::rule<It> char_;
};

template <typename It>
bool tryParseAsJson(It& f, It l) // note: first iterator gets updated
{
    static const parser<It, qi::space_type> p;

    try
    {
        return qi::phrase_parse(f,l,p,qi::space);
    } catch(const qi::expectation_failure<It>& e)
    {
        // expectation points not currently used, but we could tidy up the grammar to bail on unexpected tokens
        std::string frag(e.first, e.last);
        std::cerr << e.what() << "'" << frag << "'\n";
        return false;
    }
}

int main()
{
#if 0
    // read full stdin
    std::cin.unsetf(std::ios::skipws);
    std::istream_iterator<char> it(std::cin), pte;
    const std::string input(it, pte);

    // set up parse iterators
    auto f(begin(input)), l(end(input));
#else
    const std::string input("foo([1, 2, 3], \"some more stuff\")");

    // set to start of JSON
    auto f(begin(input)), l(end(input));
    std::advance(f, 4);
#endif

    bool ok = tryParseAsJson(f, l); // updates f to point after the end of valid JSON

    if (ok) 
        std::cout << "Non-JSON part of input starts after valid JSON: '" << std::string(f, l) << "'\n";
    return ok? 0 : 255;
}

使用QJsonDocument将子字符串解析为JSON

1 个答案:

完整的样本代码：