Метод поиска подстроки в строке

function countHash(text, pPow, r)
{
    var hs = 0;
    var textLength = text.length;
    for(var i = 0; i < textLength; i++)
    {
        hs += (pPow[textLength - 1 - i] * text[i].charCodeAt(0)) % r; 
        //hs += (pPow[i + 1] * text[i].charCodeAt(0)) % r;
    }
    return hs;
}
 
function hash(string, subString)
{
    var comparsions = 0;
    var collisions = 0;
    var stringLength = string.length;
    var subStringLength = subString.length;
    var r = 1000000007;
    var entries = [];
    var p = 2;
    var pPow = [1];
    for (var i = 1; i <= subStringLength; i++)
    {
        pPow.push(pPow[i - 1] * p);
    }
    //var substringtext = string;
    var substringtext = string.substring(0,subStringLength);
    var stringHash = countHash(substringtext, pPow, r);
    var subStringHash = countHash(subString, pPow, r);
    for (var i = 0; i <= stringLength - subStringLength; i++)
    {
        if (subStringHash == stringHash)
        {
            substringtext = string.substring(i, i + subStringLength);
            comparsions++;
            if (substringtext == subString)
            {
                entries.push(i);
            }
            else
            {
                collisions++;
            }
        }
        if (i == stringLength - subStringLength)
        {
            break;
        }
        var hoard = string[i].charCodeAt(0) * pPow[subStringLength - 1] % r;
        hoard = (stringHash - hoard) % r;
        hoard = 2 * hoard % r;
        hoard = (hoard + string[i + subStringLength].charCodeAt(0)) % r;
        stringHash = hoard;
        //hashText = (((hashText - (text[i].charCodeAt(0) * pPow[stringLength - 1]) % r) * 2) % r + text[i + stringLength].charCodeAt(0)) % r;
    }
    var output = [entries, collisions, comparsions]
    return output;
}

let opRK = {
  getHash: (text, pPow, r) => {
    let hash = 0;
    for(let i = 0; i < text.length; i++) hash += (pPow[text.length - 1 - i] * text[i].charCodeAt(0)) % r;
    return hash;
  },
  getMatches: (string, subString) => {
    let opTmp = {
      collisions: 0,
      r: 101,
      entries: [],
      pPow: [1],
      substringtext:string.substring(0,subString.length),
    };
    
    for (let i = 1; i <= subString.length; i++) opTmp.pPow.push(opTmp.pPow[i - 1] * 2);
    
    opTmp.stringHash = opRK.getHash(opTmp.substringtext, opTmp.pPow, opTmp.r);
    opTmp.subStringHash = opRK.getHash(subString, opTmp.pPow, opTmp.r);
    
    for (let i = 0; i < string.length - subString.length; i++) {
      if (opTmp.subStringHash !== opTmp.stringHash) {
        (opTmp.substringtext === subString) ? opTmp.entries.push(i - 1) : opTmp.collisions++;
        opTmp.substringtext = string.substring(i, i + subString.length);
      }
      opTmp.stringHash = (((2 * ((opTmp.stringHash - (string[i].charCodeAt(0) * opTmp.pPow[subString.length - 1] % opTmp.r)) % opTmp.r) % opTmp.r) + string[i + subString.length].charCodeAt(0)) % opTmp.r);
    }
    return [opTmp.entries, opTmp.collisions, opTmp.entries.length];
  }
};

const listAllProperties = o => {     
  let objectToInspect, result = [];
  for(objectToInspect = o; objectToInspect !== null; objectToInspect = Object.getPrototypeOf(objectToInspect))
    result = result.concat(Object.getOwnPropertyNames(objectToInspect));
  return result;
}
console.log(listAllProperties(`abc`));
/*
["0", "1", "2", "length", "length", "constructor", "anchor", "big", "blink", "bold", "charAt", "charCodeAt", "codePointAt", "concat", "endsWith", "fontcolor", "fontsize", "fixed", "includes", "indexOf", "italics", "lastIndexOf", "link", "localeCompare", "match", "normalize", "padEnd", "padStart", "repeat", "replace", "search", "slice", "small", "split", "strike", "sub", "substr", "substring", "sup", "startsWith", "toString", "trimStart", "trimLeft", "trimEnd", "trimRight", "toLocaleLowerCase", "toLocaleUpperCase", "toLowerCase", "toUpperCase", "valueOf", "matchAll", "trim", "constructor", "__defineGetter__", "__defineSetter__", "hasOwnProperty", "__lookupGetter__", "__lookupSetter__", "isPrototypeOf", "propertyIsEnumerable", "toString", "valueOf", "__proto__", "toLocaleString"]
*/

const searchSubstring = (str, substr) => {
    let res = [];
    for(let i = 0; i < str.length; i++){
        if(substr[0] == str[i]){
            for(let j = i + 1, k = 1; j < str.length && k < substr.length; j++, k++){
                if(substr[k] != str[j])
                    break;
                if(k == substr.length - 1){
                    res.push([i, j]);
                }
            }
        }
    }
    if(!res.length)
        return false;
    return res;
}

var fs = require("fs"); 
var text = fs.readFileSync("string.txt", "utf8");
var substring = fs.readFileSync("subString.txt", "utf8");

    for (let i = 0; i < string.length - subString.length; i++) {
      if (opTmp.subStringHash !== opTmp.stringHash) {
        (opTmp.substringtext === subString) ? opTmp.entries.push(i - 1) : opTmp.collisions++;
        opTmp.substringtext = string.substring(i, i + subString.length);
      }

for (let i = 0; i < string.length - subString.length; i++) {
      if (opTmp.subStringHash == opTmp.stringHash) {
        (opTmp.substringtext === subString) ? opTmp.entries.push(i - 1) : opTmp.collisions++;
        opTmp.substringtext = string.substring(i, i + subString.length);
        console.log(opTmp.substringtext);
      }
      opTmp.stringHash = (((2 * ((opTmp.stringHash - (string[i].charCodeAt(0) * opTmp.pPow[subString.length - 1] % opTmp.r)) % opTmp.r) % opTmp.r) + string[i + subString.length].charCodeAt(0)) % opTmp.r);
    }
// "Danny cursed Rivera openly, and forced him, while Rivera danced away."
 // [[-1], 0, 1]

// создадим, вместо туевы хучи переменных в глобальной области, один операционный объект.
// Потребление памяти это несильно сократит. Но зато уменьшит кол-во обращений к ней.
// А также предотвратит возможные коллизии до 1.
// А вообще, если Вы посчитали что чувствуете себя достаточно комфортно в Node,
// пора бы уже и модули писать.  Я именно эту конечную модель сейчас показываю.
// let module = require(`opRK`); <- module получит объект, что продемонстрирован ниже
let opRK = {
  // метод объекта
  // получим хеш со строки
  // на будущее - лучше использовать алгоритмы хешей Бернштейна
  // или же один из  Кернигана и Ритчи
  // быстрее них только свет.
  getHash: (text, pPow, r) => {
    let hash = 0;
    for(let i = 0; i < text.length; i++) hash += (pPow[text.length - 1 - i] * text[i].charCodeAt(0)) % r;
    return hash;
  },
  // помимо Рабина-Карпа
  // лучше бы Вы сразу Кнута — Морриса — Пратта поизучали
  getMatches: (string, subString) => {
    // опять вместо же кучи переменных - операционный объект
    let opTmp = {
      // инициализируем поля
      // ложные срабатывания
      collisions: 0,
      // Простое число для хеша
      r: 101,
      // массив вхождений
      entries: [],
      // массив зерен\солек\семян (на вкус) 
      pPow: [1],
      // начальный кусок с которым будет сравниваться подстрока
      substringtext:string.substring(0,subString.length),
    };
    
    // пробежимся по подстроке и с каждого символа
    // потырим зернышко в opTmp.pPow
    for (let i = 1; i <= subString.length; i++) opTmp.pPow.push(opTmp.pPow[i - 1] * 2);
    
    // Получим хеши искомой и наблюдаемой строк
    opTmp.stringHash = opRK.getHash(opTmp.substringtext, opTmp.pPow, opTmp.r);
    opTmp.subStringHash = opRK.getHash(subString, opTmp.pPow, opTmp.r);
        
    for (let i = 0; i < string.length - subString.length; i++) {
      // пока хеши не равны
      if (opTmp.subStringHash !== opTmp.stringHash) {
        // тернарный оператор
        // если строки совпали
        // пополняем массив вхождений
        // иначе коллизия
        // тут бы Вам кстати по-другому сделать надо было,
        // но это Вы уже сами подумаете
        // (подсказка - тернарный оператор может продолжаться сколь угодно долго при семантике)
        // (подсказка - ложные срабатывания можно в принципе определить как
        // opTmp.substringtext[0] === subString[0]
        (opTmp.substringtext === subString) ? opTmp.entries.push(i - 1) : opTmp.collisions++;
        // получили что хотели
        // смещаем на один символ шаблон
        opTmp.substringtext = string.substring(i, i + subString.length);
      }
      // и меняем хеш
      // идея сделать именно так .....
      // ну ладно Вам виднее
      // подсказка(у вас уже готов целый метод)
      opTmp.stringHash = (((2 * ((opTmp.stringHash - (string[i].charCodeAt(0) * opTmp.pPow[subString.length - 1] % opTmp.r)) % opTmp.r) % opTmp.r) + string[i + subString.length].charCodeAt(0)) % opTmp.r);
    }
    // ну и собственно вернем результаты [массив вхождений, ложные, кол-во вхождений]
    return [opTmp.entries, opTmp.collisions, opTmp.entries.length];
  }
};