home
  • Blog
  • Home
  • Projects
    • Ember
    • EmberData
    • Ember CLI
2.18
  • Packages
    • @ember/application
    • @ember/array
    • @ember/component
    • @ember/controller
    • @ember/debug
    • @ember/engine
    • @ember/error
    • @ember/object
    • @ember/polyfills
    • @ember/routing
    • @ember/runloop
    • @ember/service
    • @ember/string
    • @ember/test
    • @ember/utils
    • ember-glimmer
    • jquery
  • Classes
    • Adapter
    • Application
    • ApplicationInstance
    • ApplicationInstance.BootOptions
    • ArrayProxy
    • Checkbox
    • Component
    • ComputedProperty
    • ContainerDebugAdapter
    • ContainerProxyMixin
    • Controller
    • CoreObject
    • DataAdapter
    • Ember.Debug
    • Ember.Logger
    • Ember.MutableEnumerable
    • Ember.Namespace
    • Ember.NativeArray
    • Ember.Templates.helpers
    • Ember.Test
    • Ember.Test.QUnitAdapter
    • EmberArray
    • EmberError
    • EmberObject
    • Engine
    • EngineInstance
    • Evented
    • GlobalsResolver
    • HashLocation
    • Helper
    • HistoryLocation
    • LinkComponent
    • Mixin
    • MutableArray
    • NoneLocation
    • ObjectProxy
    • Observable
    • PromiseProxyMixin
    • RSVP.EventTarget
    • RSVP.Promise
    • Route
    • Router
    • RouterService
    • Service
    • String
    • TextArea
    • TextField

Class Ember.ControllerMixin private


Uses: Ember.ActionHandler
Defined in: packages/ember-runtime/lib/mixins/controller.js:5
Module: ember


Methods

replaceRoute (name, models) public

Module: ember

Defined in packages/ember-routing/lib/ext/controller.js:155

name
String

the name of the route or a URL

models
...Object

the model(s) or identifier(s) to be used while transitioning to the route.

Transition into another route while replacing the current URL, if possible. This will replace the current history entry instead of adding a new one. Beside that, it is identical to transitionToRoute in all other respects.

aController.replaceRoute('blogPosts');
aController.replaceRoute('blogPosts.recentEntries');

Optionally supply a model for the route in question. The model will be serialized into the URL using the serialize hook of the route:

aController.replaceRoute('blogPost', aPost);

If a literal is passed (such as a number or a string), it will be treated as an identifier instead. In this case, the model hook of the route will be triggered:

aController.replaceRoute('blogPost', 1);

Multiple models will be applied last to first recursively up the route tree.

app/router.js
Router.map(function() {
  this.route('blogPost', { path: ':blogPostId' }, function() {
    this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
  });
});
aController.replaceRoute('blogComment', aPost, aComment);
aController.replaceRoute('blogComment', 1, 13);

It is also possible to pass a URL (a string that starts with a /). This is intended for testing and debugging purposes and should rarely be used in production code.

aController.replaceRoute('/');
aController.replaceRoute('/blog/post/1/comment/13');

send (actionName, context) public

Module: ember

Inherited from Ember.ActionHandler packages/ember-runtime/lib/mixins/action_handler.js:167

actionName
String

The action to trigger

context
*

a context to send with the action

Triggers a named action on the ActionHandler. Any parameters supplied after the actionName string will be passed as arguments to the action target function.

If the ActionHandler has its target property set, actions may bubble to the target. Bubbling happens when an actionName can not be found in the ActionHandler's actions hash or if the action target function returns true.

Example

app/routes/welcome.js
import Route from '@ember/routing/route';

export default Route.extend({
  actions: {
    playTheme() {
      this.send('playMusic', 'theme.mp3');
    },
    playMusic(track) {
      // ...
    }
  }
});

transitionToRoute (name, models, options) public

Module: ember

Defined in packages/ember-routing/lib/ext/controller.js:74

name
String

the name of the route or a URL

models
...Object

the model(s) or identifier(s) to be used while transitioning to the route.

options
Object

optional hash with a queryParams property containing a mapping of query parameters

Transition the application into another route. The route may be either a single route or route path:

aController.transitionToRoute('blogPosts');
aController.transitionToRoute('blogPosts.recentEntries');

Optionally supply a model for the route in question. The model will be serialized into the URL using the serialize hook of the route:

aController.transitionToRoute('blogPost', aPost);

If a literal is passed (such as a number or a string), it will be treated as an identifier instead. In this case, the model hook of the route will be triggered:

aController.transitionToRoute('blogPost', 1);

Multiple models will be applied last to first recursively up the route tree.

app/router.js
Router.map(function() {
  this.route('blogPost', { path: ':blogPostId' }, function() {
    this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
  });
});
aController.transitionToRoute('blogComment', aPost, aComment);
aController.transitionToRoute('blogComment', 1, 13);

It is also possible to pass a URL (a string that starts with a /). This is intended for testing and debugging purposes and should rarely be used in production code.

aController.transitionToRoute('/');
aController.transitionToRoute('/blog/post/1/comment/13');
aController.transitionToRoute('/blog/posts?sort=title');

An options hash with a queryParams property may be provided as the final argument to add query parameters to the destination URL.

aController.transitionToRoute('blogPost', 1, {
  queryParams: { showComments: 'true' }
});

// if you just want to transition the query parameters without changing the route
aController.transitionToRoute({ queryParams: { sort: 'date' } });

See also replaceRoute.

Properties

actions public

Module: ember

Inherited from Ember.ActionHandler packages/ember-runtime/lib/mixins/action_handler.js:22

The collection of functions, keyed by name, available on this ActionHandler as action targets.

These functions will be invoked when a matching {{action}} is triggered from within a template and the application's current route is this route.

Actions can also be invoked from other parts of your application via ActionHandler#send.

The actions hash will inherit action handlers from the actions hash defined on extended parent classes or mixins rather than just replace the entire hash, e.g.:

app/mixins/can-display-banner.js
import Mixin from '@ember/mixin';

export default Mixin.create({
  actions: {
    displayBanner(msg) {
      // ...
    }
  }
});
app/routes/welcome.js
import Route from '@ember/routing/route';
import CanDisplayBanner from '../mixins/can-display-banner';

export default Route.extend(CanDisplayBanner, {
  actions: {
    playMusic() {
      // ...
    }
  }
});

// `WelcomeRoute`, when active, will be able to respond
// to both actions, since the actions hash is merged rather
// then replaced when extending mixins / parent classes.
this.send('displayBanner');
this.send('playMusic');

Within a Controller, Route or Component's action handler, the value of the this context is the Controller, Route or Component object:

app/routes/song.js
import Route from '@ember/routing/route';

export default Route.extend({
  actions: {
    myAction() {
      this.controllerFor("song");
      this.transitionTo("other.route");
      ...
    }
  }
});

It is also possible to call this._super(...arguments) from within an action handler if it overrides a handler defined on a parent class or mixin:

Take for example the following routes:

app/mixins/debug-route.js
import Mixin from '@ember/mixin';

export default Ember.Mixin.create({
  actions: {
    debugRouteInformation() {
      console.debug("It's a-me, console.debug!");
    }
  }
});
app/routes/annoying-debug.js
import Route from '@ember/routing/route';
import DebugRoute from '../mixins/debug-route';

export default Route.extend(DebugRoute, {
  actions: {
    debugRouteInformation() {
      // also call the debugRouteInformation of mixed in DebugRoute
      this._super(...arguments);

      // show additional annoyance
      window.alert(...);
    }
  }
});

Bubbling

By default, an action will stop bubbling once a handler defined on the actions hash handles it. To continue bubbling the action, you must return true from the handler:

app/router.js
Router.map(function() {
  this.route("album", function() {
    this.route("song");
  });
});
app/routes/album.js
import Route from '@ember/routing/route';

export default Route.extend({
  actions: {
    startPlaying: function() {
    }
  }
});
app/routes/album-song.js
import Route from '@ember/routing/route';

export default Route.extend({
  actions: {
    startPlaying() {
      // ...

      if (actionShouldAlsoBeTriggeredOnParentRoute) {
        return true;
      }
    }
  }
});

model public

Module: ember

Defined in packages/ember-runtime/lib/mixins/controller.js:35

The controller's current model. When retrieving or modifying a controller's model, this property should be used instead of the content property.

queryParams public

Module: ember

Defined in packages/ember-routing/lib/ext/controller.js:12

Defines which query parameters the controller accepts. If you give the names ['category','page'] it will bind the values of these query parameters to the variables this.category and this.page. By default, Ember coerces query parameter values using toggleProperty. This behavior may lead to unexpected results. To explicitly configure a query parameter property so it coerces as expected, you must define a type property:

  queryParams: [{
    category: {
      type: 'boolean'
    }
  }]

target public

Module: ember

Defined in packages/ember-runtime/lib/mixins/controller.js:15

The object to which actions from the view should be sent.

For example, when a Handlebars template uses the {{action}} helper, it will attempt to send the action to the view's controller's target.

By default, the value of the target property is set to the router, and is injected when a controller is instantiated. This injection is applied as part of the application's initialization process. In most cases the target property will automatically be set to the logical consumer of actions for the controller.

On this page


Methods

  • replaceRoute
  • send
  • transitionToRoute

Properties

  • actions
  • model
  • queryParams
  • target
Team Sponsors Security Legal Branding Community Guidelines
Twitter GitHub Discord Mastodon

If you want help you can contact us by email, open an issue, or get realtime help by joining the Ember Discord.

© Copyright 2026 - Tilde Inc.
Ember.js is free, open source and always will be.


Ember is generously supported by
blue Created with Sketch.