Yalnızca bir kez çağrılabilen JavaScript işlevi

Yalnızca bir kez çalıştırılabilen bir işlev oluşturmam gerekiyor, ilkinden sonra her seferinde çalıştırılmayacak. C ++ ve Java'dan işi yapabilecek statik değişkenler hakkında bilgi sahibiyim ama bunu yapmanın daha zarif bir yolu olup olmadığını bilmek istiyorum.

"Çalıştırılmayacak" derken, "birden fazla çağrıldığında hiçbir şey yapmayacağını" kastediyorsunuz, bir kapatma oluşturabilirsiniz:

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

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

@Vladloffe tarafından yapılan bir yoruma cevap olarak (şimdi silindi): Global bir değişkenle, diğer kod "çalıştırılan" bayrağın değerini (hangi adı seçerseniz seçin) sıfırlayabilir. Bir kapatma ile, başka bir kodun bunu yanlışlıkla veya kasıtlı olarak yapmasının bir yolu yoktur.

Buradaki diğer yanıtların da işaret ettiği gibi, birkaç kitaplığın ( Alt Çizgi ve Ramda gibi ) bir işlevi bağımsız değişken olarak kabul eden ve sağlanan işlevi nasıl olursa olsun tam olarak bir kez çağıran başka bir işlevi döndüren küçük bir yardımcı işlev işlevi (genellikle once()^[*] olarak adlandırılır ) vardır. çoğu kez döndürülen işlev çağrılır. Döndürülen işlev ayrıca sağlanan işlev tarafından ilk döndürülen değeri önbelleğe alır ve sonraki çağrılarda döndürür.

Bununla birlikte, böyle bir üçüncü taraf kitaplığı kullanmıyorsanız, ancak yine de böyle bir yardımcı program işlevi istiyorsanız (yukarıda sunduğum nonce çözümden ziyade), uygulanması yeterince kolaydır. Gördüğüm en güzel versiyon , David Walsh tarafından gönderilen bu versiyon :

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

Ben değiştirmek için eğimli olacak fn = null;etmek fn = context = null;. Bir contextzamanlar fnçağrılan bir referansı sürdürmek için kapatmanın bir nedeni yok .

^[*] _{Bununla birlikte, jQuery'nin bu Drupal uzantısı gibi diğer kitaplıkların, once()oldukça farklı bir şey yapan adlandırılmış bir işlevi olabileceğini unutmayın .}

Yeniden kullanılabilir bir NOOP (işlem yok) işleviyle değiştirin.

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

Çağrıldıktan sonra boş bir işlevi işaret edin:

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>

Veya bunun gibi:

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 bunu yapan bir işleve sahiptir, altçizgi.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;
    };
  };

Statik değişkenlerden bahsetmişken, bu biraz kapanış varyantına benzer:

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

once(); once(); 

Daha sonra isterseniz bir işlevi sıfırlayabilirsiniz:

once.done = false;

var quit = false;

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

"Kendini kaldır" işlevine sahip olabilirsiniz

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

    Once = undefined;
}

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

Ancak, hataları yutmak istemiyorsanız, bu en iyi cevap olmayabilir.

Bunu da yapabilirsiniz:

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

    Once = function(){};
}

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

Akıllı işaretçi gibi çalışmasına ihtiyacım var, eğer A tipinden hiç eleman yoksa çalıştırılabilir, bir veya daha fazla A elemanı varsa, fonksiyon çalıştırılamaz.

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

    // do stuff
}

bunu dene

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

Crockford adında bir adamdan ... :)

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

Aşağıdakilerle invalidateçalışan yeniden kullanılabilir işlev 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);

JSBin'de deneyin: https://jsbin.com/vicipar/edit?js,console

Bunyk'ten cevap varyasyonu

Örnek JSFiddle - http://jsfiddle.net/6yL6t/

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

Yapabilirsin:

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

Ve sadece bir kez çalışacak :)

İlk kurulum:

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

Node.js kullanıyorsanız veya browsererify ile JavaScript yazıyorsanız, "bir kez" npm modülünü düşünün :

var once = require('once')

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

İşlevi gelecekte yeniden kullanabilmek istiyorsanız, bu, yukarıdaki ed Hopp koduna göre iyi çalışır (orijinal sorunun bu ekstra özelliği gerektirmediğini anladım!):

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

Çıktı şöyle görünür:

Hello World!
Reset
Hello World!

İhtiyaç duyduğunuzda yazması kolay basit dekoratör

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

kullanarak:

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

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

Alt çizgi "bir kez" işlevi kullanılmaya çalışılıyor:

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

Ramda kullanıyorsanız, "bir kez" işlevini kullanabilirsiniz .

Belgelerden bir alıntı:

bir kez İşlev (a… → b) → (a… → b) PARAMETRELER v0.1.0'da eklendi

Bir fn işlevini kabul eder ve döndürülen işlevin kaç kez çalıştırıldığına bakılmaksızın fn'nin yalnızca bir kez çağrılabileceği şekilde fn'nin çağrılmasını koruyan bir işlev döndürür. Hesaplanan ilk değer, sonraki çağrılarda döndürülür.

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

mümkün olduğunca basit tutun

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

Sonucu görebilirsiniz

JQuery, one () yöntemini kullanarak işlevi yalnızca bir kez çağırmaya izin verir :

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>

() Üzerinde JQuery yöntemini kullanarak uygulama :

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>

Yerel JS kullanarak uygulama:

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

Bu, sonsuz döngüleri önlemek için kullanışlıdır (jQuery kullanarak):

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

Ad alanı kirliliğinden endişeleniyorsanız, "doIt" için uzun, rastgele bir dizeyi değiştirin.

Yapışkan yürütmeyi önlemeye yardımcı olur

var done = false;

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