如何编写一个JavaScript函数来检查字符串中的第一个字符和最后一个字符是否相等

debugcn 发表于 Dev

迈克L5799

我一直在进行此javascript挑战，并且已经很接近了，但是有些地方不对了。这是挑战：

给定一个包含三种大括号类型的字符串数组：round（），square []和curl {}您的任务是编写一个函数，检查每个字符串中的大括号是否正确匹配。如果每个字符串中的花括号都匹配，则将1打印到标准输出（console.log）；如果不匹配，则将0打印（每行一个结果）

我的代码是这样的：

var infoToParse = [ ")(){}", "[]({})", "([])", "{()[]}", "([)]" ]; 

function checkBraces(infoToParse) {
    var tabChars = infoToParse;
    for (i= 0; tabChars.length - 1; i+=1) {
        if (tabChars[i].charAt(0) === tabChars[i].charAt(tabChars[i].length-1)){
            console.log(1);
        }else{
            console.log(0);
        }
    }
}

checkBraces(infoToParse);

当前数组项的输出应为Output：0 1 1 1 0

冰刺

我想您可以通过这种方式做到这一点，并保持起始位置的“树状”。除了您自己的测试用例外，没有进行其他测试：)

var testCases = [")(){}", "[]({})", "([])", "{()[]}", "([)]"];

var braceType = {
  round: ["(", ")"],
  curly: ["{", "}"],
  square: ["[", "]"]
};

var bracePosition = {
  start: ["{", "(", "["],
  end: ["}", ")", "]"]
};

function typeOfBraces(sign) {
  for (var property in braceType) {
    if (braceType[property].indexOf(sign) < 0) {
      continue;
    }
    if (bracePosition.start.indexOf(sign) < 0) {
      return {
        type: property,
        position: "end"
      };
    } else {
      return {
        type: property,
        position: "start"
      };
    }
  }
  throw "Sign is not a brace!";
};

function Braces(brace, parent, type) {
  this.brace = brace;
  this.parent = parent || null;
  this.type = type || {
    type: 'init',
    position: ''
  };
  this.children = [];

  this.nextBrace = function(nextSign) {
    var nextType = typeOfBraces(nextSign);
    if (nextType.position === 'start') {
      var child = new Braces(nextSign, this, nextType);
      this.children.push(child);
      return child;
    }
    if (nextType.position === 'end') {
      if (this.type.position === '') {
        throw 'Cannot start with an end tag!';
      }
      if (this.type.position === 'end' && this.parent === null) {
        throw 'Cannot end the sequence';
      }
      if (this.type.position === 'end' && this.parent.position === 'start') {
        if (this.type.type === this.parent.type) {
          var child = new Braces(nextSign, this.parent, nextType);
          this.parent.children.add(child);
          return this.parent;
        }
      }
    }
    if (this.type.position === 'start' && nextType.type === this.type.type && nextType.position === 'end') {
      return this.parent;
    }
    return new Braces(nextSign, this, nextType);
  };
}

for (var i = 0; i < testCases.length; i++) {
  var brace = new Braces(testCases[i]);
  for (var j = 0, len = testCases[i].length; j < len; j++) {
    try {
      brace = brace.nextBrace(testCases[i][j]);
    } catch (e) {
      console.log(e);
      brace = null;
      break;
    }
  }
  if (brace != null && brace.parent == null) {
    // valid entry
    console.log(brace);
    console.log(testCases[i] + " is a valid sequence");
  } else {
    // invalid entry
    console.log(testCases[i] + " is an invalid sequence");
  }
}

或者，使其变得更简单并检查一下括号：

function validBraces(braceSequence) {
  var stack = '',
    i, len, lastStack = -1,
    toAdd = "{([",
    toRemove = "})]",
    sign;
  for (i = 0, len = braceSequence.length; i < len; i++) {
    sign = braceSequence[i];
    if (toAdd.indexOf(sign) >= 0) {
      stack += sign;
      lastStack++;
    } else if (toRemove.indexOf(sign) >= 0) {
      if (toAdd.indexOf(stack.charAt(lastStack)) !== toRemove.indexOf(sign)) {
        // format exception
        console.warn('Format exception, didn\'t expect ' + sign + ' (current stack: ' + stack + ')');
        return false;
      } else {
        stack = stack.slice(0, -1);
        lastStack--;
      }
    } else {
      console.warn('Invalid character exception, didn\'t expect ' + sign + ' (current stack: ' + stack + ')');
      return false;
    }
  }
  return true;
}

var testCases = [")(){}", "[]({})", "([])", "{()[]}", "([)]"];

for (var i = 0; i < testCases.length; i++) {
  if (validBraces(testCases[i])) {
    console.log(testCases[i] + ' is a valid sequence');
  } else {
    console.log(testCases[i] + ' is an invalid sequence');
  }
}

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。