Class Component

public

A component is a reusable UI element that consists of a .hbs template and an optional JavaScript class that defines its behavior. For example, someone might make a button in the template and handle the click behavior in the JavaScript file that shares the same name as the template.

Components are broken down into two categories:

  • Components without JavaScript, that are based only on a template. These are called Template-only or TO components.
  • Components with JavaScript, which consist of a template and a backing class.

Ember ships with two types of JavaScript classes for components:

  1. Glimmer components, imported from @glimmer/component, which are the default component's for Ember Octane (3.15) and more recent editions.
  2. Classic components, imported from @ember/component, which were the default for older editions of Ember (pre 3.15).

Below is the documentation for Classic components. If you are looking for the API documentation for Template-only or Glimmer components, it is available here.

Defining a Classic Component

If you want to customize the component in order to handle events, transform arguments or maintain internal state, you implement a subclass of Component.

One example is to add computed properties to your component:

profile.js
1
2
3
4
5
6
7
8
9
10
11
12
13
import Component from '@ember/component';

export default Component.extend({
  displayName: computed('person.title', 'person.firstName', 'person.lastName', function() {
    let { title, firstName, lastName } = this.person;

    if (title) {
      return `${title} ${lastName}`;
    } else {
      return `${firstName} ${lastName}`;
    }
  })
});

And then use it in the component's template:

profile.hbs
1
2
<h1>{{this.displayName}}</h1>
{{yield}}

Customizing a Classic Component's HTML Element in JavaScript

HTML Tag

The default HTML tag name used for a component's HTML representation is div. This can be customized by setting the tagName property.

Consider the following component class:

paragraph.js
1
2
3
4
5
import Component from '@ember/component';

export default Component.extend({
  tagName: 'em'
});

When invoked, this component would produce output that looks something like this:

1
<em id="ember1" class="ember-view"></em>

HTML class Attribute

The HTML class attribute of a component's tag can be set by providing a classNames property that is set to an array of strings:

widget.js
1
2
3
4
5
import Component from '@ember/component';

export default Component.extend({
  classNames: ['my-class', 'my-other-class']
});

Invoking this component will produce output that looks like this:

1
<div id="ember1" class="ember-view my-class my-other-class"></div>

class attribute values can also be set by providing a classNameBindings property set to an array of properties names for the component. The return value of these properties will be added as part of the value for the components's class attribute. These properties can be computed properties:

widget.js
1
2
3
4
5
6
7
8
9
10
11
12
import Component from '@ember/component';
import { computed } from '@ember/object';

export default Component.extend({
  classNames: ['my-class', 'my-other-class'],
  classNameBindings: ['propertyA', 'propertyB'],

  propertyA: 'from-a',
  propertyB: computed(function() {
    if (someLogic) { return 'from-b'; }
  })
});

Invoking this component will produce HTML that looks like:

1
<div id="ember1" class="ember-view my-class my-other-class from-a from-b"></div>

Note that classNames and classNameBindings is in addition to the class attribute passed with the angle bracket invocation syntax. Therefore, if this component was invoked like so:

1
<MyWidget class="from-invocation" />

The resulting HTML will look similar to this:

1
<div id="ember1" class="from-invocation ember-view my-class my-other-class from-a from-b"></div>

If the value of a class name binding returns a boolean the property name itself will be used as the class name if the property is true. The class name will not be added if the value is false or undefined.

widget.js
1
2
3
4
5
6
7
import Component from '@ember/component';

export default Component.extend({
  classNameBindings: ['hovered'],

  hovered: true
});

Invoking this component will produce HTML that looks like:

1
<div id="ember1" class="ember-view hovered"></div>

Custom Class Names for Boolean Values

When using boolean class name bindings you can supply a string value other than the property name for use as the class HTML attribute by appending the preferred value after a ":" character when defining the binding:

widget.js
1
2
3
4
5
6
7
import Component from '@ember/component';

export default Component.extend({
  classNameBindings: ['awesome:so-very-cool'],

  awesome: true
});

Invoking this component will produce HTML that looks like:

1
<div id="ember1" class="ember-view so-very-cool"></div>

Boolean value class name bindings whose property names are in a camelCase-style format will be converted to a dasherized format:

widget.js
1
2
3
4
5
6
7
import Component from '@ember/component';

export default Component.extend({
  classNameBindings: ['isUrgent'],

  isUrgent: true
});

Invoking this component will produce HTML that looks like:

1
<div id="ember1" class="ember-view is-urgent"></div>

Class name bindings can also refer to object values that are found by traversing a path relative to the component itself:

widget.js
1
2
3
4
5
6
7
8
9
10
import Component from '@ember/component';
import EmberObject from '@ember/object';

export default Component.extend({
  classNameBindings: ['messages.empty'],

  messages: EmberObject.create({
    empty: true
  })
});

Invoking this component will produce HTML that looks like:

1
<div id="ember1" class="ember-view empty"></div>

If you want to add a class name for a property which evaluates to true and and a different class name if it evaluates to false, you can pass a binding like this:

widget.js
1
2
3
4
5
6
import Component from '@ember/component';

export default Component.extend({
  classNameBindings: ['isEnabled:enabled:disabled'],
  isEnabled: true
});

Invoking this component will produce HTML that looks like:

1
<div id="ember1" class="ember-view enabled"></div>

When isEnabled is false, the resulting HTML representation looks like this:

1
<div id="ember1" class="ember-view disabled"></div>

This syntax offers the convenience to add a class if a property is false:

widget.js
1
2
3
4
5
6
7
import Component from '@ember/component';

// Applies no class when isEnabled is true and class 'disabled' when isEnabled is false
export default Component.extend({
  classNameBindings: ['isEnabled::disabled'],
  isEnabled: true
});

Invoking this component when the isEnabled property is true will produce HTML that looks like:

1
<div id="ember1" class="ember-view"></div>

Invoking it when the isEnabled property on the component is false will produce HTML that looks like:

1
<div id="ember1" class="ember-view disabled"></div>

Updates to the value of a class name binding will result in automatic update of the HTML class attribute in the component's rendered HTML representation. If the value becomes false or undefined the class name will be removed.

Both classNames and classNameBindings are concatenated properties. See EmberObject documentation for more information about concatenated properties.

Other HTML Attributes

The HTML attribute section of a component's tag can be set by providing an attributeBindings property set to an array of property names on the component. The return value of these properties will be used as the value of the component's HTML associated attribute:

anchor.js
1
2
3
4
5
6
7
8
import Component from '@ember/component';

export default Component.extend({
  tagName: 'a',
  attributeBindings: ['href'],

  href: 'http://google.com'
});

Invoking this component will produce HTML that looks like:

1
<a id="ember1" class="ember-view" href="http://google.com"></a>

One property can be mapped on to another by placing a ":" between the source property and the destination property:

anchor.js
1
2
3
4
5
6
7
8
import Component from '@ember/component';

export default Component.extend({
  tagName: 'a',
  attributeBindings: ['url:href'],

  url: 'http://google.com'
});

Invoking this component will produce HTML that looks like:

1
<a id="ember1" class="ember-view" href="http://google.com"></a>

HTML attributes passed with angle bracket invocations will take precedence over those specified in attributeBindings. Therefore, if this component was invoked like so:

1
<MyAnchor href="http://bing.com" @url="http://google.com" />

The resulting HTML will looks like this:

1
<a id="ember1" class="ember-view" href="http://bing.com"></a>

Note that the href attribute is ultimately set to http://bing.com, despite it having attribute binidng to the url property, which was set to http://google.com.

Namespaced attributes (e.g. xlink:href) are supported, but have to be mapped, since : is not a valid character for properties in Javascript:

use.js
1
2
3
4
5
6
7
8
import Component from '@ember/component';

export default Component.extend({
  tagName: 'use',
  attributeBindings: ['xlinkHref:xlink:href'],

  xlinkHref: '#triangle'
});

Invoking this component will produce HTML that looks like:

1
<use xlink:href="#triangle"></use>

If the value of a property monitored by attributeBindings is a boolean, the attribute will be present or absent depending on the value:

input.js
1
2
3
4
5
6
7
8
import Component from '@ember/component';

export default Component.extend({
  tagName: 'input',
  attributeBindings: ['disabled'],

  disabled: false
});

Invoking this component will produce HTML that looks like:

1
<input id="ember1" class="ember-view" />

attributeBindings can refer to computed properties:

input.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import Component from '@ember/component';
import { computed } from '@ember/object';

export default Component.extend({
  tagName: 'input',
  attributeBindings: ['disabled'],

  disabled: computed(function() {
    if (someLogic) {
      return true;
    } else {
      return false;
    }
  })
});

To prevent setting an attribute altogether, use null or undefined as the value of the property used in attributeBindings:

input.js
1
2
3
4
5
6
7
import Component from '@ember/component';

export default Component.extend({
  tagName: 'form',
  attributeBindings: ['novalidate'],
  novalidate: null
});

Updates to the property of an attribute binding will result in automatic update of the HTML attribute in the component's HTML output.

attributeBindings is a concatenated property. See EmberObject documentation for more information about concatenated properties.

Layouts

The layout property can be used to dynamically specify a template associated with a component class, instead of relying on Ember to link together a component class and a template based on file names.

In general, applications should not use this feature, but it's commonly used in addons for historical reasons.

The layout property should be set to the default export of a template module, which is the name of a template file without the .hbs extension.

profile.hbs
1
2
<h1>Person's Title</h1>
<div class='details'>{{yield}}</div>
profile.js
1
2
3
4
5
6
  import Component from '@ember/component';
  import layout from '../templates/components/person-profile';

  export default Component.extend({
    layout
  });

If you invoke the component:

1
2
3
4
<PersonProfile>
  <h2>Chief Basket Weaver</h2>
  <h3>Fisherman Industries</h3>
</PersonProfile>

or

1
2
3
4
{{#person-profile}}
  <h2>Chief Basket Weaver</h2>
  <h3>Fisherman Industries</h3>
{{/person-profile}}

It will result in the following HTML output:

1
2
3
4
5
<h1>Person's Title</h1>
  <div class="details">
  <h2>Chief Basket Weaver</h2>
  <h3>Fisherman Industries</h3>
</div>

Handling Browser Events

Components can respond to user-initiated events in one of three ways: passing actions with angle bracket invocation, adding event handler methods to the component's class, or adding actions to the component's template.

Passing Actions With Angle Bracket Invocation

For one-off events specific to particular instance of a component, it is possible to pass actions to the component's element using angle bracket invocation syntax.

1
2
3
<MyWidget {{action 'firstWidgetClicked'}} />

<MyWidget {{action 'secondWidgetClicked'}} />

In this case, when the first component is clicked on, Ember will invoke the firstWidgetClicked action. When the second component is clicked on, Ember will invoke the secondWidgetClicked action instead.

Besides {{action}}, it is also possible to pass any arbitrary element modifiers using the angle bracket invocation syntax.

Event Handler Methods

Components can also respond to user-initiated events by implementing a method that matches the event name. This approach is appropriate when the same event should be handled by all instances of the same component.

An event object will be passed as the argument to the event handler method.

widget.js
1
2
3
4
5
6
7
8
9
import Component from '@ember/component';

export default Component.extend({
  click(event) {
    // `event.target` is either the component's element or one of its children
    let tag = event.target.tagName.toLowerCase();
    console.log('clicked on a `<${tag}>` HTML element!');
  }
});

In this example, whenever the user clicked anywhere inside the component, it will log a message to the console.

It is possible to handle event types other than click by implementing the following event handler methods. In addition, custom events can be registered by using Application.customEvents.

Touch events:

  • touchStart
  • touchMove
  • touchEnd
  • touchCancel

Keyboard events:

  • keyDown
  • keyUp
  • keyPress

Mouse events:

  • mouseDown
  • mouseUp
  • contextMenu
  • click
  • doubleClick
  • focusIn
  • focusOut

Form events:

  • submit
  • change
  • focusIn
  • focusOut
  • input

Drag and drop events:

  • dragStart
  • drag
  • dragEnter
  • dragLeave
  • dragOver
  • dragEnd
  • drop

{{action}} Helper

Instead of handling all events of a particular type anywhere inside the component's element, you may instead want to limit it to a particular element in the component's template. In this case, it would be more convenient to implement an action instead.

For example, you could implement the action hello for the person-profile component:

profile.js
1
2
3
4
5
6
7
8
9
import Component from '@ember/component';

export default Component.extend({
  actions: {
    hello(name) {
      console.log("Hello", name);
    }
  }
});

And then use it in the component's template:

profile.hbs
1
2
3
4
5
<h1>{{@person.name}}</h1>

<button {{action 'hello' @person.name}}>
  Say Hello to {{@person.name}}
</button>

When the user clicks the button, Ember will invoke the hello action, passing in the current value of @person.name as an argument.

See Ember.Templates.helpers.action.

Show:

selector
String
a jQuery-compatible selector string
returns
JQuery
the jQuery object for the DOM node

Returns a jQuery object for this component's element. If you pass in a selector string, this method will return a jQuery object, using the current element as its buffer.

For example, calling component.$('li') will return a jQuery object containing all of the li elements inside the DOM element of this component.

Please note that jQuery integration is off by default and this feature will not work properly. To enable this feature, you can read the instructions in the jquery-integration optional feature guide.

key
String
The key to observe
target
Object
The target object to invoke
method
String|Function
The method to invoke
sync
Boolean
Whether the observer is sync or not
returns
Observable

Adds an observer on a property.

This is the core method used to register an observer for a property.

Once you call this method, any time the key's value is set, your observer will be notified. Note that the observers are triggered any time the value is set, regardless of whether it has actually changed. Your observer should be prepared to handle that.

There are two common invocation patterns for .addObserver():

  • Passing two arguments:
    • the name of the property to observe (as a string)
    • the function to invoke (an actual function)
  • Passing three arguments:
    • the name of the property to observe (as a string)
    • the target object (will be used to look up and invoke a function on)
    • the name of the function to invoke on the target object (as a string).
component.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import Component from '@ember/component';

export default Component.extend({
  init() {
    this._super(...arguments);

    // the following are equivalent:

    // using three arguments
    this.addObserver('foo', this, 'fooDidChange');

    // using two arguments
    this.addObserver('foo', (...args) => {
      this.fooDidChange(...args);
    });
  },

  fooDidChange() {
    // your custom logic code
  }
});

Observer Methods

Observer methods have the following signature:

component.js
1
2
3
4
5
6
7
8
9
10
11
12
import Component from '@ember/component';

export default Component.extend({
  init() {
    this._super(...arguments);
    this.addObserver('foo', this, 'fooDidChange');
  },

  fooDidChange(sender, key, value, rev) {
    // your code
  }
});

The sender is the object that changed. The key is the property that changes. The value property is currently reserved and unused. The rev is the last property revision of the object when it changed, which you can use to detect if the key value has really changed or not.

Usually you will not need the value or revision parameters at the end. In this case, it is common to write observer methods that take only a sender and key value as parameters or, if you aren't interested in any of these values, to write an observer that has no parameters at all.

keyName
String
returns
Object
The cached value of the computed property, if any

Returns the cached value of a computed property, if it exists. This allows you to inspect the value of a computed property without accidentally invoking it if it is intended to be generated lazily.

keyName
String
The name of the property to decrement
decrement
Number
The amount to decrement by. Defaults to 1
returns
Number
The new property value

Set the value of a property to the current value minus some amount.

1
2
player.decrementProperty('lives');
orc.decrementProperty('health', 5);
returns
EmberObject
receiver

Destroys an object by setting the isDestroyed flag and removing its metadata, which effectively destroys observers and bindings.

If you try to set a property on a destroyed object, an exception will be raised.

Note that destruction is scheduled for the end of the run loop and does not happen immediately. It will set an isDestroying flag immediately.

Available since v1.13.0

Called when the attributes passed into the component have been updated. Called both during the initial render of a container and during a rerender. Can be used in place of an observer; code placed here will be executed every time any attribute updates.

Available since v1.13.0

Called after a component has been rendered, both on initial render and in subsequent rerenders.

Available since v1.13.0

Called when the component has updated and rerendered itself. Called only during a rerender, not during an initial render.

Available since v1.13.0

Called when the attributes passed into the component have been changed. Called only during a rerender, not during an initial render.

keyName
String
The property to retrieve
returns
Object
The property value or undefined.

Retrieves the value of a property from the object.

This method is usually similar to using object[keyName] or object.keyName, however it supports both computed properties and the unknownProperty handler.

Because get unifies the syntax for accessing all these kinds of properties, it can make many refactorings easier, such as replacing a simple property with a computed property, or vice versa.

Computed Properties

Computed properties are methods defined with the property modifier declared at the end, such as:

1
2
3
4
5
import { computed } from '@ember/object';

fullName: computed('firstName', 'lastName', function() {
  return this.get('firstName') + ' ' + this.get('lastName');
})

When you call get on a computed property, the function will be called and the return value will be returned instead of the function itself.

Unknown Properties

Likewise, if you try to call get on a property whose value is undefined, the unknownProperty() method will be called on the object. If this method returns any value other than undefined, it will be returned instead. This allows you to implement "virtual" properties that are not defined upfront.

list
String...|Array
of keys to get
returns
Object

To get the values of multiple properties at once, call getProperties with a list of strings or an array:

1
2
record.getProperties('firstName', 'lastName', 'zipCode');
// { firstName: 'John', lastName: 'Doe', zipCode: '10011' }

is equivalent to:

1
2
record.getProperties(['firstName', 'lastName', 'zipCode']);
// { firstName: 'John', lastName: 'Doe', zipCode: '10011' }
name
String
The name of the event
returns
Boolean
does the object have a subscription for event

Checks to see if object has any subscriptions for named event.

keyName
String
The name of the property to increment
increment
Number
The amount to increment by. Defaults to 1
returns
Number
The new property value

Set the value of a property to the current value plus some amount.

1
2
person.incrementProperty('age');
team.incrementProperty('score', 2);

An overridable method called when objects are instantiated. By default, does nothing unless it is overridden during class definition.

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
import EmberObject from '@ember/object';

const Person = EmberObject.extend({
  init() {
    alert(`Name is ${this.get('name')}`);
  }
});

let steve = Person.create({
  name: 'Steve'
});

// alerts 'Name is Steve'.

NOTE: If you do override init for a framework class like Component from @ember/component, be sure to call this._super(...arguments) in your init declaration! If you don't, Ember may not have an opportunity to do important setup work, and you'll see strange behavior in your application.

keyName
String
The property key to be notified about.
returns
Observable

Notify the observer system that a property has just changed.

Sometimes you need to change a value directly or indirectly without actually calling get() or set() on it. In this case, you can use this method instead. Calling this method will notify all observers that the property has potentially changed value.

name
String
The name of the event
target
Object
The target of the subscription
method
Function|String
The function or the name of a function of the subscription
returns
this

Cancels subscription for given name, target, and method.

name
String
The name of the event
target
Object
The "this" binding for the callback
method
Function|String
A function or the name of a function to be called on `target`
returns
this

Subscribes to a named event with given function.

1
2
3
person.on('didLoad', function() {
  // fired once the person has loaded
});

An optional target can be passed in as the 2nd argument that will be set as the "this" for the callback. This is a good way to give your function access to the object triggering the event. When the target parameter is used the callback method becomes the third argument.

name
String
The name of the event
target
Object
The "this" binding for the callback
method
Function|String
A function or the name of a function to be called on `target`
returns
this

Subscribes a function to a named event and then cancels the subscription after the first time the event is triggered. It is good to use one when you only care about the first time an event has taken place.

This function takes an optional 2nd argument that will become the "this" value for the callback. When the target parameter is used the callback method becomes the third argument.

name
String
the name of the attribute
returns
String

Normally, Ember's component model is "write-only". The component takes a bunch of attributes that it got passed in, and uses them to render its template.

One nice thing about this model is that if you try to set a value to the same thing as last time, Ember (through HTMLBars) will avoid doing any work on the DOM.

This is not just a performance optimization. If an attribute has not changed, it is important not to clobber the element's "hidden state". For example, if you set an input's value to the same value as before, it will clobber selection state and cursor position. In other words, setting an attribute is not always idempotent.

This method provides a way to read an element's attribute and also update the last value Ember knows about at the same time. This makes setting an attribute idempotent.

In particular, what this means is that if you get an <input> element's value attribute and then re-render the template with the same value, it will avoid clobbering the cursor and selection position. Since most attribute sets are idempotent in the browser, you typically can get away with reading attributes using jQuery, but the most reliable way to do so is through this method.

key
String
The key to observe
target
Object
The target object to invoke
method
String|Function
The method to invoke
sync
Boolean
Whether the observer is async or not
returns
Observable

Remove an observer you have previously registered on this object. Pass the same key, target, and method you passed to addObserver() and your target will no longer receive notifications.

Renders the view again. This will work regardless of whether the view is already in the DOM or not. If the view is in the DOM, the rendering process will be deferred to give bindings a chance to synchronize.

If children were added during the rendering process using appendChild, rerender will remove them, because they will be added again if needed by the next render.

In general, if the display of your view changes, you should modify the DOM element directly instead of manually calling rerender, which can be slow.

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
1
2
3
4
5
6
7
8
9
10
11
12
import Route from '@ember/routing/route';

export default Route.extend({
  actions: {
    playTheme() {
      this.send('playMusic', 'theme.mp3');
    },
    playMusic(track) {
      // ...
    }
  }
});
keyName
String
The property to set
value
Object
The value to set or `null`.
returns
Object
The passed value

Sets the provided key or path to the value.

1
record.set("key", value);

This method is generally very similar to calling object["key"] = value or object.key = value, except that it provides support for computed properties, the setUnknownProperty() method and property observers.

Computed Properties

If you try to set a value on a key that has a computed property handler defined (see the get() method for an example), then set() will call that method, passing both the value and key instead of simply changing the value itself. This is useful for those times when you need to implement a property that is composed of one or more member properties.

Unknown Properties

If you try to set a value on a key that is undefined in the target object, then the setUnknownProperty() handler will be called instead. This gives you an opportunity to implement complex "virtual" properties that are not predefined on the object. If setUnknownProperty() returns undefined, then set() will simply set the value on the object.

Property Observers

In addition to changing the property, set() will also register a property change with the object. Unless you have placed this call inside of a beginPropertyChanges() and endPropertyChanges(), any "local" observers (i.e. observer methods declared on the same object), will be called immediately. Any "remote" observers (i.e. observer methods declared on another object) will be placed in a queue and called at a later time in a coalesced manner.

hash
Object
the hash of keys and values to set
returns
Object
The passed in hash

Sets a list of properties at once. These properties are set inside a single beginPropertyChanges and endPropertyChanges batch, so observers will be buffered.

1
record.setProperties({ firstName: 'Charles', lastName: 'Jolley' });
returns
String
string representation

Returns a string representation which attempts to provide more information than Javascript's toString typically does, in a generic way for all Ember objects.

1
2
3
4
5
import EmberObject from '@ember/object';

const Person = EmberObject.extend();
person = Person.create();
person.toString(); //=> "<Person:ember1024>"

If the object's class is not defined on an Ember namespace, it will indicate it is a subclass of the registered superclass:

1
2
3
const Student = Person.extend();
let student = Student.create();
student.toString(); //=> "<(subclass of Person):ember1025>"

If the method toStringExtension is defined, its return value will be included in the output.

1
2
3
4
5
6
7
const Teacher = Person.extend({
  toStringExtension() {
    return this.get('fullName');
  }
});
teacher = Teacher.create();
teacher.toString(); //=> "<Teacher:ember1026:Tom Dale>"
keyName
String
The name of the property to toggle
returns
Boolean
The new property value

Set the value of a boolean property to the opposite of its current value.

1
starship.toggleProperty('warpDriveEngaged');
name
String
The name of the event
args
Object...
Optional arguments to pass on

Triggers a named event for the object. Any additional arguments will be passed as parameters to the functions that are subscribed to the event.

1
2
3
4
5
6
7
person.on('didEat', function(food) {
  console.log('person ate some ' + food);
});

person.trigger('didEat', 'broccoli');

// outputs: person ate some broccoli

Override to implement teardown.

Available since v1.13.0

Called before a component has been rendered, both on initial render and in subsequent rerenders.

Available since v1.13.0

Called when the component is about to update and rerender itself. Called only during a rerender, not during an initial render.