第 152 题：实现一个 normalize 函数，能将输入的特定的字符串转化为特定的结构化数据

[gauseen]

字符串仅由小写字母和 [] 组成，且字符串不会包含多余的空格。
示例一: 'abc' --> {value: 'abc'}
示例二：'[abc[bcd[def]]]' --> {value: 'abc', children: {value: 'bcd', children: {value: 'def'}}}

[Nolaaaaa]

let normalize = str => {
  let result = {}
  let c
  
  // 字符串转化为数组
  let arr = str.split(/[\[\]]/g).filter(Boolean)
  
  // 生成结构化数据
  arr.forEach((item, index) => {
    if(index != 0) {
      c.children = {}
      c.children.value = item
      c= c.children
    } else {
      result.value = item
      c= result
    }
  })
  
  return result
}
let str = '[abc[bcd[def]]]'
normalize(str)
// {value: 'abc', children: {value: 'bcd', children: {value: 'def'}}}

[linbinhuang]

const normalize = (str) => {
  var result = {}
  str.split(/[\[\]]/g).filter(Boolean).reduce((obj, item, index, a) => {
    obj.value = item
    if(index !== a.length -1) {
      return (obj.children = {})
    }
  }, result)
  return result
}

[flyfox11]

function normalize(str) {
	let arr = str.match(/\w+/g)
	let temp = {}
	let obj
	while(arr.length) {
		let item = arr.pop()
		temp.value = item
		obj && (temp.children = obj)
		if(arr.length) {
			obj = {...temp}
			temp = {}
		}else {
			obj = temp
		}
	}
	return obj
}

[quanibm]

const normalize = str => {
  const arr = str.split(/[\[\]]/).filter(Boolean);
  const createArr = arr => {
    return arr.reduce((obj, val, n, arr) => {
      arr.length > 1 ? (obj.children = createArr(arr.slice(1))) : "";
      obj.value = arr[0];
      return obj;
    }, {});
  };
  return createArr(arr);
};

[gauseen]

var normalize = (str) => {
  var list = str.match(/\w+/g)
  var obj = {}
  var curr = obj
  while (key = list.shift()) {
      curr.value = key
      if (list.length === 0) break
      curr.children = {}
      curr = curr.children
  }
  return obj
}

[yygmind]

字符串仅由小写字母和 [] 组成，且字符串不会包含多余的空格。
示例一: 'abc' --> {value: 'abc'}
示例二：'[abc[bcd[def]]]' --> {value: 'abc', children: {value: 'bcd', children: {value: 'def'}}}

[XiaoDHuang]

let normalize = (str) => {
    let arr = str.split(/[\[\]]/).filter(Boolean);
    let i = 0, obj = {}, cur = obj;
    while(i < arr.length) {
        if (i > 0) cur = cur.children = {};
        cur.value = arr[i];
        i ++;
    }

    return obj;
}

[lhyt]

function normalize(str, res = {}) {
  if (str) {
    if (str[0] === "[") {
      const exec = /^\[(\w+)(\[.*\]){0,1}\]$/.exec(str);
      if (exec) {
        const [, value, next] = exec;
        res.value = value;
        next && normalize(next, (res.children = {}));
      }
    } else if (!/(\[|\])/.test(str)) {
      res.value = str;
    }
  }
  return res;
}

// 测试用例
[
  "[a[b[c]]]",
  "",
  "asd",
  "[aads",
  "asdasd]",
  "[asddd]",
  "[a[d]",
  "[s[]]"
].reduce((acc, c) => ((acc[c] = normalize(c)), acc), {});

es5、纯算法:

function normalize(str) {
  if (!/(\[|\])/.test(str)) {
    return { value: str };
  }
  var len = str.length,
    quene = [],
    res = {},
    ret = res,
    current = "";
  for (var i = 0; i < len; i++) {
    var c = str[i];
    if (c === "[" || c === "]") {
      if (current) {
        quene.push(current);
        current = "";
      }
      if (c === "]") {
        var top = quene.shift();
        if (top) {
          res.value = top;
          if (quene.length) {
            res = res.children || (res.children = {});
          }
        }
      }
    } else {
      current += c;
    }
  }
  return ret;
}

[kukuxi]

function normalize(str) {
  if (!str) return {};
  const arr = str
    .split(/[\[\]]/g)
    .filter(Boolean)
    .reverse();
  return arr.reduce((acc, cur) => {
    const temp = {};
    if (acc.value) { //说明此时acc !== {}
      temp.children = acc;
    }
    temp.value = cur;
    return temp;
  }, {});
}

[jwdzzhz777]

function normalize(str) {
  let current, result;
  while (current = str.match(/\[([a-z]+)\]/)) {
    let [res, value] = current;
    result = result ? { value, children: result } : { value };
    str = str.replace(res, '');
  }
  if (!result) result = {value: str};
  return result;
}