Hàm trong JavaScript chỉ có thể được gọi một lần

Tôi cần tạo một hàm chỉ có thể được thực thi một lần, trong mỗi lần sau lần đầu tiên nó sẽ không được thực thi. Tôi biết từ C ++ và Java về các biến tĩnh có thể thực hiện công việc nhưng tôi muốn biết liệu có cách nào hiệu quả hơn để làm điều này không?

Nếu bởi "sẽ không được thực thi", bạn có nghĩa là "sẽ không làm gì khi được gọi nhiều lần", bạn có thể tạo một bao đóng:

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

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

Trả lời nhận xét của @Vladloffe (hiện đã bị xóa): Với một biến toàn cục, mã khác có thể đặt lại giá trị của cờ "đã thực thi" (bất kỳ tên nào bạn chọn cho nó). Với việc đóng, các mã khác không có cách nào để làm điều đó, dù vô tình hay cố ý.

Như các câu trả lời khác ở đây chỉ ra, một số thư viện (chẳng hạn như Dấu gạch dưới và Ramda ) có một hàm tiện ích nhỏ (thường được đặt tên là once()^[*] ) chấp nhận một hàm làm đối số và trả về một hàm khác gọi hàm được cung cấp chính xác một lần, bất kể cách thức nhiều lần hàm trả về được gọi. Hàm trả về cũng lưu trữ giá trị được trả về đầu tiên bởi hàm được cung cấp và trả về giá trị đó trong các lần gọi tiếp theo.

Tuy nhiên, nếu bạn không sử dụng thư viện của bên thứ ba như vậy, nhưng vẫn muốn có một chức năng tiện ích như vậy (thay vì giải pháp nonce mà tôi đã đưa ra ở trên), nó đủ dễ dàng để thực hiện. Phiên bản đẹp nhất mà tôi đã thấy là phiên bản này được đăng bởi David Walsh :

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

Tôi sẽ có xu hướng thay đổi fn = null;thành fn = context = null;. Không có lý do gì cho việc đóng cửa để duy trì một tham chiếu đến contextmột lần fnđã được gọi.

^[*] _{Tuy nhiên, hãy lưu ý rằng các thư viện khác, chẳng hạn như phần mở rộng Drupal này cho jQuery , có thể có một hàm có tên once()thực hiện một cái gì đó khá khác biệt.}

Thay thế nó bằng một chức năng NOOP (không hoạt động) có thể tái sử dụng .

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

Trỏ đến một hàm trống khi nó đã được gọi:

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>

Hoặc, như vậy:

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 có một chức năng thực hiện điều đó, 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;
    };
  };

Nói về biến tĩnh, điều này hơi giống với biến thể đóng:

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

once(); once(); 

Sau đó, bạn có thể đặt lại một chức năng nếu bạn muốn:

once.done = false;

var quit = false;

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

Bạn có thể chỉ cần có chức năng "loại bỏ chính nó"

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

    Once = undefined;
}

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

Nhưng đây có thể không phải là câu trả lời tốt nhất nếu bạn không muốn mắc lỗi nuốt chữ.

Bạn cũng có thể làm điều này:

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

    Once = function(){};
}

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

Tôi cần nó hoạt động giống như con trỏ thông minh, nếu không có phần tử nào từ kiểu A, nó có thể được thực thi, nếu có một hoặc nhiều phần tử A thì hàm không thể thực thi được.

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

    // do stuff
}

thử cái này

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

Từ một anh chàng tên là Crockford ... :)

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

invalidateChức năng có thể tái sử dụng hoạt động với 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);

Hãy thử nó trên JSBin: https://jsbin.com/vicipar/edit?js,console

Biến thể của câu trả lời từ Bunyk

Đây là một ví dụ JSFiddle - http://jsfiddle.net/6yL6t/

Và mã:

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

Bạn có thể làm:

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

Và nó sẽ chỉ chạy một lần :)

Thiết lập ban đầu:

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

Nếu bạn đang sử dụng Node.js hoặc viết JavaScript với Browserify, hãy xem xét mô-đun npm "một lần" :

var once = require('once')

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

Nếu bạn muốn có thể sử dụng lại chức năng này trong tương lai thì chức năng này hoạt động tốt dựa trên mã của ed Hopp ở trên (tôi nhận thấy rằng câu hỏi ban đầu không yêu cầu tính năng bổ sung này!):

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

Đầu ra trông giống như:

Hello World!
Reset
Hello World!

trang trí đơn giản dễ viết khi bạn cần

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

sử dụng:

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

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

Cố gắng sử dụng dấu gạch dưới hàm "một lần":

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

Nếu bạn đang sử dụng Ramda, bạn có thể sử dụng chức năng "một lần" .

Trích dẫn từ tài liệu:

một lần Hàm (a… → b) → (a… → b) THAM SỐ được thêm vào v0.1.0

Chấp nhận một hàm fn và trả về một hàm bảo vệ việc gọi fn sao cho fn chỉ có thể được gọi một lần, bất kể hàm trả về được gọi bao nhiêu lần. Giá trị đầu tiên được tính toán được trả về trong các lần gọi tiếp theo.

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

giữ nó càng đơn giản càng tốt

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

Bạn có thể xem kết quả

JQuery chỉ cho phép gọi hàm một lần bằng phương thức 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>

Triển khai bằng phương thức JQuery trên () :

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>

Triển khai bằng JS gốc:

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

Điều này rất hữu ích để ngăn chặn các vòng lặp vô hạn (sử dụng jQuery):

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

Nếu bạn lo lắng về ô nhiễm không gian tên, hãy thêm một chuỗi dài, ngẫu nhiên cho "doIt".

Nó giúp ngăn chặn quá trình thực thi dính

var done = false;

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