如何检查javascript中的有效大括号，编程问题？

在过去的几天里，我们一直在努力解决codewars的以下问题：

编写一个接受大括号字符串的函数，并确定大括号的顺序是否有效。如果字符串有效，则返回

true

；如果字符串无效，则返回

false

所有输入字符串都将是非空的，并且只包含括号、括号和大括号：

（）[]{}

什么是有效的？ 如果所有大括号都与正确的大括号匹配，则认为大括号字符串有效

例子 所以我真的被这一个的代码卡住了，这就是我到目前为止所拥有的：

function validBraces(braces){
    let opening = [ '(', '[', '{']
    let closing = [ ')', ']', '}']
    let count = 0
    const left = []
    const right = []

    // I generate left and right arrays, left w/the opening braces from the input, right w/ the closing
    for (let i = 0; i < braces.length; i++) {
        if (opening.includes(braces[i])) {
            left.push(braces[i])
        } else if (closing.includes(braces[i])) {
            right.push(braces[i])
        }
    }
    if (braces.length % 2 !== 0) {
        return false
    }
    // I know there's no point in doing this but at one point I thought I was finishing the program and thought I would 'optimize it' to exit early, probably this is dumb haha.
    if (left.length !== right.length) {
        return false
    }
    // The juicy (not juicy) part where I check if the braces make sense
    for (let i = 0; i < left.length; i++) {
    // If the list are made up of braces like  ()[]{} add one to counter
        if (opening.indexOf(left[i]) === closing.indexOf(right[i])) {
            count += 1
        } else // If left and right are mirrored add one to the counter
            if (opening.indexOf(left[i]) === closing.indexOf(right.reverse()[i])) {
                count += 1
            }
}
    //If the counter makes sense return true
    if (count === braces.length / 2) {
        return true
    } else { return false}
}


console.log(validBraces( "()" )) //true
console.log(validBraces("([])")) //true
console.log(validBraces( "[(])" )) //false
console.log(validBraces( "[(})" )) //false
console.log(validBraces( "[([[]])]" )) //true

函数validBraces（大括号）{
让opening=['（'，'['，'{']
让closing=['）'，']'，'}']
让计数=0
常量左=[]
const right=[]
//我生成左数组和右数组，左数组包含输入的左大括号，右数组包含右大括号
for（设i=0；i

一些评论：我知道我仍然没有检查这个例子（[]）（），但我想以某种方式将它分成两个较小的检查

如果你读到这一点，谢谢你。我希望能得到一些指导，尽管我不想让这个问题为我解决。由于这是一个6kyu问题，我可能在某种程度上过于复杂化了，如果是这样的话，我将非常感谢你给我一个如何更聪明地处理这个问题的提示

提前谢谢你！：祈祷：：祈祷：

var validBraces=（s）=>{
设objO={'（'：0，['：1，{'：2}；
设objC={'）：0']'：1'}'：2}；
让堆栈=[]；
对于（让i=0；i，如Dave所建议的，使用堆栈，我为其编写了代码：

var leftBraces="([{";
var rightBraces=")]}";

function checkBraces(braces) {
  var ok=true;
  var stack=[];
  for(var i=0; i<braces.length && ok; i++) {
    var brace=braces[i];
    if(leftBraces.includes(brace)) stack.push(brace);
    else {
      var leftBrace=stack.pop();
      if(leftBrace==undefined) ok=false;
      else if(leftBraces.indexOf(leftBrace)!=rightBraces.indexOf(brace)) ok=false;
    }
  }
  if(stack.length) ok=false;
  return ok;
}

var leftBraces=“（[{”；
var rightbrases=“）]}”；
函数复选框（大括号）{
var-ok=true；
var堆栈=[]；
对于（var i=0；iHell yeah！！我很高兴自己最终通过这里给我的一些提示找到了解决方案：


函数validBraces（大括号）{
让opening=['（'，'['，'{']
让closing=['）'，']'，'}']
设arr=[]
//console.log（closing.indexOf（大括号[“”]）==opening.indexOf（arr[“”]））
for（设i=0；i}
你可能想得太多了。归结起来就是推大括号开始，看到大括号结束时弹出，看看它们是否匹配。不确定这是否被允许，但我在youtube频道上制作的最后一个视频正好解决了这个问题：FWIW，不包括几行测试值，在20 LOC.Us左右打卡使用单个堆栈；不需要使用多个AFAICT。我想它可以降到大约一半，并保持可读性。您已经（大致）打开了正确的方法--简化问题，重新定义问题的本质。这回答了你的问题吗？各位，请记住OP明确地试图为自己解决这个问题。指出答案或提供解决方案，特别是过于复杂的答案，不是他们所要求的。似乎有点过度设计。很高兴你成功了：）T他唯一真正的“问题”（考虑到约束条件，问题不大）是，这会进行大量“隐藏”迭代（
包括
和多个
索引）.这就是为什么你会看到很多解决方案使用对象或
映射
。但是，正如我最近了解到的，使用对象/映射可能会对小集合造成性能损失，所以我猜这实际上比基于映射的解决方案快，尽管我还没有测试过。底线——工作做得好，热情很好，很好，你花了时间让我困惑如果可以的话，我会投票两次。那么，你能投票选出好的答案并选出最好的吗？希望是我的…：）
var leftBraces="([{";
var rightBraces=")]}";

function checkBraces(braces) {
  var ok=true;
  var stack=[];
  for(var i=0; i<braces.length && ok; i++) {
    var brace=braces[i];
    if(leftBraces.includes(brace)) stack.push(brace);
    else {
      var leftBrace=stack.pop();
      if(leftBrace==undefined) ok=false;
      else if(leftBraces.indexOf(leftBrace)!=rightBraces.indexOf(brace)) ok=false;
    }
  }
  if(stack.length) ok=false;
  return ok;
}