Getting started

  1. How KO works and what benefits it brings
  2. Downloading and installing

Observables

  1. Creating view models with observables
  2. Working with observable arrays

Computed observables

  1. Using computed observables
  2. Writable computed observables
  3. How dependency tracking works
  4. Pure computed observables
  5. Reference

Bindings

Controlling text and appearance

  1. The visible binding
  2. The text binding
  3. The html binding
  4. The css binding
  5. The style binding
  6. The attr binding

Control flow

  1. The foreach binding
  2. The if binding
  3. The ifnot binding
  4. The with binding
  5. The component binding

Working with form fields

  1. The click binding
  2. The event binding
  3. The submit binding
  4. The enable binding
  5. The disable binding
  6. The value binding
  7. The textInput binding
  8. The hasFocus binding
  9. The checked binding
  10. The options binding
  11. The selectedOptions binding
  12. The uniqueName binding

Rendering templates

  1. The template binding

Binding syntax

  1. The data-bind syntax
  2. The binding context

Creating custom bindings

  1. Creating custom bindings
  2. Controlling descendant bindings
  3. Supporting virtual elements
  4. Custom disposal logic
  5. Preprocessing: Extending the binding syntax

Components

  1. Overview: What components and custom elements offer
  2. Defining and registering components
  3. The component binding
  4. Using custom elements
  5. Advanced: Custom component loaders

Further techniques

  1. Loading and saving JSON data
  2. Extending observables
  3. Deferred updates
  4. Rate-limiting observables
  5. Unobtrusive event handling
  6. Using fn to add custom functions
  7. Microtasks
  8. Asynchronous error handling

Plugins

  1. The mapping plugin

More information

  1. Browser support
  2. Getting help
  3. Links to tutorials & examples
  4. Usage with AMD using RequireJs (Asynchronous Module Definition)

The "uniqueName" binding

Purpose

The uniqueName binding ensures that the associated DOM element has a nonempty name attribute. If the DOM element did not have a name attribute, this binding gives it one and sets it to some unique string value.

You won鈥檛 need to use this often. It鈥檚 only useful in a few rare cases, e.g.:

  • Other technologies may depend on the assumption that certain elements have names, even though names might be irrelevant when you鈥檙e using KO. For example, jQuery Validation currently will only validate elements that have names. To use this with a Knockout UI, it鈥檚 sometimes necessary to apply the uniqueName binding to avoid confusing jQuery Validation. See an example of using jQuery Validation with KO.

  • IE 6 does not allow radio buttons to be checked if they don鈥檛 have a name attribute. Most of the time this is irrelevant because your radio button elements will have name attributes to put them into mutually-exclusive groups. However, just in case you didn鈥檛 add a name attribute because it鈥檚 unnecessary in your case, KO will internally use uniqueName on those elements to ensure they can be checked.

Example

<input data-bind="value: someModelProperty, uniqueName: true" />

Parameters

  • Main parameter

    Pass true (or some value that evaluates as true) to enable the uniqueName binding, as in the preceding example.

  • Additional parameters

    • None

Dependencies

None, other than the core Knockout library.

(c) knockoutjs.com