在codewars上做了一道括号婚配的题目。

题目

推断字符串中的{}、[]、()三种括号是不是婚配，须要斟酌嵌套的状况。

例子：

validBraces("(){}[]")     // true 
validBraces("(}")         // false 
validBraces("[(])")       // false 
validBraces("([{}])")     // true 

Solution

这个题目的最基础只要两种状况，一种是并列的，即没有嵌套的状况，如()[]{};另一种状况就是嵌套的状况，如{[()]}。第一种状况是比较简单的，有难度的是第二种状况。存在嵌套的状况的解决要领，是起首婚配最内里的括号对，即我们常说的从内部最先崩溃。

第一种要领：

function validBraces(braces){
  while(/\(\)|\[\]|\{\}/g.test(braces)){
    braces = braces.replace(/\(\)|\[\]|\{\}/g,"")
  }
  return !braces.length;
}

这类要领，查找成对的括号，然后将成对相邻的括号替换成空字符串，也就是说删除。末了推断字符串的长度是不是为0。是，则示意完整婚配，不然，比婚配。
实在，这类计划就是典范的“从内部最先崩溃”。我们以{[()]}为例，你视察一下，如今只要最内里的()才是成对且相邻的，当把()替换成空字符串以后，[]变成了成对且相邻的，然后再将其替换成空字符串。就这样一向轮回地查找，直到再也找不到成对且相邻的括号为止。

第二种要领：

function validBraces(braces){
  let leftBraReg = /[\(\{\[]/, 
    // 栈
      stack = [],
      bracket, rightBracket
  braces = braces.split('')
  for(bracket of braces) {
    if(leftBraReg.test(bracket)) {
      stack.push(bracket)
    }
    else {
      switch (bracket) {
          case ')':
          rightBracket = stack.pop()
          if(rightBracket !=='(') {
              return false
          }
          break
        case ']':
          rightBracket = stack.pop()
          if(rightBracket !=='[') {
              return false
          }
          break
        case '}':
          rightBracket = stack.pop()
          if(rightBracket !=='{') {
              return false
          }
          break
      }
    }
  }
  return stack.length === 0 ? true : false
}

这类要领，是将左半边括号，即(、[、{存入栈stack中，当遍历到右半边括号，即)、]、}的时刻，stack实行出栈操纵，然后将出栈的左半边括号与遍历到的有半边括号婚配，看是不是为与其相婚配的另半边括号。假如遍历完了，则推断栈的长度，为0，则婚配，不然，比婚配。
我们一样以{[()]}为例，前三项，即{、[、(入栈，当遍历到)的时刻，位于栈顶的'(‘后出栈与)比较，看是不是婚配。背面的]、}也是一样原理。

结语

如今逐渐发明，数据结构和正则表达式非常重要（这里的解决要领就离别用到了），虽然日常平凡用得少，到一道有运用场景，你就会发明数据结构和正则表达式的壮大了。