运行 IndexOf 超过一倍 JS

Question

如何不用正则搜索多个相同的值，看是否满足条件？假设我有这个字符串 ***6**5****8*9***2 我需要做的是检查字符串是否总共至少有三次 ***，然后检查 *** 前后的数字是否总和为 11。在给出的示例中，满足这些条件是因为：首先字符串一共有三个***，然后9+2就是11.

我已经使用正则表达式、匹配和替换解决了这个问题，但是我如何在不应用这些解决方案的情况下解决这个问题。

我曾尝试在没有正则表达式的情况下执行此操作，但没有成功，因为 indexOf 只给我一个结果：

string = "***6**5****8*9***2";

  for (var i = 0; i < string.length; i++) {
     let where = (string.indexOf("***"));
     let a = parseInt(string.charAt(where - 1)); 
     let b = parseInt(string.charAt(where + 3));
    if (a + b == 11){
        isTrue = true;             
    }
   }

Answer 1

您可以按星号拆分字符串，并保留数组中的开头，然后检查值是否以星号开头，检查长度和左右元素的总和。

var string = "***6**5****8*9***2",
    parts = string.split(/(\*+)/),
    result = parts.some((s, i, { [i - 1]: l, [i + 1]: r }) =>
        s[0] === '*' && s.length >= 3 && +l + +r === 11
    );

console.log(result);
console.log(parts);

Answer 2

我尝试根据您现有的代码创建一个解决方案：

string = "***6**5****8*9***2***4";

let where = 0;
// Skip leading *
while (where < string.length && '*' == string.charAt(where)) {
  where += 1;
}

while (true) {
  // Find three stars based on previous result
  where = string.indexOf("***", where);
  // No more triples
  if (where == -1) break;
  // Convert to digit - will be NaN if not a digit
  let a = parseInt(string.charAt(where - 1));
  // Find trailing digit
  let j = where + 1;
  // Skip to next non * char
  while (j < string.length && '*' == string.charAt(j)) {
    j += 1;
  }
  // No matches - quit
  if (j == string.length) break;
  // Parse digit
  let b = parseInt(string.charAt(j));
  // Do the math
  if (!isNaN(a) && !isNaN(b)){
    console.log(`${a} + ${b} = ${a+b}`);
  }
  where = j;
}

Answer 3

写了一个简单的Parser.I希望对你有帮助

string = "***6**5****8*9***2";

class Parser {
  static parse(string) {
    var lexer = new Lexer(string);
    var token = lexer.getToken();
    var prevNumberToken  = null ;
    while (token.type !== TOKEN_TYPE_END) {
      if(token.type === TOKEN_TYPE_NUMBER){
        if(prevNumberToken && prevNumberToken.value + token.value === 11 ) {
          return true;
        }
        prevNumberToken = token ;
      } else if(token.type !== TOKEN_TYPE_THREESTARS){
        prevNumberToken = null ;
      }
      token = lexer.getToken();
    }
    return false;
  }
}


class Lexer {
  constructor(string) {
    this._string = string;
    this._index = -1;
    this._len = string.length;
  }

  getToken() {
    if (this._index < 0) {
      this._index = 0;
      return new Token(TOKEN_TYPE_START, '', -1);
    }
    if (this._index >= this._len) {
      return new Token(TOKEN_TYPE_END, '', this._len);
    }
    if (this._string[this._index] === "*") {
      return this._getStarToken()
    } else {
      return this._getNumberToken();
    }
  }

  _getStarToken() {
    var stars = "";
    var i = this._index;
    while (this._index < this._len && this._string[this._index] === "*") {
      stars += "*";
      this._index++;
    }
    if (stars.length === 3) {
      return new Token(TOKEN_TYPE_THREESTARS, stars, i)
    }
    return new Token(TOKEN_TYPE_STARS, stars, i)
  }
  _getNumberToken() {
    var numbers = "";
    var i = this._index;
    while (this._index < this._len && this._string[this._index] !== "*") {
      if (this._string[this._index] >= "0" && this._string[this._index] <= "90") {
        numbers += this._string[this._index];
        this._index++;
      } else {
        throw new Error("invalid character")
      }
    }
    return new Token(TOKEN_TYPE_NUMBER, parseInt(numbers), i);
  }

}


class Token {
  constructor(type, value, index) {
    this._type = type
    this._index = index
    this._value = value
  }
  get type() { return this._type }
  get index() { return this._index }
  get value() { return this._value }
}

const TOKEN_TYPE_START = 1;
const TOKEN_TYPE_NUMBER = 2;
const TOKEN_TYPE_THREESTARS = 4;
const TOKEN_TYPE_STARS = 8;
const TOKEN_TYPE_END = 16;

console.log(Parser.parse(string));

运行 IndexOf 超过一倍 JS

Run IndexOf more than one time JS

javascript

for-loop

indexof