How to check if Regex matches before some index without searching entire string, or if regex matches at an index in JavaScript?

Question

I have a case where I'm using regex to check a string for matches, after a start index and before an end one.

To set the start point, it is possible to create a new Regexp() and set it's index before running exec().

I can not find a way, though, to limit the depth of its search. One "obvious" solution might be to use substring() to get a string that can't be searched passed a point, but it would have a massive negative impact on performance. Any solution to setting a limit on regex search depth that includes substring() will not do, and is IMO embarrassingly inefficient, so please do not post them.

The three ways I can imagine fixing this are:

1. if there is some way to set a limit, such as myRegex.exec(string, stopIndex) or myString.length = temporaryFakeLimit; //do regex, reset length. Neither of these work or exist.

2. if there was some way to check for a regex match at an index in a string ie myRegex.testAt(myString, indexToCheck), I could iterate through the string myself, checking for matches.

3. if there was a non-native implementation of regex, which is capable of doing either of the above.

So far I have not been able to find a good solution.

How can I check if a Regex has a match in a string before some index, without it searching the entire string?

---

Edit (Not by OP)

To add further:

If it doesn't find a match, and I'm only looking 100 chars deep on a 100000 char text, that's an issue.

How can we search a portion of a given string using RegEx. This portion of string should be determined by parameters indicating a start index and an end index.

Example of Parameters

var str = `Check enhancement bonus fear effect fly initiative check panicked points of damage rounding stunned touch attack unarmed strike. Aquatic subtype attack of opportunity catching on fire charm conjuration deafened evasion evil domain fast healing favored class fire domain gaseous form healing subschool incorporeal melee weapon multiplying skill points stunned summoning subschool take 10 turn. Adjacent class concentrate on a spell energy drained infection intelligence invisible law domain mundane nonlethal damage small.`;

var rgx = /\d\d/;

var start = 300;

var end = 500;

The result should be:

10

Answer 1

I'm not sure if I understand correctly your requirements but I think you can use something like this (^.{0,4})(the actual regex)(.*) and adjust the length by changing 4 with [max size] - [actual regex length].

I don't know how exactly the regex engine is implemented in JavaScript but I think that by using something like this the engine won't process the entire string.

The example above will start the search at the start of the string. For starting at an offset, you can use something like this:

(^.{5}.{0,4})(the actual regex)(.*) where 5 is the offset.

Answer 2

You can use a for loop and break

let str = "test string";

let match = "string";

let limit = 4;

let res = "";

for (let i = 0; i < str.length; i++) {
  console.log(i, i < limit);
  if (i >= limit - 1) {
    if (!res) {
      res = null;
    }
    break;
  };
  // alternatively, using `RegExp`
  // new RegExp(str[i], "i").test(match[i])
  if (str[i] === match[i]) { 
    res += str[i]
  }
}

console.log(res);

Answer 3

EDIT: ignore the following, the true answer to this question is that substr does not work in js the way I thought it did. In native browser code, strings are immutable, so when substr() is called, it can just reference the original string with a new start and length property. It's super efficient.

---

OLD ANSWER:

I've managed to figure out a solution for this, although it's ugly. The idea is to use a regex that matches the thing you are looking for, or anything. Because it will match anything if it doesn't match what you want, it moves one char at a time. Using capturing groups, you can check if it's matching the thing you want, or the dummy matches.

The code for it is like so:

var stringToSearch = "hey hi ho here we go, woop de do an2 for you, lalala lelele lolol goop da woop ba bee";

var whatIWant = "a.+[1-3]";
var anyChar = ".|\n"

var myRegex = new RegExp("("+whatIWant+")|"+anyChar, 'g');


function boundedRegexSearch(searchMe, regex, start, end) {
  regex.lastIndex = start; //start search index
  
  var keepSearching = true;
  while(keepSearching) {
    var result = regex.exec(searchMe);
    var whatImSearchingFor = result[1];
  
    if(whatImSearchingFor !== undefined)
      return whatImSearchingFor;
   
    keepSearching = regex.lastIndex < end;
  }
}


//can not match anything from index 0 to 8, returns undefined
console.log(boundedRegexSearch(stringToSearch, myRegex, 0, 8));

//can match "an2" at index 36
console.log(boundedRegexSearch(stringToSearch, myRegex, 20, 40));

Answer 4

OP Question

How can I check if a Regex has a match in a string before some index, without it searching the entire string?

Comment added to question

If it doesn't find a match, and I'm only looking 100 chars deep on a 100000 char text, that's an issue. And this isn't about an expected output, it's about a function that doesn't seem to exist.

Taking both of these requirements from a badly managed question into consideration, we should do the following:

• Take 4 parameters: the string str, the RegEx tgt, the start index ptA, and the end index ptZ

• Extract a new string by using slice(ptA, (ptZ+1)). The ptZ+1 is because ptZ is exclusive.

• Then use match() on the new string using tgt.

Since the OP emphasized performance, here's a test between OP answer and this answer at jsPerf.

Demo

const str = `Anything suspicious? Well... then should we go? Any uh... Cartel news these days? Seems like I'm always reading something or other in the paper. I don't want to talk about it. To you or anyone else. I'm done explaining myself. Gus is dead. We've got work to do. `;

let tgt = /Cartel/;

function searchIndexRange(str, rgx, ptA, ptZ) {
  const frag = str.slice(ptA, (ptZ + 1));
  let exists = frag.match(rgx);
  if (exists !== -1) {
    return exists;
  } else return false;
}

// First call returns null 
// Second call returns the search key "Cartel"

let res = JSON.stringify(searchIndexRange(str, tgt, 0, 1));
console.log(res);

res = JSON.stringify(searchIndexRange(str, tgt, 0, 100));
console.log(res);