function tokensAreBalanced(string) {
  var asymmetricTokens = "[]{}()",
    symmetricTokens = '"',
    stack = [],
    i, character, tokenPosition;

  for(i = 0; character = string[i]; i++) {
    tokenPosition = asymmetricTokens.indexOf(character);

    if(tokenPosition >= 0) {
      if(tokenPosition % 2 === 0) {
        stack.push(asymmetricTokens[tokenPosition + 1]); // push next expected token
      } else if(stack.length === 0 || stack.pop() !== character) {
        return false;
      }
    } else {
      if(symmetricTokens.includes(character)) {
        if(stack.length > 0 && stack[stack.length - 1] === character) {
          stack.pop();
        } else {
          stack.push(character);
        }
      }
    }
  }

  return stack.length === 0;
}


console.log('("back-to-school)"', tokensAreBalanced('("back-to-school)"'));

console.log('("back-to-school)', tokensAreBalanced('("back-to-school)'));

console.log('("back-to-school")', tokensAreBalanced('("back-to-school")'));

console.log('(ele AND car) OR ("ele car)")', tokensAreBalanced('(ele AND car) OR ("ele car)")'));

这会以两种方式执行push()或"的pop()检查。

• 如果堆栈为空或堆栈中最后一个字符不等于"，则将此"插入堆栈
• 如果stack不是空的并且stack中的最后一个字符等于"，那么pop()就是stack中的"。这样做是因为我在这里做了一种贪婪的匹配，因为"对于已经栈"意味着"..."中的表达式被求值了。所以，我们可以安全地匹配这2个"，然后继续下一个。

工作很好，但让我知道，如果它失败的任何情况。

function areQuotesAndParenthesesBalanced(s){
	var pairs = {
		'}':'{',
		']':'[',
		')':'(',
	};

	var stack = [];

	for(var i = 0;i < s.length;++i){
		switch(s.charAt(i)){
			case '[': case '{':case '(':
				stack.push(s.charAt(i));
			break;
			case ']': case '}':case ')':
				if(isStackEmpty(stack) || peek(stack) !== pairs[s.charAt(i)]) return false;
				stack.pop();
			break;
			case '"':
				if(isStackEmpty(stack) || peek(stack) !== s.charAt(i)){
					stack.push(s.charAt(i));
				}else{
					stack.pop();
				}
		}
	}

	return isStackEmpty(stack);
}

function isStackEmpty(s){
	return s.length === 0;
}

function peek(s){
	return s[s.length-1];
}


var tests = {
				'("back-to-school")':true,
				'"(back-to-school)"':true,
				'("back-to-school)"':false,
				'("back-to-school)':false,
				'"["["["[]"]"]"]"':true,
				'"["]""':false,
				'"[]"""':true,
				'""""':true,
				'""':true,
				'"':false,
				'""[("")]""':true,
				'""[("")]':true,
				'"["["["[]"]"[""]]"]':false,
				'"[]"[({})]""':true,
				'"[{}"]':false
			};

for(var each_test in tests){
	var res = areQuotesAndParenthesesBalanced(each_test);
	console.log(each_test + " --> " + (res === tests[each_test] ? "ok" : "not ok") + " , expected : " + tests[each_test]);
}

输出

("back-to-school") --> ok , expected : true
"(back-to-school)" --> ok , expected : true
("back-to-school)" --> ok , expected : false
("back-to-school) --> ok , expected : false
"["["["[]"]"]"]" --> ok , expected : true
"["]"" --> ok , expected : false
"[]""" --> ok , expected : true
"""" --> ok , expected : true
"" --> ok , expected : true
" --> ok , expected : false
""[("")]"" --> ok , expected : true
""[("")] --> ok , expected : true
"["["["[]"]"[""]]"] --> ok , expected : false
"[]"[({})]"" --> ok , expected : true
"[{}"] --> ok , expected : false

您可以尝试将一个有序元组放在堆栈上，并基于此进行检查。

[(,"],
[",)],
[(,"],
[",)]

== ("")("") example of a balanced stack.

[",(],
[",(],
[),"],
[),"]

== "("()")" another balanced stack

[(,"],
[),"]

== (")" trivial unbalanced stack

[(,)] <- trivial item, can ignore in implementation
[","] <- trivial item, can ignore in implementation

[",(],
[),(],
[),"]

== "()()" balanced stack

我太累了，无法真正实现它，但希望它能给你一些想法和说明性的例子，我会在睡一觉后重温它。

我建议通过删除所有带引号的子字符串来简化输入。引号的行为不同，因为引号内的括号没有被特殊处理，而是作为普通字符处理。通过首先删除每个带引号的部分，这个“问题”从一开始就解决了。还有不相关的字符（既不是圆括号也不是引号）。这样，我们只剩下一个带有括号的字符串，并且可能只出现一个引号，后者会立即使输入无效。
下面的代码类似于@nice_dev的答案，实现了该操作，并将pairs取反;它还将撇号作为可选分隔符来处理：

function areQuotesAndParenthesesBalanced(s) {
    const pairs = {
        '{':'}',
        '[':']',
        '(':')',
    };

    const stack = [""]; // Dummy
    for (const token of s.replace(/"[^"]*"|'[^']*'|[^"'{}()[\]]+/g, "")) {
        if (token in pairs) {
            stack.push(pairs[token]);
        } else {
            if (stack.at(-1) !== token) return false;
            stack.pop();
        }
    }
    return stack.length == 1; // Empty
}

// Same tests as in the answer of @nice_dev:
const tests = {
    '("back-to-school")': true,
    '"(back-to-school)"': true,
    '("back-to-school)"': false,
    '("back-to-school)': false,
    '"["["["[]"]"]"]"': true,
    '"["]""': false,
    '"[]"""': true,
    '""""': true,
    '""': true,
    '"': false,
    '""[("")]""': true,
    '""[("")]': true,
    '"["["["[]"]"[""]]"]': false,
    '"[]"[({})]""': true,
    '"[{}"]': false
};

for (const each_test in tests){
    const res = areQuotesAndParenthesesBalanced(each_test);
    console.log(`${each_test} --> ${res === tests[each_test] ? "ok" : "not ok"}, expected: ${tests[each_test]}`);
}

一个简单的处理方法可能是这样的，只针对第一个大括号：

function Search(str) {
    const onlyBrackets = str.replace(/[a-zA-Z]/g, "");
    const left = onlyBrackets.replace(/[)]/g, "");
    const right = onlyBrackets.replace(/[(]/g, "");

    str = left.length === right.length ? 1 : 0
    return str
}

console.log(Search("(coder)(byte))")) // 0

console.log(Search("(c(oder))b(yte)")) // 1

function isParenthesisBalanced(_str) {
 var parenMap = {'{':'}', '[':']', '(':')'};
 var parenStack =[];

 for(var i=0;i<_str.length; i++) {
     if(_str[i] in parenMap) {
         parenStack.push(_str[i]);
     } else if(Object.values(parenMap).indexOf(_str[i]) != -1) {
        if(parenMap[parenStack.pop()] != _str[i]) return false;
     }
 }
 return true;
}