How Can I Create a Function in JavaScript That Executes Only Once?

Creating a Function in JavaScript That's Executable Only Once

In JavaScript, it's sometimes necessary to restrict a function's execution to a single instance. While static variables can achieve this in languages like C , JavaScript offers a more elegant solution through closures.

A closure, a function that preserves its context even after its enclosing scope has ended, allows for the creation of functions that can only be invoked once. By encapsulating the execution flag within a closure, we can ensure that it remains persistent and inaccessible to external code.

Here's an example of using a closure to create a one-time executable function:

<code class="javascript">var something = (function() {
    var executed = false;
    return function() {
        if (!executed) {
            executed = true;
            // do something
        }
    };
})();

something(); // "do something" happens
something(); // nothing happens</code>

This function ensures that the enclosed code within the closure is only executed once, despite subsequent invocations.

Alternatively, if you prefer a more encapsulated approach, you can utilize a utility function like the one below:

<code class="javascript">function once(fn, context) { 
    var result;
    return function() { 
        if (fn) {
            result = fn.apply(context || this, arguments);
            fn = null;
            context = null;
        }
        return result;
    };
}</code>

Usage:

<code class="javascript">function something() { /* do something */ }
var one_something = once(something);

one_something(); // "do something" happens
one_something(); // nothing happens</code>

This utility function returns a function that caches the result of the first invocation and disables subsequent executions.

The above is the detailed content of How Can I Create a Function in JavaScript That Executes Only Once?. For more information, please follow other related articles on the PHP Chinese website!