Backbone.Events.once

[m64253]

Simple event helper to bind to an event an only have the callback trigger once.

[niallsmart]

Why not just use _.once? For example:

model.bind(event, _.once(callback));

[yuchi]

'Cause otherwise it will be called every time anyway. It's useless and wasting. Unbinding permits garbage collecting every reference.

[jashkenas]

To repeat myself from earlier this afternoon: I don't think that this is a common enough need to warrant addition to Backbone.Events ... especially when _.once is guaranteed to be available.

[khepin]

Just to put my grain of salt in there, I definitely see value in having such a "once" method, and _.once does not help in this case.

_.once returns the same result without calling the function again. But in some case the return value of a function is not what's interesting.

Sometimes it's an api call, sometimes it's some DOM manipulation. If I need to re-bind it later, then using _.once completely defeats the purpose.

[tedsuo]

Just came across this, thought I'd add another +1. For me, it's pretty common to only bind once in two cases: events that only happen once ( like an 'end' event), and events that happen frequently but are very decoupled from what is being hung on them ( a 'nextTick' event is an example). In both cases, it's important that references be cleaned up to prevent memory leaks. Mostly I do this in node.js, somewhat new to backbone but hit the same issue almost immediately.

Cheers,
T

[iturgeon]

fwiw, I could use this functionality right now

[philfreo]

Yesterday I also needed something like http://api.jquery.com/one/ (and _.once isn't the same)

[monokrome]

I'm interested in this, also.

Although using _.once does allow for a similar result - it does not unbind the event handler. If you have a long running application with many events, this would still result in many potentially unnecessary calls to once() simply because the method wasn't unbound.

This can be fixed by calling Event.off in each of your handlers that need to be called only once, but you may not have access to the context in some cases where you've provided a this argument. Using Event.off actually gets the intended result when you have the proper context to the object which on was called on, but my opinion is that it shouldn't be necessary to call off inside of your Event handler.

For instance, if I wanted to use jQuery.noop (as an example) as my handler, I would now have to do the following because I don't have access to the context of MyObject inside of noop:

// I can't use a lambda here, or I wouldn't be able to reference it from itself.
var something = function () {
    myInstance.off('exploded', something);
    jQuery.noop();
}

myInstance.on('exploded', something);

A much more simple solution would be:

myInstance.once('exploded', jQuery.noop);

I would think that wanting an event to only fire a specific handler a single time isn't too rare of a request, and it's definitely something that should be taken account in Backbone.