Is there a rule of thumb to decide when to use trigger or triggerMethod in Backbone.Marionette?

Question

I'm playing a bit with Backbone.js and Backbone.Marionette and I would like to know what's the difference between trigger and triggerMethod.

In particular, is there any rule of thumb to decide when use the former or the latter?

In my mind events, for example, are useful to communicate between a DOM element and its view.

triggerMethod is used in Marionette to update in cascade different components, e.g. a layout calls the show method to its children (children respond to onShow). So, for me its the same as calling a direct method on it. Is this true?

What about trigger?

Thanks you in advance.

Giuseppinagiustina

Answer 1

There isn't a huge difference, and it simply depends on what you want to do...

• trigger will trigger an event
• triggerMethod will trigger an event AND call a corresponding method according to naming convention (see https://marionettejs.com/docs/v2.1.0/marionette.functions.html#marionettetriggermethod)

Obviously, if you only want to trigger an event, you'd use trigger. But using trigger you also create a "home made" triggerMethod implementation: trigger the event, then have a listener that will call the function you want.

So what about triggerMethod ? As mentioned above, it will trigger an event and call a method. So if your only objective is to call the method in the first place, there isn't necessarily a need for using triggerMethod.

So why would one use triggerMethod at all? Because it gives you "hooks" to add functionality with event listeners. In my book on Marionette, for example, there is a triggerMethod call in https://github.com/davidsulc/marionette-gentle-introduction/blob/master/assets/js/apps/contacts/edit/edit_controller.js#L24 to display error messages on a form. The same could be achieved by simply calling

view.onFormDataInvalid(contact.validationError);

But as mentioned above, triggerMethod give us a "hook" for later use. For example, let's say I want to add logging of user errors: I can simply add a listener to my view:

initialize: function(){
  this.on("form:data:invalid", function(validationError){
    // log error here
  }
}

This additonal functionality can be added without impacting the rest of the code, because we've used triggerMethod instead of a direct method call. In addition, it will be easier to test later (small tests, with single point of failure):

• test that "form:data:invalid" event is triggered when a user enters incorrect info
• test that when "form:data:invalid" event is triggered, error gets logged
• etc.

Amnesia

Awesome. So I could just use triggerMethod instead of trigger. But in both cases the view will respond to them is the same of the one I send that message to. True? With an exception for collection views that are able to forward events. P.S. I've already your books. ;-) – Giuseppinagiustina

Errata: ...the one I send the message from. – Giuseppinagiustina

If you call myView.triggerMethod("do:something", x), the onDoSomething method will be called on myView, and will receive argument x... – Amnesia

Hi David, thanks for the great explanation. But the link provided above [github.com/marionettejs/backbone.marionette/blob/master/docs/… is not working. – Expose

Indeed the answer is 4.5 years old, and it seems Marionette has reworked its documentation. You can find the information you're after at marionettejs.com/docs/v2.1.0/… (I've updated the link in the answer) – Amnesia

Answer 2

trigger(name)

• Part of Backbone.js
• Triggers event using the name passed in

triggerMethod(name)

• Part of Marionnete.js

• Does everything trigger(name) does

• Also calls methods using a predefined naming convention.

  eg. triggerMethod('foo') will call onFoo()

  eg. triggerMethod('foo:bar') will call onFooBar()

Abomb

Thanks for your feedback. Here my question was: why prefer the latter to the former? Have you any other case different from David one? – Giuseppinagiustina