Função em JavaScript que pode ser chamada apenas uma vez

Preciso criar uma função que possa ser executada apenas uma vez, em cada vez após a primeira não será executada. Eu sei de C ++ e Java sobre variáveis ​​estáticas que podem fazer o trabalho, mas gostaria de saber se existe uma maneira mais elegante de fazer isso.

Se por "não será executado" você quiser dizer "não fará nada quando for chamado mais de uma vez", você pode criar um encerramento:

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

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

Em resposta a um comentário de @Vladloffe (agora excluído): Com uma variável global, outro código poderia redefinir o valor do sinalizador "executado" (qualquer nome que você escolher para ele). Com um encerramento, outro código não tem como fazer isso, seja acidental ou deliberadamente.

Como outras respostas aqui apontam, várias bibliotecas (como Underscore e Ramda ) têm uma pequena função de utilidade (normalmente chamada once()^[*] ) que aceita uma função como um argumento e retorna outra função que chama a função fornecida exatamente uma vez, independentemente de como muitas vezes a função retornada é chamada. A função retornada também armazena em cache o primeiro valor retornado pela função fornecida e o retorna nas chamadas subsequentes.

No entanto, se você não estiver usando essa biblioteca de terceiros, mas ainda quiser essa função de utilitário (em vez da solução nonce que ofereci acima), é fácil de implementar. A versão mais legal que vi é esta postada por David Walsh :

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

Eu estaria inclinado a mudar fn = null;para fn = context = null;. Não há razão para o fechamento manter uma referência a contextuma vez fnque foi chamado.

^[*] _{Esteja ciente, entretanto, que outras bibliotecas, como esta extensão do Drupal para jQuery , podem ter uma função chamada once()que faz algo bastante diferente.}

Substitua-o por uma função NOOP (sem operação) reutilizável .

// 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
}

Aponte para uma função vazia depois de chamada:

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>

Ou, assim:

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 tem uma função que faz isso, 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;
    };
  };

Falando sobre variáveis ​​estáticas, isso é um pouco como a variante de encerramento:

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

once(); once(); 

Você pode redefinir uma função se desejar:

once.done = false;

var quit = false;

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

Você poderia simplesmente ter a função "remover a si mesmo"

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

    Once = undefined;
}

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

Mas essa pode não ser a melhor resposta se você não quiser engolir erros.

Você também pode fazer isso:

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

    Once = function(){};
}

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

Preciso que funcione como smart pointer, se não houver elementos do tipo A ele pode ser executado, se houver um ou mais elementos A a função não poderá ser executada.

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

    // do stuff
}

tente isso

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

De um cara chamado Crockford ... :)

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

invalidateFunção reutilizável que funciona com 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);

Experimente no JSBin: https://jsbin.com/vicipar/edit?js,console

Variação de resposta de Bunyk

Aqui está um exemplo de JSFiddle - http://jsfiddle.net/6yL6t/

E o código:

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();
    }
}

Você poderia fazer:

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

E será executado apenas uma vez :)

Configuração 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;
    };
}

Se você usa Node.js ou escreve JavaScript com browserify, considere o módulo npm "uma vez" :

var once = require('once')

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

Se você quiser reutilizar a função no futuro, isso funciona bem com base no código de ed Hopp acima (percebi que a pergunta original não exigia esse recurso extra!):

   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();

A saída é semelhante a:

Hello World!
Reset
Hello World!

decorador simples e fácil de escrever quando você precisa

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

usando:

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

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

Tentando usar a função de sublinhado "uma 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; */

Se estiver usando Ramda, você pode usar a função "uma vez" .

Uma citação da documentação:

uma vez Função (a… → b) → (a… → b) PARÂMETROS adicionados na v0.1.0

Aceita uma função fn e retorna uma função que protege a invocação de fn de forma que fn só possa ser chamado uma vez, não importa quantas vezes a função retornada seja chamada. O primeiro valor calculado é retornado nas invocações subsequentes.

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

mantenha-o o mais simples possível

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

Você pode ver o resultado

JQuery permite chamar a função apenas uma vez usando o método one () :

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>

Implementação usando o método JQuery em () :

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>

Implementação 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 é útil para prevenir loops infinitos (usando jQuery):

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

Se você está preocupado com a poluição do namespace, substitua "doIt" por uma string longa e aleatória.

Ajuda a prevenir a execução pegajosa

var done = false;

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