Creating Computed Observables

Creating computed observables is a relatively straightforward process, however there are some things a developers should be aware of when using them.

A basic computed observable:

function AppViewModel() {
  this.firstName = fw.observable('Bob');
  this.lastName = fw.observable('Smith');

  // Create a computed fullName value based on firstName and lastName
  this.fullName = fw.computed(function() {
    return this.firstName() + " " + this.lastName();
  }, this);

Here we see a fullName property being computed from the firstName and lastName. Notice we are passing in the context of the evaluator as the second parameter so that when we reference this inside of it we are accessing the view model (and its attached observables fullName and lastName).


Depending on your needs you may want to try the alternative pure computed variant, which has lower resource usage and may be a better fit for your particular use-case.

Managing 'this'

The second parameter to fw.computed (the bit where we passed this in the above example) defines the value of this when evaluating the computed observable. Without passing it in, it would not have been possible to refer to this.firstName() or this.lastName(). Experienced JavaScript coders will regard this as obvious, but if you're still getting to know JavaScript it might seem strange. (Languages like C# and Java never expect the programmer to set a value for this, but JavaScript does, because its functions themselves aren't part of any object by default.)

A popular convention that simplifies things

There's a popular convention that avoids the need to track this altogether: if your viewmodel's constructor copies a reference to this into a different variable (traditionally called self), you can then use self throughout your viewmodel and don't have to worry about it being redefined to refer to something else. For example:

function AppViewModel() {
  var self = this;

  self.firstName = fw.observable('Bob');
  self.lastName = fw.observable('Smith');
  self.fullName = fw.computed(function() {
    return self.firstName() + " " + self.lastName();

Because self is captured in the function's closure, it remains available and consistent in any nested functions, such as the computed observable's evaluator. This convention is even more useful when it comes to event handlers.

Change Notifications

Forcing computed observables to always notify subscribers

When a computed observable returns a primitive value (a number, string, boolean, or null), the dependencies of the observable are normally only notified if the value actually changed. However, it is possible to use the built-in notify extender to ensure that a computed observable's subscribers are always notified on an update, even if the value is the same. You would apply the extender like this:

myViewModel.fullName = fw.pureComputed(function() {
  return myViewModel.firstName() + " " + myViewModel.lastName();
}).extend({ notify: 'always' });

Delaying and/or suppressing change notifications

Normally, a computed observable updates and notifies its subscribers immediately, as soon as its dependencies change. But if a computed observable has many dependencies or involves expensive updates, you may get better performance by limiting or delaying the computed observable's updates and notifications. This is accomplished using the rateLimit extender like this:

// Ensure updates no more than once per 50-millisecond period
myViewModel.fullName.extend({ rateLimit: 50 });

Utility Methods


Returns true when the passed in value is a computed observable.



Returns true for observables, observable arrays, and all computed observables.



Returns true for observables, observable arrays, and writable computed observables (also aliased as fw.isWriteableObservable).