Función en JavaScript que solo se puede llamar una vez

Necesito crear una función que se pueda ejecutar solo una vez, cada vez después de la primera no se ejecutará. Sé de C ++ y Java acerca de las variables estáticas que pueden hacer el trabajo, pero me gustaría saber si hay una forma más elegante de hacer esto.

Si por "no se ejecutará" quiere decir "no hará nada cuando se le llame más de una vez", puede crear un cierre:

var something = (function() {
    var executed = false;
    return function() {
        if (!executed) {
            executed = true;
            // do something
        }
    };
})();

something(); // "do something" happens
something(); // nothing happens

En respuesta a un comentario de @Vladloffe (ahora eliminado): Con una variable global, otro código podría restablecer el valor de la bandera "ejecutado" (cualquier nombre que elija). Con un cierre, otro código no tiene forma de hacer eso, ya sea accidental o deliberadamente.

Como señalan otras respuestas aquí, varias bibliotecas (como Underscore y Ramda ) tienen una pequeña función de utilidad (normalmente llamada once()^[*] ) que acepta una función como argumento y devuelve otra función que llama a la función proporcionada exactamente una vez, independientemente de cómo muchas veces se llama a la función devuelta. La función devuelta también almacena en caché el valor devuelto primero por la función proporcionada y lo devuelve en llamadas posteriores.

Sin embargo, si no está utilizando una biblioteca de terceros, pero aún desea una función de utilidad (en lugar de la solución nonce que ofrecí anteriormente), es bastante fácil de implementar. La versión más bonita que he visto es esta publicada por David Walsh :

function once(fn, context) { 
    var result;
    return function() { 
        if (fn) {
            result = fn.apply(context || this, arguments);
            fn = null;
        }
        return result;
    };
}

Me inclinaría a cambiar fn = null;a fn = context = null;. No hay ninguna razón para que el cierre mantenga una referencia a contextuna vez que fnse ha llamado.

^[*] _{Tenga en cuenta, sin embargo, que otras bibliotecas, como esta extensión de Drupal para jQuery , pueden tener una función nombrada once()que hace algo bastante diferente.}

Reemplácelo con una función NOOP (sin operación) reutilizable .

// this function does nothing
function noop() {};

function foo() {
    foo = noop; // swap the functions

    // do your thing
}

function bar() {
    bar = noop; // swap the functions

    // do your thing
}

Apunta a una función vacía una vez que se ha llamado:

function myFunc(){
     myFunc = function(){}; // kill it as soon as it was called
     console.log('call once and never again!'); // your stuff here
};

<button onClick=myFunc()>Call myFunc()</button>

O, así:

var myFunc = function func(){
     if( myFunc.fired ) return;
     myFunc.fired = true;
     console.log('called once and never again!'); // your stuff here
};

// even if referenced & "renamed"
((refToMyfunc)=>{
  setInterval(refToMyfunc, 1000);
})(myFunc)

UnderscoreJs tiene una función que hace eso, underscorejs.org/#once

  // Returns a function that will be executed at most one time, no matter how
  // often you call it. Useful for lazy initialization.
  _.once = function(func) {
    var ran = false, memo;
    return function() {
      if (ran) return memo;
      ran = true;
      memo = func.apply(this, arguments);
      func = null;
      return memo;
    };
  };

Hablando de variables estáticas, esto es un poco como una variante de cierre:

var once = function() {
    if(once.done) return;
    console.log('Doing this once!');
    once.done = true;
};

once(); once(); 

A continuación, puede restablecer una función si lo desea:

once.done = false;

var quit = false;

function something() {
    if(quit) {
       return;
    } 
    quit = true;
    ... other code....
}

Simplemente puede hacer que la función "se elimine"

​function Once(){
    console.log("run");

    Once = undefined;
}

Once();  // run
Once();  // Uncaught TypeError: undefined is not a function 

Pero esta puede no ser la mejor respuesta si no quiere tragar errores.

También puedes hacer esto:

function Once(){
    console.log("run");

    Once = function(){};
}

Once(); // run
Once(); // nothing happens

Necesito que funcione como un puntero inteligente, si no hay elementos del tipo A, se puede ejecutar, si hay uno o más elementos A, la función no se puede ejecutar.

function Conditional(){
    if (!<no elements from type A>) return;

    // do stuff
}

prueba esto

var fun = (function() {
  var called = false;
  return function() {
    if (!called) {
      console.log("I  called");
      called = true;
    }
  }
})()

De un tipo llamado Crockford ... :)

function once(func) {
    return function () {
        var f = func;
        func = null;
        return f.apply(
            this,
            arguments
        );
    };
}

invalidateFunción reutilizable que funciona con setInterval:

var myFunc = function (){
  if (invalidate(arguments)) return;
  console.log('called once and never again!'); // your stuff here
};

const invalidate = function(a) {
  var fired = a.callee.fired;
  a.callee.fired = true;
  return fired;
}

setInterval(myFunc, 1000);

Pruébelo en JSBin: https://jsbin.com/vicipar/edit?js,console

Variación de respuesta de Bunyk

Aquí hay un ejemplo de JSFiddle: http://jsfiddle.net/6yL6t/

Y el codigo:

function hashCode(str) {
    var hash = 0, i, chr, len;
    if (str.length == 0) return hash;
    for (i = 0, len = str.length; i < len; i++) {
        chr   = str.charCodeAt(i);
        hash  = ((hash << 5) - hash) + chr;
        hash |= 0; // Convert to 32bit integer
    }
    return hash;
}

var onceHashes = {};

function once(func) {
    var unique = hashCode(func.toString().match(/function[^{]+\{([\s\S]*)\}$/)[1]);

    if (!onceHashes[unique]) {
        onceHashes[unique] = true;
        func();
    }
}

Podrías hacerlo:

for (var i=0; i<10; i++) {
    once(function() {
        alert(i);
    });
}

Y solo se ejecutará una vez :)

Configuración inicial:

var once = function( once_fn ) {
    var ret, is_called;
    // return new function which is our control function 
    // to make sure once_fn is only called once:
    return function(arg1, arg2, arg3) {
        if ( is_called ) return ret;
        is_called = true;
        // return the result from once_fn and store to so we can return it multiply times:
        // you might wanna look at Function.prototype.apply:
        ret = once_fn(arg1, arg2, arg3);
        return ret;
    };
}

Si usa Node.js o escribe JavaScript con browserify, considere el módulo npm "once" :

var once = require('once')

function load (file, cb) {
  cb = once(cb)
  loader.load('file')
  loader.once('load', cb)
  loader.once('error', cb)
}

Si desea poder reutilizar la función en el futuro, esto funciona bien según el código de ed Hopp anterior (¡me doy cuenta de que la pregunta original no requería esta función adicional!):

   var something = (function() {
   var executed = false;              
    return function(value) {
        // if an argument is not present then
        if(arguments.length == 0) {               
            if (!executed) {
            executed = true;
            //Do stuff here only once unless reset
            console.log("Hello World!");
            }
            else return;

        } else {
            // otherwise allow the function to fire again
            executed = value;
            return;
        }       
    }
})();

something();//Hello World!
something();
something();
console.log("Reset"); //Reset
something(false);
something();//Hello World!
something();
something();

La salida se ve así:

Hello World!
Reset
Hello World!

decorador simple que es fácil de escribir cuando lo necesita

function one(func) {
  return function () {
     func && func.apply(this, arguments);
     func = null;
  }
}

utilizando:

var initializer= one( _ =>{
      console.log('initializing')
  })

initializer() // 'initializing'
initializer() // nop
initializer() // nop

Intentando utilizar la función de subrayado "una vez":

var initialize = _.once(createApplication);
initialize();
initialize();
// Application is only created once.

http://underscorejs.org/#once

var init = function() {
    console.log("logges only once");
    init = false;
}; 

if(init) { init(); }

/* next time executing init() will cause error because now init is 
   -equal to false, thus typing init will return false; */

Si está utilizando Ramda, puede utilizar la función "una vez" .

Una cita de la documentación:

once Función (a… → b) → (a… → b) PARÁMETROS Agregados en v0.1.0

Acepta una función fn y devuelve una función que protege la invocación de fn de manera que solo se puede llamar a fn una vez, sin importar cuántas veces se invoque la función devuelta. El primer valor calculado se devuelve en invocaciones posteriores.

var addOneOnce = R.once(x => x + 1);
addOneOnce(10); //=> 11
addOneOnce(addOneOnce(50)); //=> 11

Mantenlo lo más simple posible

function sree(){
  console.log('hey');
  window.sree = _=>{};
}

Puedes ver el resultado

JQuery permite llamar a la función solo una vez usando el método uno () :

let func = function() {
  console.log('Calling just once!');
}
  
let elem = $('#example');
  
elem.one('click', func);

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div>
  <p>Function that can be called only once</p>
  <button id="example" >JQuery one()</button>
</div>

Implementación usando el método JQuery en () :

let func = function(e) {
  console.log('Calling just once!');
  $(e.target).off(e.type, func)
}
  
let elem = $('#example');
  
elem.on('click', func);

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div>
  <p>Function that can be called only once</p>
  <button id="example" >JQuery on()</button>
</div>

Implementación usando JS nativo:

let func = function(e) {
  console.log('Calling just once!');
  e.target.removeEventListener(e.type, func);
}
  
let elem = document.getElementById('example');
  
elem.addEventListener('click', func);

<div>
  <p>Functions that can be called only once</p>
  <button id="example" >ECMAScript addEventListener</button>
</div>

if (!window.doesThisOnce){
  function myFunction() {
    // do something
    window.doesThisOnce = true;
  };
};

Este es útil para prevenir bucles infinitos (usando jQuery):

<script>
var doIt = true;
if(doIt){
  // do stuff
  $('body').html(String($('body').html()).replace("var doIt = true;", 
                                                  "var doIt = false;"));
} 
</script>

Si le preocupa la contaminación del espacio de nombres, sustituya "doIt" por una cadena larga y aleatoria.

Ayuda a prevenir la ejecución pegajosa

var done = false;

function doItOnce(func){
  if(!done){
    done = true;
    func()
  }
  setTimeout(function(){
    done = false;
  },1000)
}