Class Component
publicimport Component from '@ember/component'; |
A Component
is a view that is completely
isolated. Properties accessed in its templates go
to the view object and actions are targeted at
the view object. There is no access to the
surrounding context or outer controller; all
contextual information must be passed in.
The easiest way to create a Component
is via
a template. If you name a template
app/components/my-foo.hbs
, you will be able to use
{{my-foo}}
in other templates, which will make
an instance of the isolated component.
You can use yield
inside a template to
include the contents of any block attached to
the component. The block will be executed in the
context of the surrounding context or outer controller:
If you want to customize the component, in order to
handle events or actions, you implement a subclass
of Component
named after the name of the
component.
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:
Components must have a -
in their name to avoid
conflicts with built-in controls that wrap HTML
elements. This is consistent with the same
requirement in web components.
HTML Tag
The default HTML tag name used for a component's DOM representation is div
.
This can be customized by setting the tagName
property.
The following component class:
paragraph.js | |
1 2 3 4 5 |
import Component from '@ember/component'; export default Component.extend({ tagName: 'em' }); |
Would result in instances with the following HTML:
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'] }); |
Will result in component instances with an HTML representation of:
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 |
import Component from '@ember/component'; import { computed } from '@ember/object'; export default Component.extend({ classNameBindings: ['propertyA', 'propertyB'], propertyA: 'from-a', propertyB: computed(function() { if (someLogic) { return 'from-b'; } }) }); |
Will result in component instances with an HTML representation of:
1 |
<div id="ember1" class="ember-view 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 }); |
Will result in component instances with an HTML representation of:
1 |
<div id="ember1" class="ember-view hovered"></div> |
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 }); |
Will result in component instances with an HTML representation of:
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 }); |
Will result in component instances with an HTML representation of:
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 }) }); |
Will result in component instances with an HTML representation of:
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 }); |
Will result in component instances with an HTML representation of:
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 }); |
Will result in component instances with an HTML representation of:
1 |
<div id="ember1" class="ember-view"></div> |
When the isEnabled
property on the component is set to false
, it will result
in component instances with an HTML representation of:
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.
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' }); |
Will result in component instances with an HTML representation of:
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' }); |
Will result in component instances with an HTML representation of:
1 |
<a id="ember1" class="ember-view" href="http://google.com"></a> |
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' }); |
Will result in component instances with an HTML representation of:
1 |
<use xlink:href="#triangle"></use> |
If the return value of an attributeBindings
monitored property 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 }); |
Will result in a component instance with an HTML representation of:
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
return value of the attributeBindings
monitored property:
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 rendered HTML representation.
attributeBindings
is a concatenated property. See EmberObject
documentation for more information about concatenated properties.
Layouts
See Ember.Templates.helpers.yield for more information.
Layout can be used to wrap content in a component. In addition to wrapping content in a Component's template, you can also use the public layout API in your Component JavaScript.
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 }); |
The above 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> |
Responding to Browser Events
Components can respond to user-initiated events in one of three ways: method
implementation, through an event manager, and through {{action}}
helper use
in their template or layout.
Method Implementation
Components can respond to user-initiated events by implementing a method that
matches the event name. A jQuery.Event
object will be passed as the
argument to this method.
widget.js | |
1 2 3 4 5 6 7 8 |
import Component from '@ember/component'; export default Component.extend({ click(event) { // will be called when an instance's // rendered element is clicked } }); |
{{action}}
Helper
See Ember.Templates.helpers.action.
Event Names
All of the event handling approaches described above respond to the same set
of events. The names of the built-in events are listed below. (The hash of
built-in events exists in Ember.EventDispatcher
.) Additional, custom events
can be registered by using Ember.Application.customEvents
.
Touch events:
touchStart
touchMove
touchEnd
touchCancel
Keyboard events:
keyDown
keyUp
keyPress
Mouse events:
mouseDown
mouseUp
contextMenu
click
doubleClick
mouseMove
focusIn
focusOut
mouseEnter
mouseLeave
Form events:
submit
change
focusIn
focusOut
input
HTML5 drag and drop events:
dragStart
drag
dragEnter
dragLeave
dragOver
dragEnd
drop
$ (selector) JQuery public
Defined in packages/ember-glimmer/lib/component.js:875
- 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.
didReceiveAttrs public
Defined in packages/ember-glimmer/lib/component.js:758
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.
didRender public
Defined in packages/ember-glimmer/lib/component.js:778
Available since v1.13.0
Called after a component has been rendered, both on initial render and in subsequent rerenders.
didUpdate public
Defined in packages/ember-glimmer/lib/component.js:842
Available since v1.13.0
Called when the component has updated and rerendered itself. Called only during a rerender, not during an initial render.
didUpdateAttrs public
Defined in packages/ember-glimmer/lib/component.js:810
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.
readDOMAttr (name) public
Defined in packages/ember-glimmer/lib/component.js:645
- 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.
rerender public
Inherited from Ember.ViewMixin packages/ember-views/lib/mixins/view_support.js:122
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.
send (actionName, context) public
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 | |
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) { // ... } } }); |
sendAction (action, params) public
Inherited from Ember.ActionSupport packages/ember-views/lib/mixins/action_support.js:27
- action
- String
- the action to call
- params
- *
- arguments for the action
Calls an action passed to a component.
For example a component for playing or pausing music may translate click events into action notifications of "play" or "stop" depending on some internal state of the component:
button.js | |
1 2 3 4 5 6 7 8 9 10 11 |
import Component from '@ember/component'; export default Component.extend({ click() { if (this.get('isPlaying')) { this.sendAction('play'); } else { this.sendAction('stop'); } } }); |
The actions "play" and "stop" must be passed to this play-button
component:
When the component receives a browser click
event it translate this
interaction into application-specific semantics ("play" or "stop") and
calls the specified action.
app/controller/application.js | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import Controller from '@ember/controller'; export default Controller.extend({ actions: { musicStarted() { // called when the play button is clicked // and the music started playing }, musicStopped() { // called when the play button is clicked // and the music stopped playing } } }); |
If no action is passed to sendAction
a default name of "action"
is assumed.
button.js | |
1 2 3 4 5 6 7 |
import Component from '@ember/component'; export default Component.extend({ click() { this.sendAction(); } }); |
app/controllers/application.js | |
1 2 3 4 5 6 7 8 9 |
import Controller from '@ember/controller'; export default Controller.extend({ actions: { playNextSongInAlbum() { ... } } }); |
willRender public
Defined in packages/ember-glimmer/lib/component.js:794
Available since v1.13.0
Called before a component has been rendered, both on initial render and in subsequent rerenders.
willUpdate public
Defined in packages/ember-glimmer/lib/component.js:826
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.