Beginners Guide to KnockoutJS: Part 3

Key Takeaways

• Utilize the `foreach` binding in KnockoutJS to automatically duplicate and bind sections of markup for each item in an array, such as dynamically generating table rows or list items based on array data.
• Leverage pseudovariables like `$data`, `$parent`, `$parents`, and `$root` within nested bindings to access and manipulate data from different levels of your view model hierarchy effectively.
• Implement the `if` and `with` bindings to conditionally render sections of your UI and establish new binding contexts, enhancing the dynamism and readability of your application.
• Explore KnockoutJS’s templating capabilities, which allow for both native templating using control-flow bindings and advanced scenarios using the `template` binding with options for passing additional parameters and callbacks.
• Extend Knockout observables and create custom bindings to encapsulate complex behaviors and interactions, providing reusable solutions that maintain clean and manageable codebases.

A Beginners Guide to KnockoutJS: Templating and More

There are four control-flow bindings: foreach, if, ifnot and with. These control bindings allow you to declaratively define the control-flow logic without creating a named template as you will see below.

The foreach binding duplicates a section of markup for each entry in an array, and binds each copy of that markup to the corresponding array item. This is suitable for rendering lists or tables. If your array is an observable array, whenever you later add or remove array entries, the binding will update the UI to match by inserting or removing more copies of the list items or table rows, without affecting any other DOM elements. See the following example:

<table>
 <thead>
  <tr><th>Title</th><th>Author</th></tr>
 </thead>
 <tbody data-bind="foreach: books">
  <tr>
   <td data-bind="text: title"></td>
   <td data-bind="text: author"></td>      
  </tr>
 </tbody>
</table>

<script type="text/javascript">
  function viewModel() {
   var self = this;
   self.books = ko.observableArray([
     { title: 'The Secret', author: 'Rhonda Byrne' },
     { title: 'The Power', author: 'Rhonda Byrne' },
     { title: 'The Magic', author: 'Rhonda Byrne' }
   ]);
  }
  ko.applyBindings(new viewModel());    
</script>

Here, a table row will be created automatically for each array entry in the books array.

Sometimes you may need to refer to the array entry itself rather than just one of its properties. In that case, you can use the pseudovariable $data. It means “the current item”, when is used within a foreach block.

<ul data-bind="foreach: daysOfWeek">
 <li>
 <span data-bind="text: $data"></span>
 </li>
</ul>

<script type="text/javascript">
function viewModel() {
  var self = this;
  self.daysOfWeek = ko.observableArray([
   'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'
  ]);
};

ko.applyBindings(new viewModel());
</script>

This will list all days of the week without need to repeat the code for each item separately.

In Knockout you can nest as many control-flow bindings as you wish. And when you do that, it’s often desirable to reach back up the hierarchy and access data or functions from parent contexts. In such cases you can use the following pseudovariables:

$parent – represents the data item outside the current foreach block

$parents – is an array representing data items from all outer control-flow scopes. $parents[0] is the same as $parent. $parents[1] represents the item from the grandparent control-flow scope, and so on.

$root – represents the item from the outer-most control-flow scope. Typically this is your top-level view model object.

In the following example we use the $parent pseudovariable in order to remove properly a book item from the books array:

<table>
 <thead>
  <tr><th>Title</th><th>Author</th></tr>
 </thead>
 <tbody data-bind="foreach: books">
  <tr>
   <td data-bind="text: title"></td>
   <td data-bind="text: author"></td>      
  </tr>
 </tbody>
</table>

<script type="text/javascript">
  function viewModel() {
   var self = this;
   self.books = ko.observableArray([
     { title: 'The Secret', author: 'Rhonda Byrne' },
     { title: 'The Power', author: 'Rhonda Byrne' },
     { title: 'The Magic', author: 'Rhonda Byrne' }
   ]);
  }
  ko.applyBindings(new viewModel());    
</script>

In some cases, you might want to duplicate a section of markup, but you don’t have any container element on which to put a foreach binding. Then you can use the following syntax:

<ul data-bind="foreach: daysOfWeek">
 <li>
 <span data-bind="text: $data"></span>
 </li>
</ul>

<script type="text/javascript">
function viewModel() {
  var self = this;
  self.daysOfWeek = ko.observableArray([
   'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'
  ]);
};

ko.applyBindings(new viewModel());
</script>

In this example, you can’t use a normal foreach binding. If you put it on the

this will duplicate the header item, and if you want to put a further container inside the
you can’t because only
• elements are allowed inside
  s. The solution is to use the containerless control-flow syntax where the and comments define a “virtual element” that contains the markup inside, which syntax Knockout understands and binds this virtual element as if you had a real container element. This type of syntax is also valid for if and with bindings.

  The if binding causes a section of markup to appear in your document, only if a specified expression evaluates to true. Then the contained markup will be present in the document, and any data-bind attributes on it will be applied. On the other hand, if your expression evaluates to false, the contained markup will be removed from your document without first applying any bindings to it.

  <table>
   <thead>
    <tr><th>Title</th><th>Author</th></tr>
   </thead>
   <tbody data-bind="foreach: books">
    <tr>
     <td data-bind="text: title"></td>
     <td data-bind="text: author"></td>
     <td><a href="#" data-bind="click: $parent.removeBook">Remove</a></td>
    </tr>
   </tbody>
  </table>
  
  <script type="text/javascript">
    function viewModel() {
     var self = this;
     self.books = ko.observableArray([
       { title: 'The Secret', author: 'Rhonda Byrne' },
       { title: 'The Power', author: 'Rhonda Byrne' },
       { title: 'The Magic', author: 'Rhonda Byrne' }
     ]);
  
    self.removeBook = function() {
     self.books.remove(this);
    }
    }
    ko.applyBindings(new viewModel());    
  </script>

  The with binding creates a new binding context, so that descendant elements are bound in the context of a specified object. The object that you want to use as the context for binding descendant elements. If the expression you supply evaluates to null or undefined, descendant elements will not be bound at all, but will instead be removed from the document. The with binding changes the data context to whatever object you specify. This is especially useful when dealing with object graphs with multiple parent/child relationships.

  <ul>
  <li><strong>Days of week:</strong></li>
   <!-- ko foreach: daysOfWeek -->
   <li>
    <span data-bind="text: $data"></span>
   </li>
   <!-- /ko -->
  </ul>
  
  <script type="text/javascript">
  function viewModel() {
    var self = this;
    self.daysOfWeek = ko.observableArray([
     'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'
    ]);
  };
  
  ko.applyBindings(new viewModel());
  </script>

  Templating

  The template binding populates the associated DOM element with the results of rendering a template. Templates are a simple and convenient way to build sophisticated UI structures – possibly with repeating or nested blocks – as a function of your view model data. There are two main ways of using templates. The first one, native templating, is the mechanism that underpins foreach, if, with, and other control-flow bindings. Internally, those control-flow bindings capture the HTML markup contained in your element, and use it as a template to render against an arbitrary data item. This feature is built into Knockout and doesn’t require any external library. You can see the basic scheme for creating a template here:

  <label><input type="checkbox" data-bind="checked: showList" />Show me list</label>
  <ul data-bind="if: showList">
    <li>Item</li>
    <li>Item</li>
    <li>Item</li>
  </ul>
  
  <script type="text/javascript">
     function viewModel() {
      var self = this;
      self.showList = ko.observable(false);
     }
    ko.applyBindings(new viewModel());    
  </script>

  In the following example you can see how to use it in action:

  <table>
   <thead>
    <tr><th>Title</th><th>Author</th></tr>
   </thead>
   <tbody data-bind="foreach: books">
    <tr>
     <td data-bind="text: title"></td>
     <td data-bind="text: author"></td>      
    </tr>
   </tbody>
  </table>
  
  <script type="text/javascript">
    function viewModel() {
     var self = this;
     self.books = ko.observableArray([
       { title: 'The Secret', author: 'Rhonda Byrne' },
       { title: 'The Power', author: 'Rhonda Byrne' },
       { title: 'The Magic', author: 'Rhonda Byrne' }
     ]);
    }
    ko.applyBindings(new viewModel());    
  </script>

  Here, we must use an id equals to the template name in order to bound the template to the rest of our markup. In this case it is ‘book-template’.

  Instead of using the short syntax described above, we can pass more parameters to the template binding, which will gives us more precise control over the final output.

  <ul data-bind="foreach: daysOfWeek">
   <li>
   <span data-bind="text: $data"></span>
   </li>
  </ul>
  
  <script type="text/javascript">
  function viewModel() {
    var self = this;
    self.daysOfWeek = ko.observableArray([
     'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'
    ]);
  };
  
  ko.applyBindings(new viewModel());
  </script>

  Here, the name is the id of the element that contains the template you wish to render; the data is an object to supply as the data for the template to render; and the afterRender is a callback function to be invoked against the rendered DOM elements.

  The following example is an equivalent of a foreach binding. Here, foreach is passed as a parameter to the template binding.

  <table>
   <thead>
    <tr><th>Title</th><th>Author</th></tr>
   </thead>
   <tbody data-bind="foreach: books">
    <tr>
     <td data-bind="text: title"></td>
     <td data-bind="text: author"></td>
     <td><a href="#" data-bind="click: $parent.removeBook">Remove</a></td>
    </tr>
   </tbody>
  </table>
  
  <script type="text/javascript">
    function viewModel() {
     var self = this;
     self.books = ko.observableArray([
       { title: 'The Secret', author: 'Rhonda Byrne' },
       { title: 'The Power', author: 'Rhonda Byrne' },
       { title: 'The Magic', author: 'Rhonda Byrne' }
     ]);
  
    self.removeBook = function() {
     self.books.remove(this);
    }
    }
    ko.applyBindings(new viewModel());    
  </script>

  You can get exactly the same result by embedding an anonymous template directly inside the element to which you use foreach binding:

  <ul>
  <li><strong>Days of week:</strong></li>
   <!-- ko foreach: daysOfWeek -->
   <li>
    <span data-bind="text: $data"></span>
   </li>
   <!-- /ko -->
  </ul>
  
  <script type="text/javascript">
  function viewModel() {
    var self = this;
    self.daysOfWeek = ko.observableArray([
     'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'
    ]);
  };
  
  ko.applyBindings(new viewModel());
  </script>

  The second way of using templates is to connect Knockout to a third-party template engine. Knockout will pass your model values to the external template engine and inject the resulting markup string into your document. For examples that use the jquery.tmpl and Underscore template engines check the documentation.

  Extending Observables

  Knockout observables provide the basic features necessary to support reading/writing values and notifying subscribers when that value changes. In some cases, though, you may wish to add additional functionality to an observable like adding additional properties to the observable. Knockout extenders provide an easy and flexible way to do just that.

  Creating an extender involves adding a function to the ko.extenders object. The function takes in the observable itself as the first argument and any options in the second argument. It can then either return the observable or return something new like a computed observable that uses the original observable in some way.

  Now we’ll create an observable extender which will add the ability to show a hint message.

  <label><input type="checkbox" data-bind="checked: showList" />Show me list</label>
  <ul data-bind="if: showList">
    <li>Item</li>
    <li>Item</li>
    <li>Item</li>
  </ul>
  
  <script type="text/javascript">
     function viewModel() {
      var self = this;
      self.showList = ko.observable(false);
     }
    ko.applyBindings(new viewModel());    
  </script>

  Custom Bindings

  Knockout’s built-in bindings allow you to handle most binding scenarios, but if you encounter a specialized binding scenario that isn’t covered, you can create custom bindings with Knockout which gives you a lot of flexibility to encapsulate sophisticated behaviors in an easy-to-reuse way. For example, you can create interactive components like grids, tabsets, and so on, in the form of custom bindings.

  Knockout bindings consist of two methods: init and update. Creating a binding is as simple as creating an object with these two methods and registering that object with Knockout using ko.bindingHandlers as shown below.

  <table>
   <thead>
    <tr><th>Title</th><th>Author</th></tr>
   </thead>
   <tbody data-bind="foreach: books">
    <tr>
     <td data-bind="text: title"></td>
     <td data-bind="text: author"></td>      
    </tr>
   </tbody>
  </table>
  
  <script type="text/javascript">
    function viewModel() {
     var self = this;
     self.books = ko.observableArray([
       { title: 'The Secret', author: 'Rhonda Byrne' },
       { title: 'The Power', author: 'Rhonda Byrne' },
       { title: 'The Magic', author: 'Rhonda Byrne' }
     ]);
    }
    ko.applyBindings(new viewModel());    
  </script>

  The init function will only run the first time that the binding is evaluated for this element. This is usually used to run one-time initialization code or to wire up event handlers that let you update your view model based on an event being triggered in your UI.

  The update function provides a way to respond when associated observables are modified. Typically, this is used to update your UI based on changes to your view model.

  The init and update functions are supplied four parameters. Generally, you will want to focus on the element and the valueAccessor parameters, as they are the standard way to link your view model to your UI. You don’t actually have to provide both init and update callbacks – you can just provide one or the other if that’s all you need.

  The element parameter gives you direct access to the DOM element that contains the binding.

  The valueAccessor parameter is a function that gives you access to what was passed to the binding. If you passed an observable, then the result of this function will be that observable (not the value of it). If you used an expression in the binding, then the result of the valueAccessor will be the result of the expression.

  The allBindingsAccessor parameter gives you access to all of the other bindings that were listed in the same data-bind attribute. This is generally used to access other bindings that interact with this binding. These bindings likely will not have any code associated with them and are just a way to pass additional options to the binding, unless you choose to pass an object with multiple properties into your main binding. For example, optionsValue, optionsText, and optionsCaption are bindings that are only used to pass options to the options binding.

  The viewModel parameter will provides access to your overall view model for bindings outside of templates. Inside of a template, this will be set to the data being bound to the template. For example, when using the foreach option of the template binding, the viewModel parameter would be set to the current array member being sent through the template. Most of the time the valueAccessor will give you the data that you want, but the viewModel parameter is particularly useful if you need an object to be your target when you call/apply functions.

  In the following example we will create a custom binding which scale a textarea when it is in focus.

  <ul data-bind="foreach: daysOfWeek">
   <li>
   <span data-bind="text: $data"></span>
   </li>
  </ul>
  
  <script type="text/javascript">
  function viewModel() {
    var self = this;
    self.daysOfWeek = ko.observableArray([
     'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'
    ]);
  };
  
  ko.applyBindings(new viewModel());
  </script>

  First, in the init function we declare that when element is in focus then its value will be set to true, and vice versa. Then in the update function we use allBindingAccessor parameter to add additional options to our binding – scaleUp and scaleDown. We use the ko.utils.unwrapObservable to get the current binding’s value and check if it is set to true. If so, the DOM element is scaled up, otherwise it is scaled down.

  At last let’s see an example that combines the hints observable extender and scaleOnFocus custom binding:

  <table>
   <thead>
    <tr><th>Title</th><th>Author</th></tr>
   </thead>
   <tbody data-bind="foreach: books">
    <tr>
     <td data-bind="text: title"></td>
     <td data-bind="text: author"></td>      
    </tr>
   </tbody>
  </table>
  
  <script type="text/javascript">
    function viewModel() {
     var self = this;
     self.books = ko.observableArray([
       { title: 'The Secret', author: 'Rhonda Byrne' },
       { title: 'The Power', author: 'Rhonda Byrne' },
       { title: 'The Magic', author: 'Rhonda Byrne' }
     ]);
    }
    ko.applyBindings(new viewModel());    
  </script>

  You can place the hints observable and scaleOnFocus binding in a separate file and then including them in the main file. This makes the code modular and allows you to re-use it whenever you want.

  That’s it, folks! I hope you enjoyed this series. Now you have all necessary knowledge to start and continue learning and experimenting with Knockout. For more comprehensive examples and tutorials you can go to the Knockout site, which I suggest you to do.

  Frequently Asked Questions about KnockoutJS

  What is the purpose of ko.utils.unwrapObservable in KnockoutJS?

  The ko.utils.unwrapObservable function in KnockoutJS is used to retrieve the current value of an observable or a non-observable. This function is particularly useful when you’re not sure if you’re dealing with an observable or a non-observable. It allows you to handle both cases without having to write separate code for each. This function is a part of KnockoutJS’s utility functions that provide additional functionality to make working with observables easier.

  How does the foreach binding work in KnockoutJS?

  The foreach binding in KnockoutJS is used to bind an array of items to a section of your HTML. It replicates the associated DOM element and its descendants for each item in the array, creating a loop. This is particularly useful when you want to display a list of items in your UI. The foreach binding also provides a context for each iteration, allowing you to access the current item using the $data keyword.

  What is the mapping plugin in KnockoutJS?

  The mapping plugin in KnockoutJS is a utility that helps you to convert your JSON objects into observable objects. This is particularly useful when you’re working with data from a server. The mapping plugin allows you to easily map your data to your view model, and it also provides options to customize the mapping process.

  How can I work with collections in KnockoutJS?

  Working with collections in KnockoutJS is made easy with the help of observable arrays. Observable arrays are special types of observables that hold an array of values. They provide functions to manipulate the array such as push, pop, shift, unshift, reverse, sort, and splice. Observable arrays also notify subscribers when items are added or removed, making it easy to keep your UI in sync with your data.

  I found an issue in KnockoutJS, where can I report it?

  If you’ve found an issue in KnockoutJS, you can report it on the KnockoutJS GitHub page. Before reporting an issue, it’s a good idea to check if the issue has already been reported by someone else. If it hasn’t, you can create a new issue and provide as much detail as possible to help the KnockoutJS team understand and resolve the issue.

  How can I use computed observables in KnockoutJS?

  Computed observables in KnockoutJS are functions that are dependent on one or more other observables, and will automatically update whenever any of these dependencies change. Computed observables are useful when you want to combine or manipulate observables in some way. To create a computed observable, you can use the ko.computed function.

  How can I handle events in KnockoutJS?

  KnockoutJS provides a number of bindings to handle events such as click, submit, focus, among others. These bindings allow you to specify a JavaScript function to be executed when the associated event occurs. The function can be a part of your view model or a standalone function.

  How can I use custom bindings in KnockoutJS?

  Custom bindings in KnockoutJS allow you to create your own bindings that can be used just like the built-in bindings. This is particularly useful when you want to create reusable pieces of functionality. To create a custom binding, you can use the ko.bindingHandlers object.

  How can I debug KnockoutJS applications?

  Debugging KnockoutJS applications can be done using the browser’s developer tools. You can use console.log to print out values, or use breakpoints to pause execution and inspect the current state of your application. KnockoutJS also provides the ko.toJSON function, which can be used to convert your view model into a JSON string for easy inspection.

  How can I test KnockoutJS applications?

  Testing KnockoutJS applications can be done using JavaScript testing frameworks such as Jasmine or Mocha. These frameworks allow you to write unit tests for your view models, ensuring that they behave as expected. When testing KnockoutJS applications, it’s a good idea to separate your view models from the DOM as much as possible, to make testing easier.

The above is the detailed content of Beginners Guide to KnockoutJS: Part 3. For more information, please follow other related articles on the PHP Chinese website!