Javascript 从原始字符串形成树或节点

我将以下内容作为字符串

 var string = "@anno1[ data1 xyz @anno2[data2  @anno3[data3] data4] data5 @anno4[data6] data7]"

我想把它转换成一个对象，如下所示：

var childs = [ 
        {
            name : '@anno1',
            text : 'data1 xyz data2 data3 data4 data5 data6 data7',
        }, 
        {
            name : '@anno2',
            text : 'data2 data3 data4'
        }, 
        {
            name : '@anno3',
            text : 'data3'
        }, 
        {
            name : '@anno4',
            text : 'data6'
        } 
]

我尝试过很多方法，但都没有成功，提前谢谢

下面是我尝试过的java代码

    import java.util.HashMap;
import java.util.Map;

public class ExpressionTree {

    static Map <String, String> resultMap = new HashMap<String, String>(16);

    public static void main(String args[]) {
        // String exp = "[data1 xyz @anno2[data2 @anno3[data3] data4] data5 @anno4[data6] data7]";

        String exp = "@anno1[ data1 xyz @anno2[data2  @anno3[data3] data4] data5 @anno4[data6] data7 ]";

        parseRecursively(exp);
    }

    private static void parseRecursively(String exp) {

        String annotation = null;
        String annotationValue = null;

        if (exp.startsWith("@")) {
            int dataStartIndex = exp.indexOf("[");
            annotation = exp.substring(0, dataStartIndex);
            annotationValue = exp.substring(0 + dataStartIndex, exp.lastIndexOf("]")+1).trim();

            System.out.println(annotation);
            System.out.println(annotationValue);

            resultMap.put(annotation, annotationValue);

            parseRecursively(annotationValue);

        } else {
            int annotationStartIndex = exp.indexOf("@");
            int dataStartIndex = exp.substring(1).indexOf("[");

            if( -1 != annotationStartIndex || -1 != dataStartIndex)
            {
                annotation = exp.substring(annotationStartIndex, dataStartIndex+1).trim();

                String nextData = exp.substring(0 + dataStartIndex + 1).trim();
                String tmpNextData = nextData;

                int countOfOpenBrackets = 0;
                for (int i = 0; tmpNextData.charAt(i) != ']'; i++) {
                    // System.out.println(tmpNextData.charAt(i));
                    if (tmpNextData.charAt(i) == '[') {
                        countOfOpenBrackets++;
                    }
                    // tmpNextData = tmpNextData.substring(1);
                }

                tmpNextData = nextData;
                int endIndexOfCurrentData = 0;

                for (int i = 0; i < tmpNextData.length() && endIndexOfCurrentData == 0; i++) {
                    // System.out.println(tmpNextData.charAt(i));
                    if (tmpNextData.charAt(i) == ']') {
                        countOfOpenBrackets--;
                    }
                    if (countOfOpenBrackets == 0) {
                        endIndexOfCurrentData = i + 1;
                    }
                    // tmpNextData = tmpNextData.substring(1);
                }

                annotationValue = nextData.substring(0, endIndexOfCurrentData).trim();

                System.out.println(annotation);
                System.out.println(annotationValue);

                resultMap.put(annotation, annotationValue);

                parseRecursively(annotationValue);
            }
        }
        System.out.println(resultMap);
    }
}

import java.util.HashMap；
导入java.util.Map；
公共类表达式树{
静态映射结果映射=新HashMap（16）；
公共静态void main（字符串参数[]）{
//String exp=“[data1 xyz@anno2[data2@anno3[data3]data4]data5@anno4[data6]data7]”；
字符串exp=“@anno1[data1 xyz@anno2[data2@anno3[data3]data4]data5@anno4[data6]data7]”；
递归解析（exp）；
}
递归解析私有静态void（字符串exp）{
字符串注释=null；
字符串annotationValue=null；
如果（exp.startsWith（“@”））{
int dataStartIndex=exp.indexOf（“[”）；
注释=exp.substring（0，dataStartIndex）；
annotationValue=exp.substring（0+dataStartIndex，exp.lastIndexOf（“]）+1）.trim（）；
System.out.println（注释）；
System.out.println（注释值）；
结果映射put（注释，注释值）；
递归解析（注释值）；
}否则{
int annotationStartIndex=exp.indexOf（“@”）；
int dataStartIndex=exp.substring（1）.indexOf（“[”）；
如果（-1！=注释开始索引| |-1！=数据开始索引）
{
annotation=exp.substring（annotationStartIndex，dataStartIndex+1）.trim（）；
字符串nextData=exp.substring（0+dataStartIndex+1）.trim（）；
字符串tmpNextData=nextData；
int countofopen方括号=0；
对于（int i=0；tmpNextData.charAt（i）！=']'；i++）{
//System.out.println（tmpNextData.charAt（i））；
if（tmpNextData.charAt（i）='['）{
countofopen括号++；
}
//tmpNextData=tmpNextData.substring（1）；
}
tmpNextData=nextData；
int-endIndexOfCurrentData=0；
对于（int i=0；i

下面是一个JavaScript（ES6）解决方案：

函数对象（字符串）{
“严格使用”；
const tokens=string.match（/[\[\]]|[^\s\[\]]+/g），
结果=[]；
设i=0；
函数recurse（）{
常量字=[]；
让obj；
while（i
。作为控制台包装器{max height:100%！important；top:0；}
您尝试过哪些解决方案？是什么让人们对voteHi失望，@hbagdi编辑了答案，您现在可以看到，您能解释一下当前的方法而不是仅仅发布整个代码吗？如果有文本解释该方法，则更容易理解。你是在寻找javascript或java解决方案吗？你是天才，感谢alotI在文本旁边有新行和制表符，这也应该包含在文本中如果你说只有文字空间分隔项，而不是制表符或换行符，然后在正则表达式中，用一个空格替换
\s
（与所有这些匹配）。