如何在JavaScript中将字符串树解析为数组

Question

Let's say I get an API response that returns a tree-like structure like this:

"gw43g: (-95.147, 38.5818); " +
"jp987h: (" +
         "bvp7: (-97.450, 30.150); " +
         "7g8oi: (" +
                 "34ilht: (-82.192997, 29.39719); " +
                 "34hb1: (-122.25, 37.47)); " +
         "b238: (-71.0349, 42.2129)); " +
"ao8yh: (-90.147, 42.5818);"

Its a string.

Using JavaScript, I need to turn it into an array like this..

["(-95.147, 38.5818)",
  "(bvp7: (-97.450, 30.150); 7g8oi: (...)...)",
  "(-90.147, 42.5818)"]

..such that the innards of each pair of parenthesizes is an array item, no matter many nested parenthesizes are contained in the outermost pair.

I'm not having any luck, so I'm asking your your guy's help. Here's what I've tried.

function getCoords(str) {
    return str.split(';').map(function(s) {
        return s.substring(s.indexOf('(')+1, s.lastIndexOf(')'));
    });
}

..but that's way wrong. Feel free to call on any functional toolkits (underscore.js, etc). And no, this is not a homework assignment, it's for a book I'm writing. Thanks for any help!

Answer 1

You could use Array.prototype.reduce() like this:

 var str = "gw43g: (-95.147, 38.5818); " + "jp987h: (" + "bvp7: (-97.450, 30.150); " + "7g8oi: (" + "34ilht: (-82.192997, 29.39719); " + "34hb1: (-122.25, 37.47)); " + "b238: (-71.0349, 42.2129)); " + "ao8yh: (-90.147, 42.5818);" var cnt = 0; // keep count of opened brackets var result = Array.prototype.reduce.call(str, function(prev, curr) { if (curr === '(' && cnt++ === 0) prev.push(''); if (cnt > 0) prev[prev.length-1] += curr; if (curr === ')') cnt--; return prev; }, []); console.log(result); 

JSFiddle mirror

Answer 2

You should probably use a parser for this, but here's a quick and dirty solution that's kind of like a mini-parser:

var src = "gw43g: (-95.147, 38.5818) .... ";

var re = /(\w+:\s*\()|(\);?)|((?:(?!\w+:\s*\(|\);?).)+)/g;

var output = [];
var match;
var stackCount = 0;

while ((match = re.exec(src)))
{
    if (match[1]) {
        if (stackCount == 0) output.push('');
        stackCount++;
    }
    else if (match[2]) {
        stackCount--;
    }
    output[output.length-1] += match[0];
}
console.log(output);

jsFiddle

The regular expression splits tokens into three categories, a stack opener, a stack closer, or neutral. If it finds a stack starter and there is nothing on the stack it adds a new array item, if it finds a closer it brings the stack down by one. Until the stack is at zero, it will keep appending to the current array item.

I couldn't help it, so I went ahead and just finished the simple parser, so that the string is output as an tree where the root properties are the keys (gw43g), and each either has an X, Y value, or it is a branch on the tree.

function parseBody(str) { 
    // rey: http://rey.gimenez.biz/s/fxd02f
    var re = /\s+|(\w+)\s*:\s*\(|(\);?)|(([\-+]?\s*(?:\d*\.\d*|\d+))\s*,\s*([\-+]?\s*(?:\d*\.\d*|\d+)))/g;

    var output = [];
    var match;
    var newObj;
    var root = { children: { } }
    var branch = root;

    while ((match = re.exec(str)))
    {
        // key and open
        if (match[1]) {
            newObj = { parent: branch, children: { } };
            branch.children[match[1]] = newObj;
            // new stack
            branch = newObj;
        }
        // 
        else if (match[2]) {
            // move up stack
            branch = branch.parent;
        }
        else if (match[3]) {
            branch.X = parseFloat(match[4]);
            branch.Y = parseFloat(match[5]);
        }
    }

    return root;
}

jsFiddle

Regular Expression