Question

我已经构建了一个根据某些输入返回"YES"或"NO"的函数。输入的是一串应保持平衡的方括号。

示例：

平衡-{[（）]}
非平衡-{[（]）}

该函数正在为此调用返回undefined。

isBalanced（'{[（]）}'）;

厌倦了调试。我敢肯定，循环中出了点问题。

function isBalanced(s) {
    let brackets = s.split('');
    let balanced = "YES";
    const closedBrackets = ')]}';
    const bracketCompliment = {
        '(' : ')',
        '[' : ']',
        '{' : '}'
    };
    for(let idx = 0; idx < brackets.length; idx++){
        const item = brackets.splice(0, 1)[0];
        if(closedBrackets.includes(item)){
            balanced = "NO";   
            return;
        }
        const closeIdx = brackets.indexOf(bracketCompliment[item]);
        const remainder = closeIdx % 2;
        if(closeIdx === -1 || remainder !== 0){
            balanced = "NO";
            return;
        } else{
            brackets.splice(closeIdx, 1);
        }
    }
    return balanced;
}

Answer 1

您应该return balanced;，不要return;

function isBalanced(s) {
  let brackets = s.split('');

  const closedBrackets = ')]}';

  const bracketCompliment = {
    '(': ')',
    '[': ']',
    '{': '}',
  };

  for (let idx = 0; idx < brackets.length; idx += 1) {
    const item = brackets.splice(0, 1)[0];

    if (closedBrackets.includes(item)) {
      return 'NO';
    }

    const closeIdx = brackets.indexOf(bracketCompliment[item]);

    if (closeIdx === -1 || closeIdx % 2 !== 0) {
      return 'NO';
    }
    
    brackets.splice(closeIdx, 1);
  }

  return 'YES';
}

console.log(isBalanced('{[(])}'));
console.log(isBalanced('{()}'));

Answer 2

我的解决方案：

function isBalanced (str) {
  const obj = {'{': '}', '[': '}', '(': ')'}

  // if (str.length % 2) return 'NO'
  if (obj[str[0]] === str[str.length - 1]) {
    if (str.length === 2) return 'YES'
    return isBalanced(str.slice(1, -1))
  }
  
  return 'NO'
}

console.log(isBalanced('{[(])}'));
console.log(isBalanced('{()}'));

Answer 3

这是解决您问题的另一种方法

let str = "{[()]}";

function isBalanced(str) {
    const s = str.replace(/[^{}\][()]/, '').split(""),
        codes = {'123': 125,'91': 93,'40': 41};
    if (s.length % 2 !== 0) return 'NO';
    const [first, last] = [s.splice(0, s.length / 2), s];
    return first.every((e,i) => codes[e.charCodeAt(0)] === last[last.length - (i+1)].charCodeAt(0)) ? 'YES' : 'NO'
}

console.log(isBalanced(str));

Answer 4

如果您将return放在函数中，则该函数将一直停在那里，直到到达代码的那部分，并且它将返回您在该return语句中输入的内容，因为您没有给出循环内那些return中的任何值都会返回undefined。

您可以通过简单地删除这些行并在代码末尾仅保留一个返回符来避免这种情况：

function isBalanced(s) {
    let brackets = s.split('');
    let balanced = "YES";
    const closedBrackets = ')]}';
    const bracketCompliment = {
        '(' : ')',
        '[' : ']',
        '{' : '}'
    };
    for(let idx = 0; idx < brackets.length; idx++){
        const item = brackets.splice(0, 1)[0];
        if(closedBrackets.includes(item)){
            balanced = "NO";   
        }
        const closeIdx = brackets.indexOf(bracketCompliment[item]);
        const remainder = closeIdx % 2;
        if(closeIdx === -1 || remainder !== 0){
            balanced = "NO";
        } else{
            brackets.splice(closeIdx, 1);
        }
    }
    return balanced;
}

现在，您的函数将等待直到循环完成，并将返回最后分配给balanced的所有内容。

我希望这会有所帮助。

注意：如果您想打破循环，可以使用break代替return。

Answer 5

仅当输入字符串实际处于平衡状态时，才返回balanced的值。在两种情况下，如果您设置balanced = "NO"，都将立即返回无值。如果将这些return语句替换为break语句，该函数将按预期运行。

function isBalanced(s) {
    let brackets = s.split('');
    let balanced = "YES";
    const closedBrackets = ')]}';
    const bracketCompliment = {
        '(' : ')',
        '[' : ']',
        '{' : '}'
    };
    for (let idx = 0; idx < brackets.length; idx++) {
      const item = brackets.splice(0, 1)[0];
      if (closedBrackets.includes(item)) {
        balanced = "NO";
        break;
      }
      const closeIdx = brackets.indexOf(bracketCompliment[item]);
      const remainder = closeIdx % 2;
      if (closeIdx === -1 || remainder !== 0){
        balanced = "NO";
        break;
      } else{
        brackets.splice(closeIdx, 1);
      }
    }

    return balanced;
}

JavaScript循环神秘地更新字符串的值

5 个答案: