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 instance created using Binding helpers (see "One Way Bindings"):

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:

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:

binding = Ember.Binding.from("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:

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.

This also allows you to bind between objects using the paths you declare in from and to:

// Example 1
binding = Ember.Binding.from("App.someObject.value").to("value");
binding.connect(this);

// Example 2
binding = Ember.Binding.from("parentView.value").to("App.someObject.value");
binding.connect(this);

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):

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:

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.