var viewModel = {        serverTime: ko.observable(),        numUsers: ko.observable()    };

The time on the server is: <span data-bind="text: serverTime"></span>and <span data-bind="text: numUsers"></span> user(s) are connected.

    ///获取服务器端数据    function GetData() {        $.getJSON("../Home/GetServerData?Token="+new Date(), {}, function (data) {            viewModel.serverTime(data.Date);            viewModel.numUsers(data.Count);        });        setInterval("GetData", 1000);    }    GetData();

        public JsonResult GetServerData()        {            ServerData sd=new ServerData();            sd.Date = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");            sd.Count = 3;            return this.Json(sd, JsonRequestBehavior.AllowGet);        }

    public class ServerData    {        public string Date { get; set; }        public int Count { get; set; }    }

            viewModel.serverTime(data.Date);            viewModel.numUsers(data.Count);

var viewModel = ko.mapping.fromJS(data);

            ko.mapping.fromJS(data,{}, viewModel);

var unmapped = ko.mapping.toJS(viewModel);

前言

有时候，在使用ko.mapping.fromJS的时候，可能有必要去使用mapping的高级用法来定义mapping的详细过程，以后定义了，以后再调用的时候就不必再定义了。这里有一些情形，你可能需要使用这些option。

使用keys来使对象unique化

你有一个JavaScript对象，如下：

var data = http://www.mamicode.com/{ name: ‘Scot‘, children: [{ id: 1, name: ‘Alicw‘ }] };

并且他已经绑定到viewModel

    var viewModel = {        name: ko.observable("Scot"),        children: ko.observableArray([{ id: 1, name: ‘Alicw‘ }])    };

使用map插件，你可以将它map到view model上（没任何问题）：

    var data = http://www.mamicode.com/{ name: ‘Scott‘, children: [{ id: 1, name: ‘Alicws‘ }] };    ko.mapping.fromJS(data,{},viewModel);

这里发生了两件事：name从Scot变成了Scott，children[0].name从Alicw变成了Alicws。通过调试你可以发现viewModel中的属性已经发生相应的变化更新。

于是，name像我们期望的一样更新了，但是在children数组里，子项Alicw被删除而新项Alicws被添加到数组里。这不是我们所期望 的，我们期望的是只是把name从Alicw更新成Alicws，不是替换整个item项。发生的原因是，默认情况下mapping plugin插件只是简单地比较数组里的两个对象是否相等。 因为JavaScript里{ id : 1, name : ‘Alicw‘ }和{ id : 1, name : ‘Alicws‘ }是不相等的，所以它认为喜欢将新项替换掉老项。

解决这个问题，你需要声明一个key让mapping插件使用，用来判断一个对象是新对象还是旧对象。代码如下：

    var mapping = {         ‘children‘: {              key: function(data) {                   return ko.utils.unwrapObservable(data.id);              }         }    };

ko.mapping.fromJS(data, mapping, viewModel);

这样，每次map的时候，mapping插件都会检查数组项的id属性来判断这个数组项是需要合并的还是全新replace的。

用create自定义对象的构造器

如果你想自己控制mapping，你也可以使用create回调。使用回调可以让你自己控制mapping。

举例，你有一个像这样的JavaScript对象：

var data = http://www.mamicode.com/{ name: ‘Graham‘, children: [{ id: 1, name: ‘Lisa‘ }] };

如果你想自己map children 数组，你可以这样声明：

    var MyChildModel = function (data) {        ko.mapping.fromJS(data, {}, this);    };    var mapping = { ‘children‘: { create: function (options) { return new MyChildModel(options.data); } } };

ko.mapping.fromJS(data, mapping, viewModel);

支持create回调的options参数是一个JavaScript对象，包含如下：

　　data： JavaScript对象，包含child用到的数据

　　parent：child对象所属的父对象或者数组

如果你想让初始的JavaScript对象带有额外的依赖属性dependent observables：

    var MyChildModel = function (data) {        ko.mapping.fromJS(data, {}, this);        this.nameLength = ko.dependentObservable(function () { return this.name().length; }, this);    };

用update自定义对象的updating

你也可以使用update 回调来自定义一个对象如何更新。它接受一个需要替代的对象以及和create 回调一样的options参数，你应该return更新后的值。

update 回调使用的options参数是一个JavaScript对象，包含如下内容：

　　data：JavaScript对象，包含child用到的数据
　　parent：child对象所属的父对象或者数组
　　observable：如果属性是observable的，这将会写入到实际的observable里

例子，在数据显示之前，在新数据后面附加额外的字符串：

    var data = http://www.mamicode.com/{ name: ‘Graham‘ };    var mapping = { ‘name‘: { update: function(options) { return options.data + ‘foo!‘; } } };    var viewModel = ko.mapping.fromJS(data, mapping);    alert(viewModel.name());

那么alert的结果为

Knockout.Js官网学习（Mapping高级用法二）

使用ignore忽略不需要map的属性

如果在map的时候，你想忽略一些属性，你可以使用ignore累声明需要忽略的属性名称集合：

    var data = http://www.mamicode.com/{"name":"aehyok","age":"25" };    var mapping = { ‘ignore‘: ["age"] };    var viewModel = ko.mapping.fromJS(data, mapping);

这样执行后age不会在viewModel中

你声明的忽略数组被编译到默认的ignore数组里。你可以像下面代码一样来维护它：

    var oldOptions = ko.mapping.defaultOptions().ignore;    ko.mapping.defaultOptions().ignore = ["alwaysIgnoreThis"];

使用include声明需要map的属性

默认情况下，当map你的view model回到JS对象是时候，只map原始view model里拥有的属性（除了例外的_destroy属性），不过，你可以使用include参数来定制：

var mapping = {    ‘include‘: ["propertyToInclude", "alsoIncludeThis"]};

var viewModel = ko.mapping.fromJS(data, mapping);

你声明的include数组被编译到默认的include数组里，默认只有_destroy。 你可以像这样来维护：

var oldOptions = ko.mapping.defaultOptions().include;

ko.mapping.defaultOptions().include = ["alwaysIncludeThis"];

使用copy来复制属性

默认情况下，map的时候是把所有的值都转换成observable的，如果你只是想copy属性值而不是替换成observable的，你可以将属性名称添加到copy数组：

var mapping = {    ‘copy‘: ["propertyToCopy"]};

var viewModel = ko.mapping.fromJS(data, mapping);

你声明的copy数组被编译到默认的copy数组里，默认值是空。你可以像这样来维护

var oldOptions = ko.mapping.defaultOptions().copy;
ko.mapping.defaultOptions().copy = ["alwaysCopyThis"];

Specifying the update target

在上面的例子，如果你想再一个class内map，你可以使用第三个参数作为操作的目标，例如：

ko.mapping.fromJS(data, {}, someObject); 

所以，如果你想map一个JavaScript对象到this上，你可以这样声明：

ko.mapping.fromJS(data, {}, this);

从数据源map

你可以通过多次使用ko.mapping.fromJS 来将多个JS对象的数据源map到一起，例如：

var viewModel = ko.mapping.fromJS(alice, aliceMappingOptions);

ko.mapping.fromJS(bob, bobMappingOptions, viewModel);

Map以后的observable数组

map插件map以后生产的observable数组，带有几个额外的函数来处理带有keys的mapping：

mappedRemovemappedRemoveAllmappedDestroymappedDestroyAllmappedIndexOf

它们是和ko.observableArray里的函数等价的，不同是他们通过key来处理对象。例如：

    var obj = [{ id: 1 }, { id: 2 }];    var result = ko.mapping.fromJS(obj, { key: function (item) { return ko.utils.unwrapObservable(item.id); } });    result.mappedRemove({ id: 2 });

map过的observable数组，除了上面的函数还支持一个mappedCreate函数：

 var newItem = result.mappedCreate({ id: 3 });

首先会检查key（id=3）在数组里是否存在（如果存在则抛出异常），然后，如果有create和 update回调的话会调用他们，最后创建一个新对象，并将新对象添加到数组然后返回该新对象。