Синтаксический анализ ввода массива в JavaScript с помощью Parsimmon - PullRequest
Новая
       61

Синтаксический анализ ввода массива в JavaScript с помощью Parsimmon

0 голосов
/ 25 апреля 2018

Я смотрел на то, как я могу проанализировать массив в JavaScript, который вводит пользователь, например. '[1, 2, 3, 4, [1, 2, 3], "test", "test hello"]'. Теперь я нашел Parsimmon, который кажется хорошим инструментом для этого. Библиотека поставляется с примером парсера JSON, реализованного следующим образом: 

let JSONParser = P.createLanguage({
            // This is the main entry point of the parser: a full JSON value.
            value: r =>
                P.alt(
                    r.object,
                    r.array,
                    r.string,
                    r.number,
                    r.null,
                    r.true,
                    r.false
                ).thru(parser => whitespace.then(parser)),

            // The basic tokens in JSON, with optional whitespace afterward.
            lbrace: () => word("{"),
            rbrace: () => word("}"),
            lbracket: () => word("["),
            rbracket: () => word("]"),
            comma: () => word(","),
            colon: () => word(":"),

            // `.result` is like `.map` but it takes a value instead of a function, and
            // `.always returns the same value.
            null: () => word("null").result(null),
            true: () => word("true").result(true),
            false: () => word("false").result(false),

            // Regexp based parsers should generally be named for better error reporting.
            string: () =>
                token(P.regexp(/"((?:\\.|.)*?)"/, 1))
                    .map(interpretEscapes)
                    .desc("string"),

            number: () =>
                token(P.regexp(/-?(0|[1-9][0-9]*)([.][0-9]+)?([eE][+-]?[0-9]+)?/))
                    .map(Number)
                    .desc("number"),

            // Array parsing is just ignoring brackets and commas and parsing as many nested
            // JSON documents as possible. Notice that we're using the parser `json` we just
            // defined above. Arrays and objects in the JSON grammar are recursive because
            // they can contain any other JSON document within them.
            array: r => r.lbracket.then(r.value.sepBy(r.comma)).skip(r.rbracket),

            // Object parsing is a little trickier because we have to collect all the key-
            // value pairs in order as length-2 arrays, then manually copy them into an
            // object.
            pair: r => P.seq(r.string.skip(r.colon), r.value),

            object: r =>
                r.lbrace
                    .then(r.pair.sepBy(r.comma))
                    .skip(r.rbrace)
                    .map(pairs => {
                        let object = {};
                        pairs.forEach(pair => {
                            let [key, value] = pair;
                            object[key] = value;
                        });
                        return object;
                    })
        });

Теперь я попытался реализовать свой собственный анализатор для Array без использования функции createLanguage, пока это моя реализация: 

let comma = word2(',');
let lBracket = word2('[');
let rBracket = word2(']');
let arrayParser = P.lazy(
            () =>
                // P.seq(
                lBracket.then(
                    P.alt(
                        P.digits,
                        // stringParser.trim(P.optWhitespace).sepBy(P.string(','))
                        // P.digits.sepBy1(P.string(',')),
                        arrayParser
                    ).thru(parser => P.optWhitespace.then(parser)).sepBy(comma)
                ).skip(
                    rBracket.trim(P.optWhitespace)
                )
            // )
        );

Реализация работает для разбора следующего: 

'[1, 2, 3, 4]'

но не для разбора вложенного массива: 

'[1, 2, 3, [1, 2, 3], 4]'

Я хотел бы понять, что я делаю неправильно, если есть кто-то, кто готов ответить.

Спасибо!

...