Hierarchy
Ext.BaseExt.data.FieldRequires
Files
用Field对象集合来定义一个数据模型对象Model. 它们并不直接实例化 - 我们创建一个Ext.data.Model的子类, 它会自动为每一个 在{@linkExt.data.Model Model}中定义的字段创建一个Field实例. 例如, 我们可以这样设置一个模型:
Ext.define('User', {
extend: 'Ext.data.Model',
fields: [
'name', 'email',
{name: 'age', type: 'int'},
{name: 'gender', type: 'string', defaultValue: 'Unknown'}
]
});
对于User模型, 将会创建四个字段 - name, email, age和gender. 注意: 我们这里使用了两种不同的定义格式; 如果我们只用一个名称的字符串来 定义字段(就像name和email), 那么此字段的类型将为'auto'. 就像下面这样:
Ext.define('User', {
extend: 'Ext.data.Model',
fields: [
{name: 'name', type: 'auto'},
{name: 'email', type: 'auto'},
{name: 'age', type: 'int'},
{name: 'gender', type: 'string', defaultValue: 'Unknown'}
]
});
定义type是非常重要的 - 这将用于对数据进行自动类型转换, 以正确的格式放入字段中. 在上面的例子中, name和email字段使用的是'auto'类型, 他们将把所有数据保持原样的放入字段中. 而'age'字段的类型为'int', 那么如果我们 为其设值25.4就会被四舍五入成25.
有时仅仅用基本类型是不够的, 又或者我们想要对放入字段的数据做一些特殊处理. 这时我们就可以使用convert转换方法. 下面这个例子中, 我们将创建一个字段, 而这个字段的内容基于另一个字段:
Ext.define('User', {
extend: 'Ext.data.Model',
fields: [
{
name: 'firstName',
convert: function(value, record) {
var fullName = record.get('name'),
splits = fullName.split(" "),
firstName = splits[0];
return firstName;
}
},
'name', 'email',
{name: 'age', type: 'int'},
{name: 'gender', type: 'string', defaultValue: 'Unknown'}
]
});
现在当我们创建一个新的User对象时, 其'firstName'将被自动根据'name'的内容被赋值:
var ed = Ext.create('User', {name: 'Ed Spencer'});
console.log(ed.get('firstName')); //打印 'Ed', 基于我们的convert方法.
带有自定义convert方法的字段在创建和读取数据时, 会在所有其他字段之后读取, 所以当一个convert方法依赖于其他不含
转换方法的字段时(就如上面的例子), 就能确保这些字段已经有值.
事实上, 如果我们打印出'ed'中所有的数据, 我们会看到:
console.log(ed.data);
//输出如下:
{
age: 0,
email: "",
firstName: "Ed",
gender: "Unknown",
name: "Ed Spencer"
}
因为我们为'age'字段设置了int类型, 所以它被指定了默认值0. 作为类型为'auto'的字段, email被指定了一个空字符串. 当我们注册User模型时, 我们为gender字段设置了defaultValue属性值为'Unknown', 所以得到如上结果. 让我们修改一下来获得我们期望的类型:
ed.set('gender', 'Male');
ed.get('gender'); //returns 'Male'
ed.set('age', 25.4);
ed.get('age'); //returns 25 - 我们需要一个int, 而不是float, 所以小数部分被舍去
用于校验模型. 默认为'true'. 若设为'false', 则当此字段值为空时会导致 Ext.data.Model.isValid方法返回false.
Defaults to: true
一个函数, 用来将Reader读取的值转换成存储到Model中的对象.
如果此参数为'null', 则读取此Field时不会对原始数据进行转换. 这样会提高性能. 但是你必须确保数据是正确的类型并且不需要进行转换.
此方法含如下参数:
v : Mixed
Reader提供的数据值, 如果为undefined则使用defaultValue的参数值.
rec : Ext.data.Model
Reader到目前为止读取的Model的数据对象. 注意此时的Model字段值可能尚未被全部填入, 因为字段的读取顺序是根据你在 fields字段数组中的定义顺序.
转换函数的例子:
function fullName(v, record){
return record.data.last + ', ' + record.data.first;
}
function location(v, record){
return !record.data.city ? '' : (record.data.city + ', ' + record.data.state);
}
Ext.define('Dude', {
extend: 'Ext.data.Model',
fields: [
{name: 'fullname', convert: fullName},
{name: 'firstname', mapping: 'name.first'},
{name: 'lastname', mapping: 'name.last'},
{name: 'city', defaultValue: 'homeless'},
'state',
{name: 'location', convert: location}
]
});
// create the data store
var store = Ext.create('Ext.data.Store', {
reader: {
type: 'json',
model: 'Dude',
idProperty: 'key',
root: 'daRoot',
totalProperty: 'total'
}
});
var myData = [
{ key: 1,
name: { first: 'Fat', last: 'Albert' }
// notice no city, state provided in data object
},
{ key: 2,
name: { first: 'Barney', last: 'Rubble' },
city: 'Bedrock', state: 'Stoneridge'
},
{ key: 3,
name: { first: 'Cliff', last: 'Claven' },
city: 'Boston', state: 'MA'
}
];
用于当type为"date"时将获取的数据转换为Date对象.
一个为Ext.Date.parse函数提供的格式字符串, 或当Reader提供的值为'UNIX timestamp'类型时可以指定为 "timestamp", 或当Reader提供的值为一个javascript毫秒时间戳时可以指定为"time". 详情参见Ext.Date.
Defaults to: null
(可选参数) 一个地址表达式, 用来让Ext.data.reader.Reader的实现在创建Model对象时, 从原始数据 对象中获取字段(Field)的值. 如果表达式与字段name属性相同则可省略.
mapping表达式的格式是根据所使用的Reader类型而定:
mapping是一个包含js表达式的字符串, 对应于数据子项的root数组中的元素. 默认为字段name.
mapping是一个Ext.DomQuery地址, 指向与表示record数据的DOM元素相关联的数据项. 默认为字段name.
mapping是一个指向数组中字段值位置的索引数. 默认为字段在fields中声明数组的位置.
如果需要更复杂一些的提取值的算法, 请配置字段的convert方法. 此方法会将整个原始数据对象传参, 你可以以任何方式去访问 它以获取你希望得到的数据.
Defaults to: null
Model中字段的映射名称. 此名称被用来作引用, 例如Ext.grid.property.HeaderContainer中定义的column对象的dataIndex属性.
注意: 如同上面最简单的示例中, 如果除了'name'以外没有其他属性需要定义, 那么可以只用一个'name'值的字符串来定义这个字段.
设为'false'时, 将此字段从模型的Ext.data.Model.modified字段中排除出去. 同时也会排除用Ext.data.writer.Writer 对字段进行写操作. 当此模型字段仅用于保存客户端状态而不需要在服务器端持久化时, 就可以使用此属性. 默认为'true'.
Defaults to: true
一个函数, 用来将字段的值转换为可比较大小的值, 以保证排序功能的正确执行. 预定义函数由Ext.data.SortTypes提供. 以下是一个自定义排序的例子:
// 当前顺序 执行排序之后
// +-+------+ +-+------+
// |1|First | |1|First |
// |2|Last | |3|Second|
// |3|Second| |2|Last |
// +-+------+ +-+------+
sortType: function(value) {
switch (value.toLowerCase()) // 原生的toLowerCase():
{
case 'first': return 1;
case 'second': return 2;
default: return 3;
}
}
Defaults to: null
字段的数据类型, 用于在没有定义convert时, 把接收数据转换为存储值进行自动类型转换.
用一个字符串来定义. 允许以下值:
此参数也可以用Ext.data.Types类的成员来定义.
开发人员还可以创建自定义的系统特殊数据类型, 通过为Ext.data.Types类定义新成员即可.
扩展事件
Defaults to: []
本身
获取当前类的引用，此对象被实例化。不同于 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'
成员
调用原来的方法，这是以前的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)
返回调用父类的方法的结果。
这个类的初始化配置。典型例子:
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 混入原型 键-值对
获取从该对象被实例化的类的引用。 请注意不同于 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
配置扩展
方法/属性添加到这个类的原型。
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 类名
重写这个类的成员。通过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 当前类