jQuery / JavaScript正确解析字符串

Question

Recently, I've been attempting to emulate a small language in jQuery and JavaScript, yet I've come across what I believe is an issue. I think that I may be parsing everything completely wrong.
In the code:

@name Testing
@inputs
@outputs
@persist 
@trigger 
print("Test")

The current way I am separating and parsing the string is by splitting all of the code into lines, and then reading through this lines array using searches and splits. For example, I would find the name using something like:

if(typeof lines[line] === 'undefined')
{
}
else
{
    if(lines[line].search('@name') == 0)
    {
        name = lines[line].split(' ')[1];
    }
}

But I think that I may be largely wrong on how I am handling parsing.
While reading through examples on how other people are handling parsing of code blocks like this, it appeared that people parsed the entire block, instead of splitting it into lines as I do. I suppose the question of the matter is, what is the proper and conventional way of parsing things like this, and how do you suggest I use it to parse something such as this?

Answer 1

In simple cases like this regular expressions is your tool of choice:

matches = code.match(/@name\s+(\w+)/)
name = matches[1]

To parse "real" programming languages regexps are not powerful enough, you'll need a parser, either hand-written or automatically generated with a tool like PEG .

Answer 2

A general approach to parsing, that I like to take often is the following:

1. loop through the complete block of text, character by character.
2. if you find a character that signalizes the start of one unit, call a specialized subfunction to parse the next characters.
3. within each subfunction, call additional subfunctions if you find certain characters
4. return from every subfunction when a character is found, that signalizes, that the unit has ended.

Here is a small example:

var text = "@func(arg1,arg2)"

function parse(text) {
    var i, max_i, ch, funcRes;

    for (i = 0, max_i = text.length; i < max_i; i++) {
        ch = text.charAt(i);

        if (ch === "@") {
            funcRes = parseFunction(text, i + 1);
            i = funcRes.index;
        }
    }
    console.log(funcRes);
}

function parseFunction(text, i) {
    var max_i, ch, name, argsRes;

    name = [];    
    for (max_i = text.length; i < max_i; i++) {
        ch = text.charAt(i);

        if (ch === "(") {
            argsRes = parseArguments(text, i + 1);
            return {
                name: name.join(""),
                args: argsRes.arr,
                index: argsRes.index
            };
        } 
        name.push(ch);
    }
}

function parseArguments(text, i) {
    var max_i, ch, args, arg;

    arg = [];
    args = [];
    for (max_i = text.length; i < max_i; i++) {
        ch = text.charAt(i);

        if (ch === ",") {
            args.push(arg.join(""));
            arg = [];
            continue;
        } else if (ch === ")") {
            args.push(arg.join(""));
            return {
                arr: args,
                index: i
            };
        }
        arg.push(ch);
    }
}

FIDDLE

this example just parses function expressions, that follow the syntax "@functionName(argumentName1, argumentName2, ...)". The general idea is to visit every character exactly once without the need to save current states like "hasSeenAtCharacter" or "hasSeenOpeningParentheses", which can get pretty messy when you parse large structures.

Please note that this is a very simplified example and it misses all the error handling and stuff like that, but I hope the general idea can be seen. Note also that I'm not saying that you should use this approach all the time. It's a very general approach, that can be used in many scenerios. But that doesn't mean that it can't be combined with regular expressions for instance, if it, at some part of your text, makes more sense than parsing each individual character.

And one last remark: you can save yourself the trouble if you put the specialized parsing function inside the main parsing function, so that all functions have access to the same variable i .