Creating an endless loop with JavaScript's setTimeout without self-calling

Other Questions JavaScript
1

Hey everyone! I’m trying to figure out how to build a function that continuously executes using setTimeout, but without the function calling itself. I’ve experimented with the following code:

function loopStuff() {
  // Perform some operations here
  setTimeout(loopStuff, 100);
}
loopStuff();

The challenge I’m facing is that an obfuscation tool fails when processing this self-calling design. I don’t want to use setInterval because I need the delay to start only after the current execution completes. Does anyone have a suggestion on how to restructure this so it runs repeatedly without invoking itself inside the function? I’m stuck and appreciate any help. Thanks!

2

I encountered a similar issue when working on a project that required continuous execution without self-invocation. One approach that worked well for me was using a separate scheduler function. Here’s how I implemented it:

function loopStuff() {
  // Perform operations here
}

function scheduler() {
  loopStuff();
  setTimeout(scheduler, 100);
}

scheduler();

This structure keeps the main function clean and separates the scheduling logic. It solved my obfuscation problems and maintained the desired behavior of starting the delay after each execution. The scheduler function acts as a wrapper, handling the timing and repeated calls.

Another benefit I found with this method was improved readability and easier debugging. It also allowed me to easily modify the scheduling without touching the core functionality in loopStuff(). Hope this helps with your specific use case!

3

hey there! have you thought about using a callback? something like this might work:

function loopStuff(callback) {
  // do stuff
  callback();
}

function runLoop() {
  loopStuff(() => setTimeout(runLoop, 100));
}

runLoop();

this way loopStuff doesn’t call itself, but you still get the loop. hope that helps!

4

I’ve dealt with similar issues in my projects. One effective solution is to use a named function expression within an Immediately Invoked Function Expression (IIFE). Here’s how you can structure it:

(function() {
  var loop = function() {
    // Your operations here
    setTimeout(loop, 100);
  };
  loop();
})();

This approach encapsulates the loop function within its own scope, preventing global namespace pollution. It also satisfies the requirement of not calling itself directly within the function body. The IIFE creates a closure, allowing the loop to continue indefinitely while keeping the code clean and maintainable.

I’ve found this method particularly useful when working with obfuscation tools, as it tends to work well with most of them. It also provides flexibility for adding additional logic or error handling if needed.