Alternate names
Ext.data.RecordHierarchy
Ext.BaseExt.data.ModelMixins
Requires
Subclasses
Files
Model代表应用程序管理的一些对象。例如，我们可能会为 我们想在系统中建模的现实世界中的一些物体像使用者、产品和汽车等定义一个Model。这些Model在 模型管理器中注册，被仓库使用, 而这些仓库又被许多 Ext中许多与数据绑定的组件使用.
Model定义为字段、任意方法和与模型相关的属性的集合。例如:
Ext.define('User', {
extend: 'Ext.data.Model',
fields: [
{name: 'name', type: 'string'},
{name: 'age', type: 'int', convert: null},
{name: 'phone', type: 'string'},
{name: 'alive', type: 'boolean', defaultValue: true, convert: null}
],
changeName: function() {
var oldName = this.get('name'),
newName = oldName + " The Barbarian";
this.set('name', newName);
}
});
字段数组被ModelManager自动转换为MixedCollection, 并且其他所有的属性和方法被复制到了新Model的原型里.
内置的数值型和布尔型的字段类型有默认的能强制将原生数据中的字符串转换成字段类型的Ext.data.Field.convert函数。 为了得到使用Json 或者 Array 阅读器的更好性能， 如果你控制着填充到Model中的数据, 你能取消默认的转换函数，因为这个函数会导致 原始属性值被直接复制到字段值里面。
现在我们能创建模型User的实例并调用我们定义的任何模型的逻辑:
var user = Ext.create('User', {
name : 'Conan',
age : 24,
phone: '555-555-5555'
});
user.changeName();
user.get('name'); //returns "Conan The Barbarian"
Model有内置的验证支持, 通过执行Ext.data.validations中的验证器函数(Ext.data.validations查看所有的验证函数). 给模型添加验证非常 简单:
Ext.define('User', {
extend: 'Ext.data.Model',
fields: [
{name: 'name', type: 'string'},
{name: 'age', type: 'int'},
{name: 'phone', type: 'string'},
{name: 'gender', type: 'string'},
{name: 'username', type: 'string'},
{name: 'alive', type: 'boolean', defaultValue: true}
],
validations: [
{type: 'presence', field: 'age'},
{type: 'length', field: 'name', min: 2},
{type: 'inclusion', field: 'gender', list: ['Male', 'Female']},
{type: 'exclusion', field: 'username', list: ['Admin', 'Operator']},
{type: 'format', field: 'username', matcher: /([a-z]+)[0-9]{2,3}/}
]
});
通过调用validate函数能简单执行验证, 返回一个Ext.data.Errors 对象:
var instance = Ext.create('User', {
name: 'Ed',
gender: 'Male',
username: 'edspencer'
});
var errors = instance.validate();
Model之间可以通过Ext.data.association.HasOne, belongsTo和hasMany实现关联. 例如, 假设我们正在写一个博客管理程序，其中有用户（User)、博客（Post）和回复（Comment）. 我们能这样表示模型之间的关系:
Ext.define('Post', {
extend: 'Ext.data.Model',
fields: ['id', 'user_id'],
belongsTo: 'User',
hasMany : {model: 'Comment', name: 'comments'}
});
Ext.define('Comment', {
extend: 'Ext.data.Model',
fields: ['id', 'user_id', 'post_id'],
belongsTo: 'Post'
});
Ext.define('User', {
extend: 'Ext.data.Model',
fields: ['id'],
hasMany: [
'Post',
{model: 'Comment', name: 'comments'}
]
});
见Ext.data.association.HasOne, Ext.data.association.BelongsTo和 Ext.data.association.HasMany的文档获取使用和配置关联的详细信息。 注意也能这样表示关联:
Ext.define('User', {
extend: 'Ext.data.Model',
fields: ['id'],
associations: [
{type: 'hasMany', model: 'Post', name: 'posts'},
{type: 'hasMany', model: 'Comment', name: 'comments'}
]
});
Model在表示数据和关系的类型上十分强大，但是我们早晚要把那些数据加载或者保存 在某个地方. Proxy处理所有的加载和保存, 它 能在Model直接设置:
Ext.define('User', {
extend: 'Ext.data.Model',
fields: ['id', 'name', 'email'],
proxy: {
type: 'rest',
url : '/users'
}
});
这里我们设置了一个Rest Proxy,它知道怎样从一个REST后端加载数据和向它 保存数据。让我们看看它是怎样实现的:
var user = Ext.create('User', {name: 'Ed Spencer', email: 'ed@sencha.com'});
user.save(); //POST /users
Model实例调用save告诉配置好的RestProxy我们想保存这个Model的 数据到服务器上。因为这个Model没有id，所以RestProxy知道它以前没有保存过, 于是采取了合适的行为 - 本例中就是向我们配置的URL（/users）发起一个POST请求。我们 根据API能够在任何Model上配置任何的Proxy - 见Ext.data.proxy.Proxy.
通过Proxy加载数据同样简单:
//获取一个模型类User的引用
var User = Ext.ModelManager.getModel('User');
//使用配置的RestProxy向/users/123发起一个GET请求
User.load(123, {
success: function(user) {
console.log(user.getId()); //logs 123
}
});
Model也能简单地更新和销毁:
//上段代码中加载的Model实例user:
user.set('name', 'Edward Spencer');
//告诉Proxy保存Model. 在本例中，由于Model已经有一个id了，将会向/users/123发起一个PUT请求
user.save({
success: function() {
console.log('The User was updated');
}
});
//告诉Proxy销毁Model。向/users/123发起DELETE请求
user.destroy({
success: function() {
console.log('The User was destroyed!');
}
});
加载多个Model实例在UI中显示和操作非常常见。我们通过 创建一个Store实现:
var store = Ext.create('Ext.data.Store', {
model: 'User'
});
//使用我们在Model中设置的Proxy加载Store数据
store.load();
一个Store仅仅是Model实例的集合，这些Model通常是从某处的服务器上加载的。Store也能通过Proxy 增加、更新和删除Model实例与服务器同步。更多Store的信息见Store docs。
本模型的一个或多个BelongsTo关联。
本模型的一个或多个BelongsTo关联。
用以向服务器提交本模型的唯一的客户端标记的属性的名字 当一次操作保存多个phantom记录时。 在这种情况下，服务器的响应的每一条记录应该包含客户端id， 服务器响应的数据能在适当的时候更新客户端的记录。 这个属性不能和模型的任何字段重名。
Defaults to: null
字符串形式的默认的模型Proxy类型。默认为'ajax'。
Defaults to: "ajax"
作为本模型唯一的id的字段的名字。默认为'id'。
Defaults to: "id"
本模型使用的id生成器。默认的id生成器不生成 idProperty。
可在模型级别重写来为模型自定义id生成器。 最简单的形式是:
Ext.define('MyApp.data.MyModel', {
extend: 'Ext.data.Model',
requires: ['Ext.data.SequentialIdGenerator'],
idgen: 'sequential',
...
});
以上方式将会产生序列id， 例如1, 2, 3等等。
另外一种id生成器是Ext.data.UuidGenerator:
Ext.define('MyApp.data.MyModel', {
extend: 'Ext.data.Model',
requires: ['Ext.data.UuidGenerator'],
idgen: 'uuid',
...
});
还能进一步配置id生成:
Ext.define('MyApp.data.MyModel', {
extend: 'Ext.data.Model',
idgen: {
type: 'sequential',
seed: 1000,
prefix: 'ID_'
}
});
以上方式将会生成id像ID_1000, ID_1001, ID_1002等。
如果多个模型共享一个id空间，简单的id生成器可共享:
Ext.define('MyApp.data.MyModelX', {
extend: 'Ext.data.Model',
idgen: {
type: 'sequential',
id: 'xy'
}
});
Ext.define('MyApp.data.MyModelY', {
extend: 'Ext.data.Model',
idgen: {
type: 'sequential',
id: 'xy'
}
});
如果需要共享更复杂的id生成器，最好的方式是自定义id生成器。 创建自定义的id生成器，详见Ext.data.IdGenerator。
一个配置对象，包含一个或多个事件处理函数，在对象初始化时添加到对象。 它应该是addListener指定的一个有效的监听器配置对象， 一次添加多个事件处理函数。
Ext JS 组建的DOM事件
虽然一些Ext JS组件类输出选定的DOM事件（例如"click"、"mouseover"等),
但是这只能通过添加额外的值（如果能）。例如，DataView的itemclick传递被单击的节点。为了通过Component的子元素直接访问DOM事件，
我们需要指定element选项来标识要
添加DOM监听器的Component属性：
new Ext.panel.Panel({
width: 400,
height: 200,
dockedItems: [{
xtype: 'toolbar'
}],
listeners: {
click: {
element: 'el', //bind to the underlying el property on the panel
fn: function(){ console.log('click el'); }
},
dblclick: {
element: 'body', //bind to the underlying body property on the panel
fn: function(){ console.log('dblclick body'); }
}
}
});
保存本可持久化对象数据属性的名字。默认是'data'
(也就是所有可持久化数据保存在this.data。)
Defaults to: "data"
扩展事件
Defaults to: []
本模型定义的字段集合(包括父类中定义的字段)
它是Ext.data.Field实例集合，每一个Field实例封装了字段的配置信息。 默认情况下，你能简单地用代表字段名字的字符串指定字段，但是一个字段封装了 数据类型，原始数据的自定义类型转换和一个映射属性。 这个映射通过index名指定从原始数据对象中提取字段的值。
本对象包含任何有监听器的事件的键。监听器可以在实例上直接设置， 或者在其类或者父类(通过observe) 或者在MVC EventBus上设置。本对象的值为真 (一个非零的数字)和假(0或者undefined)。它们并不代表确切的监听器数量。 如果事件必须被触发，它的值是真的， 如果没有必要，就是假的。
本属性的设计目的是避免没有监听器时调用fireEvent的开销。 如果fireEvent要调用成百上千次，这尤其有用。 用法:
if (this.hasListeners.foo) {
this.fireEvent('foo', this, arg1);
}
An internal unique ID for each Model instance, used to identify Models that don't have an ID yet
An internal unique ID for each Model instance, used to identify Models that don't have an ID yet
在本类中设置为true将一个对象标识为实例化的Observable或其子类。
Defaults to: true
In this method we use a breadth first strategy instead of depth first. The reason for doing so is that it prevents messy & difficult issues when figuring out which associations we've already processed & at what depths.
True服务器端数据库上不存在本记录(见setDirty). 任何id属性是服务器数据库上的主键的记录不是phantom，它是真实存在的。
Defaults to: false
本身
获取当前类的引用，此对象被实例化。不同于 statics,
this.self是依赖范围，它意味着要使用动态继承。
参见 statics 详细对比
Ext.define('My.Cat', {
statics: {
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
alert(this.self.speciesName); // 依赖 'this'
},
clone: function() {
return new this.self();
}
});
Ext.define('My.SnowLeopard', {
extend: 'My.Cat',
statics: {
speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'
}
});
var cat = new My.Cat(); // alerts 'Cat' 猫
var snowLeopard = new My.SnowLeopard(); // alerts 'Snow Leopard' 雪豹
var clone = snowLeopard.clone();
alert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'
绑定本模型实例的仓库，默认为[]
Defaults to: []
成员
向本对象添加一个事件处理函数，例如:
myGridPanel.on("mouseover", this.onMouseOver, this);
这个方法也允许传递单个参数，参数为一个 包含指定多个事件的属性的配置对象。例如:
myGridPanel.on({
cellClick: this.onCellClick,
mouseover: this.onMouseOver,
mouseout: this.onMouseOut,
scope: this // Important. Ensure "this" is correct during handler execution
});
你也能为每个事件处理函数单独指定选项：
myGridPanel.on({
cellClick: {fn: this.onCellClick, scope: this, single: true},
mouseover: {fn: panel.onMouseOver, scope: panel}
});
也能使用在特定作用域的方法名。注意
必须指定scope:
myGridPanel.on({
cellClick: {fn: 'onCellClick', scope: this, single: true},
mouseover: {fn: 'onMouseOver', scope: panel}
});
被监听的事件名。 也可以是属性名字是事件名字的对象。
事件调用的方法, 或者如果指定了scope，在指定scope的方法名*。
会被调用，
参数为fireEvent的参数加上下述options参数。
事件处理函数执行的作用域(this应用的上下文)
如果省略, 默认为触发事件的对象。
包含事件处理函数配置的对象。
注意: 不像ExtJS 3.x, options对象也会作为最后一个参数 传递给每一个事件处理函数。
这个对象可能包含以下任何一个属性:
事件处理函数执行的作用域(this应用的上下文)
如果省略, 默认为触发事件的对象。
事件触发后，调用事件处理函数延时毫秒数。
设置为true添加一个事件处理函数，只处理下一次触发的事件, 然后移除这个函数。
使事件处理函数在Ext.util.DelayedTask中调度运行， 延时指定的毫秒数。如果事件在这段事件再次触发， 原先的事件处理函数不再调用, 新的事件处理函数接替。
只有当事件在目标Observable上触发时调用事件处理函数, 如果事件是从Observable的子类起泡的，不会调用事件处理函数
这个选项只对绑定在Components上的监听器有效。 Component的一个属性名，这个属性引用一个待添加监听器的元素
这个选项在Component构造过程中向Components的元素添加DOM事件监听器有用。 这些元素只有在Component渲染之后才会存在。 例如, 向Panel的body中添加click监听器:
new Ext.panel.Panel({
title: 'The title',
listeners: {
click: this.handlePanelClick,
element: 'body'
}
});
组合选项
使用options参数, 可以组合不同类型的监听器：
一个延时的一次性监听器：
myPanel.on('hide', this.handleClick, this, {
single: true,
delay: 100
});
向任何Observable对象（或者Ext.Element）添加监听器， 当组件被销毁时，监听器自动被移除
添加监听器的目标项。
事件名或者包含的事件名属性的对象。
(可选的) 如果ename参数是事件名, 这就是一个事件处理函数。
(可选的) 如果ename参数是事件名, 这就是(this引用的上下文)
事件处理函数执行的作用域。
(可选的)如果ename参数是事件名,
这就是addListener的选项。
开始编辑。在编辑模式的时候，仓库接受不到任何事件(例如update事件)。
编辑开始后，其后必须跟着endEdit或者cancelEdit。
调用原来的方法，这是以前的override重写
Ext.define('My.Cat', {
constructor: function() {
alert("I'm a cat!");
}
});
My.Cat.override({
constructor: function() {
alert("I'm going to be a cat!");
this.callOverridden();
alert("Meeeeoooowwww");
}
});
var kitty = new My.Cat(); // alerts "I'm going to be a cat!"
// alerts "I'm a cat!"
// alerts "Meeeeoooowwww"
This method has been deprecated since 4.1
版本 使用 callParent 代替.
参数的参数，数组或'参数'对象
来自当前方法，例如： this.callOverridden(arguments)
返回调用重写方法的结果。
所谓的"parent"方法是指当前的方法。 这是以前的方法派生或重写(参见 Ext.define)。
Ext.define('My.Base', {
constructor: function (x) {
this.x = x;
},
statics: {
method: function (x) {
return x;
}
}
});
Ext.define('My.Derived', {
extend: 'My.Base',
constructor: function () {
this.callParent([21]);
}
});
var obj = new My.Derived();
alert(obj.x); // alerts 21
这可以用来重写如下:
Ext.define('My.DerivedOverride', {
override: 'My.Derived',
constructor: function (x) {
this.callParent([x*2]); // 调用原来的My.Derived构造
}
});
var obj = new My.Derived();
alert(obj.x); // 现在提示 42
This also works with static methods.
Ext.define('My.Derived2', {
extend: 'My.Base',
statics: {
method: function (x) {
return this.callParent([x*2]); // 调用 My.Base.method
}
}
});
alert(My.Base.method(10); // alerts 10
alert(My.Derived2.method(10); // alerts 20
然后，它也可以重写静态方法。
Ext.define('My.Derived2Override', {
override: 'My.Derived2',
statics: {
method: function (x) {
return this.callParent([x*2]); // 调用 My.Derived2.method
}
}
});
alert(My.Derived2.method(10); // 现在提示 40
这个参数, 通过当前方法得到数组或者 arguments 对象,
例如: this.callParent(arguments)
返回调用父类的方法的结果。
Helper function used by afterEdit, afterReject and afterCommit. Calls the given method on the store that this instance has joined, if any. The store function will always be called with the model instance as its single argument. If this model is joined to a Ext.data.NodeStore, then this method calls the given method on the NodeStore and the associated Ext.data.TreeStore
The function to call on the store
取消当前编辑中所做的改变
移除本对象的包括受管理的监听器在内的所有监听器
移除本对象的所有受管理的监听器
通常由包含本模型实例的Ext.data.Store调用。提交所有 本模型自创建或上次提交之后的所有的改变。
开发者应该监听Ext.data.Store.update以使代码收到拒绝操作 的通知。
True跳过对包含改变的仓库的通知 默认为false。
创建本模型实例的副本。
新的id默认为被复制的实例的id
见id。用新id生成phantom实例用:
var rec = record.copy(); // clone the record
Ext.data.Model.id(rec); // automatically generate a unique sequential id
Copies data from the passed record into this record. If the passed record is undefined, does nothing.
If this is a phantom record (represented only in the client, with no corresponding database entry), and the source record is not a phantom, then this record acquires the id of the source record.
The record to copy data from.
使用配置的代理销毁本模型实例。
传给代理的选项。Ext.data.Operation的配置对象。
模型实例
通过调用this.getBubbleTarget()（如果存在）允许本Observable对象触发的事件沿着继承体系起泡
在Observable基类中没有实现类。
这通常被Ext.Components用来将事件起泡到它的容器。 见Ext.Component.getBubbleTarget。Ext.Component中的默认实现 返回Component的直接容器。但是如果需要一个明显的target, 它可以被重写 以更快地访问需要的target。
使用范例:
Ext.override(Ext.form.field.Base, {
// Add functionality to Field's initComponent to enable the change event to bubble
initComponent : Ext.Function.createSequence(Ext.form.field.Base.prototype.initComponent, function() {
this.enableBubble('change');
}),
// We know that we want Field's events to bubble directly to the FormPanel.
getBubbleTarget : function() {
if (!this.formPanel) {
this.formPanel = this.findParentByType('form');
}
return this.formPanel;
}
});
var myForm = new Ext.formPanel({
title: 'User Details',
items: [{
...
}],
listeners: {
change: function() {
// Title goes red if form has been modified.
myForm.header.setStyle('color', 'red');
}
}
});
使用传递过来的参数(去掉事件名，加上传递给addListener的options对象
)触发指定的事件。
通过调用enableBubble，一个事件 能被设置为沿着Observable的继承体系(见Ext.Component.getBubbleTarget)向上起泡。
如果任何一个事件处理函数返回false，就返回false，否则返回true。
递归获取本模型加载的所有关联的所有数据。例如如果我们有一个 User，它有很多Order，并且每一个Order有很多OrderItem，会返回这样一个对象:
{
orders: [
{
id: 123,
status: 'shipped',
orderItems: [
...
]
}
]
}
模型加载的关联的数据。
Gets the bubbling parent for an Observable
The bubble parent. null is returned if no bubble target exists
返回一个定义本模型结构的Field数组定义
字段根据Model类定义排序。带有自定义convert函数的字段 被移到没有convert函数的字段的后面。这样依赖与现有字段值的convert函数 将能读取那些字段的值。
本Model定义的字段
Gets the names of all the fields that were modified during an edit
An array of modified field names
这个类的初始化配置。典型例子:
Ext.define('My.awesome.Class', {
// 这是默认配置
config: {
name: 'Awesome',
isAwesome: true
},
constructor: function(config) {
this.initConfig(config);
}
});
var awesome = new My.awesome.Class({
name: 'Super Awesome'
});
alert(awesome.getName()); // 'Super Awesome' 超级棒
配置
mixins 混入原型 键-值对
addManagedListener的简写方法
向任何Observable对象（或者Ext.Element）添加监听器， 当组件被销毁时，监听器自动被移除
添加监听器的目标项。
事件名或者包含的事件名属性的对象。
(可选的) 如果ename参数是事件名, 这就是一个事件处理函数。
(可选的) 如果ename参数是事件名, 这就是(this引用的上下文)
事件处理函数执行的作用域。
(可选的)如果ename参数是事件名,
这就是addListener的选项。
移除通过mon方法添加的监听器。
待移除监听器的项
事件名或者包含的事件名属性的对象。
(可选的) 如果ename参数是事件名, 这就是一个事件处理函数。
(可选的) 如果ename参数是事件名, 这就是(this引用的上下文)
事件处理函数执行的作用域。
addListener的简写方法
向本对象添加一个事件处理函数，例如:
myGridPanel.on("mouseover", this.onMouseOver, this);
这个方法也允许传递单个参数，参数为一个 包含指定多个事件的属性的配置对象。例如:
myGridPanel.on({
cellClick: this.onCellClick,
mouseover: this.onMouseOver,
mouseout: this.onMouseOut,
scope: this // Important. Ensure "this" is correct during handler execution
});
你也能为每个事件处理函数单独指定选项：
myGridPanel.on({
cellClick: {fn: this.onCellClick, scope: this, single: true},
mouseover: {fn: panel.onMouseOver, scope: panel}
});
也能使用在特定作用域的方法名。注意
必须指定scope:
myGridPanel.on({
cellClick: {fn: 'onCellClick', scope: this, single: true},
mouseover: {fn: 'onMouseOver', scope: panel}
});
被监听的事件名。 也可以是属性名字是事件名字的对象。
事件调用的方法, 或者如果指定了scope，在指定scope的方法名*。
会被调用，
参数为fireEvent的参数加上下述options参数。
事件处理函数执行的作用域(this应用的上下文)
如果省略, 默认为触发事件的对象。
包含事件处理函数配置的对象。
注意: 不像ExtJS 3.x, options对象也会作为最后一个参数 传递给每一个事件处理函数。
这个对象可能包含以下任何一个属性:
事件处理函数执行的作用域(this应用的上下文)
如果省略, 默认为触发事件的对象。
事件触发后，调用事件处理函数延时毫秒数。
设置为true添加一个事件处理函数，只处理下一次触发的事件, 然后移除这个函数。
使事件处理函数在Ext.util.DelayedTask中调度运行， 延时指定的毫秒数。如果事件在这段事件再次触发， 原先的事件处理函数不再调用, 新的事件处理函数接替。
只有当事件在目标Observable上触发时调用事件处理函数, 如果事件是从Observable的子类起泡的，不会调用事件处理函数
这个选项只对绑定在Components上的监听器有效。 Component的一个属性名，这个属性引用一个待添加监听器的元素
这个选项在Component构造过程中向Components的元素添加DOM事件监听器有用。 这些元素只有在Component渲染之后才会存在。 例如, 向Panel的body中添加click监听器:
new Ext.panel.Panel({
title: 'The title',
listeners: {
click: this.handlePanelClick,
element: 'body'
}
});
组合选项
使用options参数, 可以组合不同类型的监听器：
一个延时的一次性监听器：
myPanel.on('hide', this.handleClick, this, {
single: true,
delay: 100
});
This complex-looking method takes a given Model instance and returns an object containing all data from all of that Model's loaded associations. See getAssociatedData
The nested data set for the Model's loaded associations
通常由本模型实例join的Ext.data.Store调用。拒绝 本模型实例自创建或者上一次提交之后的所有的改变。修改的字段 回退到原先的值。
开发者应该监听Ext.data.Store.update以使代码收到拒绝操作 的通知。
True跳过对包含改变的仓库的通知 默认为false。
从指定的Observable接替选定的事件就好像事件是this触发的。
例如，如果你想要扩展Grid, 你可能决定转发store的一些事件。 所以你能在你的initComponent中实现这个:
this.relayEvents(this.getStore(), ['load']);
grid实例将会有一个observable的'load'事件，
这个事件的参数是store的load事件的参数。任何grid的load事件触发的函数
可以使用this访问grid。
移除事件处理函数。
事件处理函数关联的事件类型
待移除的事件处理函数。 必须是对传递给addListener 的函数的引用。
(可选的) 原先为事件处理函数指定的作用域。 它必须是和原先调用addListener时指定的作用域参数是一样的，否者监听器将会被移除。
移除通过mon方法添加的监听器。
待移除监听器的项
事件名或者包含的事件名属性的对象。
(可选的) 如果ename参数是事件名, 这就是一个事件处理函数。
(可选的) 如果ename参数是事件名, 这就是(this引用的上下文)
事件处理函数执行的作用域。
继续事件的触发(见suspendEvents)。
如果事件被使用queueSuspended参数挂起, 那么所有
在事件挂起期间触发的事件将会被发送到任意监听器。
使用配置的代理保存本模型实例。
传给代理的选项。Ext.data.Operation的配置对象。
The Model instance
设置本模型使用的代理。接受任何 Ext.createByAlias接受的选项。
代理
获取从该对象被实例化的类的引用。 请注意不同于 self,
this.statics()是独立的作用域，无论this是否运行，总是返回其中的调用类。
Ext.define('My.Cat', {
statics: {
totalCreated: 0,
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
var statics = this.statics();
alert(statics.speciesName); // 总是等于'Cat'，无论'this'是什么，
// 相当于：My.Cat.speciesName
alert(this.self.speciesName); // 依赖 'this'
statics.totalCreated++;
},
clone: function() {
var cloned = new this.self; // 依赖 'this'
cloned.groupName = this.statics().speciesName; // 相当于: My.Cat.speciesName
return cloned;
}
});
Ext.define('My.SnowLeopard', {
extend: 'My.Cat',
statics: {
speciesName: 'Snow Leopard' // My.SnowLeopard.speciesName = 'Snow Leopard'
},
constructor: function() {
this.callParent();
}
});
var cat = new My.Cat(); // alerts 'Cat', 然后提示 'Cat'
var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', 然后提示 'Snow Leopard'
var clone = snowLeopard.clone();
alert(Ext.getClassName(clone)); // alerts 'My.SnowLeopard'
alert(clone.groupName); // alerts 'Cat'
alert(My.Cat.totalCreated); // alerts 3
挂起所有事件的触发。(见resumeEvents)
传true，让挂起的事件排队而不是丢弃所有挂起的事件， 这些事件将会在调用resumeEvents之后触发。
配置扩展
removeListener的简写方法
移除事件处理函数。
事件处理函数关联的事件类型
待移除的事件处理函数。 必须是对传递给addListener 的函数的引用。
(可选的) 原先为事件处理函数指定的作用域。 它必须是和原先调用addListener时指定的作用域参数是一样的，否者监听器将会被移除。
方法/属性添加到这个类的原型。
Ext.define('My.awesome.Cat', {
constructor: function() {
...
}
});
My.awesome.Cat.implement({
meow: function() {
alert('Meowww...');
}
});
var kitty = new My.awesome.Cat;
kitty.meow();
成员
添加/重写这个类的静态属性。
Ext.define('My.cool.Class', {
...
});
My.cool.Class.addStatics({
someProperty: 'someValue', // My.cool.Class.someProperty = 'someValue'
method1: function() { ... }, // My.cool.Class.method1 = function() { ... };
method2: function() { ... } // My.cool.Class.method2 = function() { ... };
});
成员
this
这个类的原型借用另一个类的成员
Ext.define('Bank', {
money: '$$$',
printMoney: function() {
alert('$$$$$$$');
}
});
Ext.define('Thief', {
...
});
Thief.borrow(Bank, ['money', 'printMoney']);
var steve = new Thief();
alert(steve.money); // alerts '$$$'
steve.printMoney(); // alerts '$$$$$$$'
this 借用成员
创建这个类的新实例。
Ext.define('My.cool.Class', {
...
});
My.cool.Class.create({
someConfig: true
});
所有参数传递至类的构造。
创建的实例。
创建现有的原型方法的别名。例如：
Ext.define('My.cool.Class', {
method1: function() { ... },
method2: function() { ... }
});
var test = new My.cool.Class();
My.cool.Class.createAlias({
method3: 'method1',
method4: 'method2'
});
test.method3(); // test.method1()
My.cool.Class.createAlias('method5', 'method3');
test.method5(); // test.method3() -> test.method1()
别名新方法的名称，或对象设置多个别名。 参见flexSetter
原来的方法名
以字符串格式，获取当前类的名称。
Ext.define('My.cool.Class', {
constructor: function() {
alert(this.self.getName()); // alerts 'My.cool.Class'
}
});
My.cool.Class.getName(); // 'My.cool.Class'
className 类名
生成一个序列id。当一个记录产生之后并且没有指明id， 这个方法被调用。这个id会自动赋给这条记录。 返回这样的id: {PREFIX}-{AUTO_ID}。
产生的记录。记录不存在，而是一个 phantom。
自动生成的字符串id, "ext-record-i++";
通过id异步加载模型实例。使用样例如下:
Ext.define('MyApp.User', {
extend: 'Ext.data.Model',
fields: [
{name: 'id', type: 'int'},
{name: 'name', type: 'string'}
]
});
MyApp.User.load(10, {
scope: this,
failure: function(record, operation) {
//do something if the load failed
},
success: function(record, operation) {
//do something if the load succeeded
},
callback: function(record, operation) {
//do something whether the load succeeded or failed
}
});
重写这个类的成员。通过callParent重写的方法可以调用。
Ext.define('My.Cat', {
constructor: function() {
alert("I'm a cat!");
}
});
My.Cat.override({
constructor: function() {
alert("I'm going to be a cat!");
this.callParent(arguments);
alert("Meeeeoooowwww");
}
});
var kitty = new My.Cat(); // alerts "I'm going to be a cat!我要成为一只猫！"
// alerts "I'm a cat!我是一只猫！"
// alerts "Meeeeoooowwww"
在4.1版本, 直接利用这种方法已经过时了。 使用 Ext.define 代替:
Ext.define('My.CatOverride', {
override: 'My.Cat',
constructor: function() {
alert("I'm going to be a cat!");
this.callParent(arguments);
alert("Meeeeoooowwww");
}
});
以上完成了相同的结果，但可以由Ext.Loader重写， 其目标类和生成过程中，可以决定是否需要根据目标类所需的状态覆盖管理(My.Cat)。
This method has been deprecated since 4.1.0
使用 Ext.define 代替
添加到这个类的属性。 这应当被指定为一个对象包含一个或多个属性的文字。
this class 当前类
设置本模型使用的Proxy。接受 Ext.createByAlias接受的任何选项。
设置用代理
当本模型的id改变时触发
原id
新id
The options object passed to Ext.util.Observable.addListener.