Funkcja w javascript, którą można wywołać tylko raz

Zastąp go funkcją noop (no operation).

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

UnderscoreJs ma funkcję, która to robi, 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;
    };
  };

Po wywołaniu wystarczy wskazać pustą funkcję.

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

Mówiąc o zmiennych statycznych, jest to trochę jak wariant zamknięcia:

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

once(); once(); 

Możesz następnie zresetować funkcję, jeśli chcesz:

once.done = false;

var quit = false;

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

Możesz po prostu mieć funkcję "Usuń się"

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

    Once = undefined;
}

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

Ale to może nie być najlepsza odpowiedź, jeśli nie chcesz połykać błędów.

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

    Once = function(){};
}

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

potrzebuję go, aby działał jak inteligentny wskaźnik, jeśli nie ma elementów z Typu A, można go wykonać, jeśli jest jeden lub więcej elementów A, funkcja nie może być wykonana.

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

    // do stuff
}

Spróbuj tego

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

Od jakiegoś kolesia o imieniu Crockford... :)

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

Oto przykład JSFiddle- http://jsfiddle.net/6yL6t/

I Kod:

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

Możesz zrobić:

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

I będzie działać tylko raz:)

Konfiguracja początkowa:

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

If your using Node.js lub pisanie JavaScript za pomocą browserify, rozważ " once " moduł npm :

var once = require('once')

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

Funkcja wielokrotnego użytku invalidate, która działa z 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);

Spróbuj na JSBin: https://jsbin.com/vicipar/edit?js, console

Odpowiedź od Bunyk

Jeśli chcesz być w stanie ponownie użyć funkcji w przyszłości, to działa dobrze w oparciu o kod Ed Hopp powyżej (zdaję sobie sprawę, że oryginalne pytanie nie wywołało tej dodatkowej funkcji!):

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

Wyjście wygląda następująco:

Hello World!
Reset
Hello World!

Próba użycia funkcji podkreślenia "raz":

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; */

Jeśli używasz Ramda, możesz użyć funkcji "once" .

Cytat z dokumentacji:

Once Function (a ... → b) → (a ... → b) Parametry Dodano w v0. 1. 0

Akceptuje funkcję fn i zwraca funkcję, która strzeże wywołania fn tak, że fn może być wywołana tylko raz, bez względu na to, ile razy zwracana funkcja została wywołana. Pierwsza obliczona wartość jest zwracana w kolejnych wywołaniach.

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

Przychodzę z prostym dekoratorem, który łatwo rozwiązuje twój problem]}

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

Użycie:

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

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

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

Ten jest przydatny do zapobiegania nieskończonym pętlom (używając jQuery):

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

Jeśli martwisz się zanieczyszczeniem przestrzeni nazw, zastąp długi, losowy łańcuch dla "doIt".

Pomaga zapobiegać lepkiemu wykonaniu

var done = false;

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