javascript - 如何编写识别不平衡括号的函数

Question

我正在尝试编写一个函数来检查语法是否正确。如果正确，则返回“ok”，否则返回错误的索引。到目前为止，如果错误出现在第一个索引或最后一个索引处，我的代码就可以正常工作。发现中间的错误是我发现的困难。这是我的代码。

function syntaxError(syntax) {

  let arr = syntax.split('').join()
  let arr1 = [];
  let arr2 = [];
  let result;

  //Error if the first index contain a closing braces

  if (arr[0] === '>' || arr[0] === ']' || arr[0] === '}' || arr[0] === ')') {
    result = 0
  };

  if (arr === "") {
    result = 'ok'
  };

  //Error if its just a single brace

  if (arr.length === 1) {
    result = 0
  };

  //Error if the last index contain an opening braces

  if (arr.slice(-1) === '<' || arr.slice(-1) === '[' || arr.slice(-1) === '{' || arr.slice(-1) === '(') {
    result = indexOf(arr.slice(-1))
  };

  let char = arr[i];

  if (char == '[' || char == '{' || char == '<' || char == '(') {
    arr1.push(char)
  } else {
    arr2.push(char);
  }

  if (arr1.length === 0 || arr2.length === 0) {
    result = 0
  }

  if (arr1.length === arr2.length) {
    result = 'ok'

  }

  return result
}

下面的例子应该返回 95

('[[[[[[[[[[[[[[]]]]]]]]<<<<<<<<<<<>>>>>>>>>>>]]]]]]'+'[[[[[[[[[[[[[[]]]]]]]

<<<<<<<<<<<>>>>>>>>>>>]}]]]]' + '>')

Answer 1

您可以为每个开始字符的索引获取一个数组，如果找到相关的结束字符，则将其弹出。

如果完成并且堆栈没有项目，则语法是正确的，否则返回索引或最后压入的开始字符的索引。

Example:

code        comment
----------- ---------------------------
[][[[]][][]
[]          balanced
  [         error, this returns later 2
   [[]]     balanced
       []   balanced
         [] balanced
            finally a missing ]

function syntaxError(syntax) {
    const
        isOpening = c => /[<[{(]/.test(c),
        isClosing = c => /[>\]})]/.test(c),
        open = { '>': '<', ']': '[', '}': '{', ')': '(' };

    var stack = [],
        index,
        finished = Array
            .from(syntax)
            .every((c, i) => {
                var temp = stack[stack.length - 1];
                if (isOpening(c)) {
                    if (temp && temp.c === c) {
                        temp.indices.push(i);
                    } else {
                        stack.push({ c, indices: [i] });
                    }
                    return true;
                }
                if (isClosing(c)) {
                    if (temp && temp.c === open[c]) {
                        temp.indices.pop();
                        if (!temp.indices.length) stack.pop();
                    } else {
                       index = stack.length ? stack.pop().indices.pop() : i;
                       return false;
                    }
                }
                return true;
            });

    return finished && !stack.length
        ? 'ok'
        : index === undefined
            ? stack.pop().indices.pop()
            : index;
}

console.log(syntaxError('[][][[{}]]'));  // ok

console.log(syntaxError(')'));
//                       0

console.log(syntaxError('[][][[{<}]]'));
//                       01234567

console.log(syntaxError('[][[[]][][]'));
//                       012

console.log(syntaxError('[[[[[[[[[[[[[[]]]]]]]]<<<<<<<<<<<>>>>>>>>>>>]]]]]]'+'[[[[[[[[[[[[[[]]]]]]]<<<<<<<<<<<>>>>>>>>>>>]}]]]]' + '>'));