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

Question

字符串仅由小写字母和 [] 组成，且字符串不会包含多余的空格。

示例一：

'abc' --> {value: 'abc'}

示例二：

'[abc[bcd[def]]]' --> {value: 'abc', children: {
value: 'bcd', children: {value: 'def'}}
}

Answer 1

 return (obj.children = {})

return (obj.children = {}) 这个啥意思 呀 还是看不懂 为啥

简化一下代码，你可以这么理解：

const normalize = (str) => {
  var result = {};
  str
    .split(/[[]]/g)
    .filter(Boolean)
    .reduce((obj, item) => {
      obj.value = item;
      let children = {};
      obj.children = children;
      return children;
    }, result);
  return result;
};

代码写的6，顶一个，但是用这种极简的骚操作写法是为了减少代码量么，可读性不考虑么

Answer 2

 return (obj.children = {})

return (obj.children = {}) 这个啥意思 呀 还是看不懂 为啥

简化一下代码，你可以这么理解：

const normalize = (str) => {
  var result = {};
  str
    .split(/[[]]/g)
    .filter(Boolean)
    .reduce((obj, item) => {
      obj.value = item;
      let children = {};
      obj.children = children;
      return children;
    }, result);
  return result;
};

Answer 3

 return (obj.children = {})

return (obj.children = {}) 这个啥意思 呀 还是看不懂 为啥

Answer 4

function normalize(s) {
    let arr = s.match(/w+/g)
    let result
    while(arr.length) {
        let cur = arr.pop()
        let temp = {value: cur}
        if(result) {
            temp.children = result
        }
        result = temp
    }
    return result
}


// 测试
var s = 'abc'
normalize(s) // {value: "abc"}

s = '[abc[bcd[def]]]'
normalize(s) 
// {value: 'abc', children: {value: 'bcd', children: {value: 'def'}}}

更过编程算法题可见 JavaScript-Algorithms

Answer 5

function normalize(str) {
      const list = str.match(/w+/g)
      function fn(list) {
        if(list.length === 1){
          return {
            value: list[0]
          }
        }
        let res = {}
        const item = list.shift();
        res = {
          value: item,
          children: fn(list)
        }
        return res
      }
      return fn(list)
 }

Answer 6

var str = '[abc[bcd[def]]]';
console.log(fn(str));
function fn(strs) {
	var arr = strs.replace('[', '').replace(/]/g, '').split('[');
	// console.log('arr: ', arr);
	var res = {};
	var pointer = res;
	for (var i = 0; i < arr.length; i ++) {
		pointer.value = arr[i];
		if (i < arr.length - 1) {
			pointer.children = {};
			pointer = pointer.children;
		}
	}
	return res;
}

Answer 7

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;
}

Answer 8

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;
  }, {});
}

Answer 9

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;
}

Answer 10

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;
}

Answer 11

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

Answer 12

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
}

Answer 13

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);
};

Answer 14

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
}

Answer 15

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
}

Answer 16

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'}}}