ExtJS笔记 Store

The Store class encapsulates a client side cache of Model objects. Stores load data via a Proxy, and also provide functions for sorting, filtering and querying the model instances contained within it.

Store类封装了Model对象在客户端的缓存。store通过proxy加载数据，并且提供排序、过滤、查询model实例的函数。

Creating a Store is easy - we just tell it the Model and the Proxy to use for loading and saving its data:

创建store很简单--我们只需告诉它model和proxy：

// Set up a model to use in our Store
 Ext.define('User', {
     extend: 'Ext.data.Model',
     fields: [
         {name: 'firstName', type: 'string'},
         {name: 'lastName',  type: 'string'},
         {name: 'age',       type: 'int'},
         {name: 'eyeColor',  type: 'string'}
     ]
 });

 var myStore = Ext.create('Ext.data.Store', {
     model: 'User',
     proxy: {
         type: 'ajax',
         url: '/users.json',
         reader: {
             type: 'json',
             root: 'users'
         }
     },
     autoLoad: true
 });

In the example above we configured an AJAX proxy to load data from the url '/users.json'. We told our Proxy to use aJsonReader to parse the response from the server into Model object - see the docs on JsonReader for details.

在上面的例子中，我们配置了一个ajax代理来从'/users.json'加载数据。我们告诉代理使用JsonReader解析服务端的响应到model对象。详情参见see the docs on JsonReader

Inline data  内联数据

Stores can also load data inline. Internally, Store converts each of the objects we pass in as data into Model instances:

store可通过内联方式加载数据。在内部，store转换每个我们传入的的对象为model实例：

 Ext.create('Ext.data.Store', {
     model: 'User',
     data : [
         {firstName: 'Ed',    lastName: 'Spencer'},
         {firstName: 'Tommy', lastName: 'Maintz'},
         {firstName: 'Aaron', lastName: 'Conran'},
         {firstName: 'Jamie', lastName: 'Avins'}
     ]
 });

Loading inline data using the method above is great if the data is in the correct format already (e.g. it doesn't need to be processed by a reader). If your inline data requires processing to decode the data structure, use a MemoryProxy instead (see the MemoryProxy docs for an example).

如果数据格式是正确的（不需要我们提供reader来处理），那么使用内联数据是很好的。如果内联数据需要解析数据格式，那么要使用MemoryProxy 。

Additional data can also be loaded locally using add.

额外的数据可以通过add方法来加载。

Dynamic Loading   动态加载

Stores can be dynamically updated by calling the load method:

store可以通过调用load方法来动态更新：

store.load({
    params: {
        group: 3,
        type: 'user'
    },
    callback: function(records, operation, success) {
        // do something after the load finishes
    },
    scope: this
});

Here a bunch of arbitrary parameters is passed along with the load request and a callback function is set up to do something after the loading is over.

这个例子中，一组任意的参数通过load方法传入，回调函数在使得load结束时候可以做些事情。

Loading Nested Data    加载嵌套数据

Applications often need to load sets of associated data - for example a CRM system might load a User and her Orders. Instead of issuing an AJAX request for the User and a series of additional AJAX requests for each Order, we can load a nested dataset and allow the Reader to automatically populate the associated models. Below is a brief example, see the Ext.data.reader.Reader intro docs for a full explanation:

app经常需要加载一组相关的数据--例如，crm系统会加载users和它的orders。一种方式是通过一个ajax请求得到user，通过一系列额外的请求得到每个订单，我们可以加载一个嵌套的数据集，并让reader自动组装相关的模型，详见Ext.data.reader.Reader：

 var store = Ext.create('Ext.data.Store', {
     autoLoad: true,
     model: "User",
     proxy: {
         type: 'ajax',
         url: 'users.json',
         reader: {
             type: 'json',
             root: 'users'
         }
     }
 });

Which would consume a response like this:

我们将消费这样一个响应：

 {
     "users": [{
         "id": 1,
         "name": "Ed",
         "orders": [{
             "id": 10,
             "total": 10.76,
             "status": "invoiced"
        },{
             "id": 11,
             "total": 13.45,
             "status": "shipped"
        }]
     }]
 }

See the Ext.data.reader.Reader intro docs for a full explanation.

Filtering and Sorting     过滤和排序

Stores can be sorted and filtered - in both cases either remotely or locally. The sorters and filters are held inside MixedCollection instances to make them easy to manage. Usually it is sufficient to either just specify sorters and filters in the Store configuration or call sort or filter:

store可以被排序和过滤--并都支持远程和本地模式。MixedCollection内部管理着sorters和 filters 。通过stroe配置项指定sorters 和filters ，或直接调用sort或filter，两种方式皆可。

 var store = Ext.create('Ext.data.Store', {
     model: 'User',
     sorters: [{
         property: 'age',
         direction: 'DESC'
     }, {
         property: 'firstName',
         direction: 'ASC'
     }],

     filters: [{
         property: 'firstName',
         value: /Ed/
     }]
 });

The new Store will keep the configured sorters and filters in the MixedCollection instances mentioned above. By default, sorting and filtering are both performed locally by the Store - see remoteSort and remoteFilter to allow the server to perform these operations instead.

这个新store会在MixedCollection 实例中保存sorters 和filters 的配置。缺省的，排序和过滤都是在本地操作，--参见remoteSort和remoteFilter 来允许服务器执行操作。

Filtering and sorting after the Store has been instantiated is also easy. Calling filter adds another filter to the Store and automatically filters the dataset (calling filter with no arguments simply re-applies all existing filters). Note that by default sortOnFilter is set to true, which means that your sorters are automatically reapplied if using local sorting.

store实例化后，修改过滤和排序也很简单。调用filter添加其它的过滤并自动过滤数据集（不带参数直接调用filter会重新应用现有的过滤）。注意，sortOnFilter缺省的是true，这意味着你的sorter会自动重新应用。

store.filter('eyeColor', 'Brown');

Change the sorting at any time by calling sort:

任何时候，通过调用sort方法改变排序：

store.sort('height', 'ASC');

Note that all existing sorters will be removed in favor of the new sorter data (if sort is called with no arguments, the existing sorters are just reapplied instead of being removed). To keep existing sorters and add new ones, just add them to the MixedCollection:

注意所有现存的排序都会被取代（如果sort以无参数形式调用，现存的sorter会重新应用而不是移除）。如果要保留现有的排序并加入新的，则将它们加到MixedCollection：

store.sorters.add(new Ext.util.Sorter({
    property : 'shoeSize',
    direction: 'ASC'
}));

store.sort();

Registering with StoreManager   在StoreManager中注册

Any Store that is instantiated with a storeId will automatically be registered with the StoreManager. This makes it easy to reuse the same store in multiple views:

任何以一个storeId实例化的store都会自动注册到StoreManager。这使得很容易在多个视图间重用同一个store：

//this store can be used several times
Ext.create('Ext.data.Store', {
    model: 'User',
    storeId: 'usersStore'
});

new Ext.List({
    store: 'usersStore',
    //other config goes here
});

new Ext.view.View({
    store: 'usersStore',
    //other config goes here
});

Further Reading   延伸阅读

Stores are backed up by an ecosystem of classes that enables their operation. To gain a full understanding of these pieces and how they fit together, see:

store基于一个类系统构建。要完整的理解它们，并清楚它们如何一起工作，请看：

• Proxy - overview of what Proxies are and how they are used
• Model - the core class in the data package
• Reader - used by any subclass of ServerProxy to read a response