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

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

如果完成并且堆栈中没有任何项目，则语法正常，否则返回索引或最后推送的打开字符的索引。

示例：

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('[[[[[[[[[[[[[[]]]]]]]]<<<<<<<<<<<>>>>>>>>>>>]]]]]]'+'[[[[[[[[[[[[[[]]]]]]]<<<<<<<<<<<>>>>>>>>>>>]}]]]]' + '>'));

Answer 2

执行此操作的算法是，找到一个开始符号，将其压入堆栈（或数组，无论如何）。查找另一个开头符号，将其推入堆栈。找到与堆栈顶部匹配的结束符号，将起始符号弹出堆栈。找到与堆栈顶部不匹配的结束符号，发现一个错误。找到一个结束符号，堆栈上没有任何内容，您发现了一个错误。到最后，堆栈上仍然有符号，您发现了一个错误。

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

2 个答案: