Class Ember.Binding
An Ember.Binding
connects the properties of two objects so that whenever
the value of one property changes, the other property will be changed also.
Automatic Creation of Bindings with /^*Binding/
-named Properties
You do not usually create Binding objects directly but instead describe bindings in your class or object definition using automatic binding detection.
Properties ending in a Binding
suffix will be converted to Ember.Binding
instances. The value of this property should be a string representing a path
to another object or a custom binding instanced created using Binding helpers
(see "One Way Bindings"):
1 |
valueBinding: "MyApp.someController.title" |
This will create a binding from MyApp.someController.title
to the value
property of your object instance automatically. Now the two values will be
kept in sync.
One Way Bindings
One especially useful binding customization you can use is the oneWay()
helper. This helper tells Ember that you are only interested in
receiving changes on the object you are binding from. For example, if you
are binding to a preference and you want to be notified if the preference
has changed, but your object will not be changing the preference itself, you
could do:
1 |
bigTitlesBinding: Ember.Binding.oneWay("MyApp.preferencesController.bigTitles") |
This way if the value of MyApp.preferencesController.bigTitles
changes the
bigTitles
property of your object will change also. However, if you
change the value of your bigTitles
property, it will not update the
preferencesController
.
One way bindings are almost twice as fast to setup and twice as fast to execute because the binding only has to worry about changes to one side.
You should consider using one way bindings anytime you have an object that may be created frequently and you do not intend to change a property; only to monitor it for changes (such as in the example above).
Adding Bindings Manually
All of the examples above show you how to configure a custom binding, but the result of these customizations will be a binding template, not a fully active Binding instance. The binding will actually become active only when you instantiate the object the binding belongs to. It is useful however, to understand what actually happens when the binding is activated.
For a binding to function it must have at least a from
property and a to
property. The from
property path points to the object/key that you want to
bind from while the to
path points to the object/key you want to bind to.
When you define a custom binding, you are usually describing the property
you want to bind from (such as MyApp.someController.value
in the examples
above). When your object is created, it will automatically assign the value
you want to bind to
based on the name of your binding key. In the
examples above, during init, Ember objects will effectively call
something like this on your binding:
1 |
binding = Ember.Binding.from(this.valueBinding).to("value"); |
This creates a new binding instance based on the template you provide, and
sets the to path to the value
property of the new object. Now that the
binding is fully configured with a from
and a to
, it simply needs to be
connected to become active. This is done through the connect()
method:
1 |
binding.connect(this); |
Note that when you connect a binding you pass the object you want it to be connected to. This object will be used as the root for both the from and to side of the binding when inspecting relative paths. This allows the binding to be automatically inherited by subclassed objects as well.
Now that the binding is connected, it will observe both the from and to side and relay changes.
If you ever needed to do so (you almost never will, but it is useful to
understand this anyway), you could manually create an active binding by
using the Ember.bind()
helper method. (This is the same method used by
to setup your bindings on objects):
1 |
Ember.bind(MyApp.anotherObject, "value", "MyApp.someController.value"); |
Both of these code fragments have the same effect as doing the most friendly form of binding creation like so:
1 2 3 4 5 |
MyApp.anotherObject = Ember.Object.create({ valueBinding: "MyApp.someController.value", // OTHER CODE FOR THIS OBJECT... }); |
Ember's built in binding creation method makes it easy to automatically create bindings for you. You should always use the highest-level APIs available, even if you understand how it works underneath.