Alternate names
Ext.data.HasManyAssociationHierarchy
Ext.BaseExt.data.association.AssociationExt.data.association.HasManyRequires
Files
代表两个模型中一对多的关系. 一般由一个模型定义直接创建:
Ext.define('Product', {
extend: 'Ext.data.Model',
fields: [
{name: 'id', type: 'int'},
{name: 'user_id', type: 'int'},
{name: 'name', type: 'string'}
]
});
Ext.define('User', {
extend: 'Ext.data.Model',
fields: [
{name: 'id', type: 'int'},
{name: 'name', type: 'string'}
],
// 我们可以在模型上用hasMany快捷定义一个hasMany关联
hasMany: {model: 'Product', name: 'products'}
});
以上我们创建了Product和User模型，并且以一个User拥有多个Product关联它们。 这给每个User实例提供了一个新的函数, 在本例中，该函数称‘products’，因为在上述的association配置中特别指定了该名称.
该函数返回一个专门的StoreStore , 该Store自动过滤加载指定模型实例只有Products的:
//首先，我们加载一个id为1的User
var user = Ext.create('User', {id: 1, name: 'Ed'});
//user.products 函数由association自动创建，并且返回一个Store，
//所建的store自动作用于id为1的User中的Products
var products = user.products();
//我们仍然可以拥有所有的Store的一般方法，例如可以轻易的给User加一个Product
products.add({
name: 'Another Product'
});
//保存store的所有修改 - 这里会在保存前自动设置新的Product的user_id为1
products.sync();
为了节省内存和处理时间，新的Store只有在第一次调用products()时实例化， 所以第二次调用products()时返回的是相同的store实例.
自定义筛选
Store自动提供了一个过滤器 - 默认该过滤器设为store只返回associated模型的外键和owner模型的主键相匹配的记录. 例如，若一个ID为100的User hasMany Products， 那么过滤器加载时，只返回Products中user_id == 100的。
有时我们需要其他的字段来过滤 - 例如一个Twitter搜索的应用程序例子中，我们需要模型Search和Tweet:
Ext.define('Search', {
extend: 'Ext.data.Model',
fields: [
'id', 'query'
],
hasMany: {
model: 'Tweet',
name : 'tweets',
filterProperty: 'query'
}
});
Ext.define('Tweet', {
extend: 'Ext.data.Model',
fields: [
'id', 'text', 'from_user'
]
});
//返回一个filterProperty的store过滤器
var store = new Search({query: 'Sencha Touch'}).tweets();
上述的tweets关联就由filterProperty设置的query属性来过滤, 并且，该方式相当于如下方式:
var store = Ext.create('Ext.data.Store', {
model: 'Tweet',
filters: [
{
property: 'query',
value : 'Sencha Touch'
}
]
});
(必选) 被关联的模型的字符串名称
(必选) 被关联的模型的字符串名称
数据中用来读取关联来源的属性名称.默认为关联模型的名称。
数据中用来读取关联来源的属性名称.默认为关联模型的名称。
associated Store上设置的可选重载默认的过滤器. 若设置了该值，则自动创建一个基于该配置foreignKey的用于过滤association的过滤器。 欲知更多详细信息请参阅介绍文档. 默认为undefined
associated模型中用于链接owner模型的外键名称。 默认为owner模型名称小写加"_id", 例如，一个Group模型hasMany Users的association中需创建'group_id'作为外键。 当远程store加载时，store会自动过滤数据，只保留结果中子store中匹配外键的记录。 当然该值可以由指定的filterProperty属性重写。
Ext.define('Group', {
extend: 'Ext.data.Model',
fields: ['id', 'name'],
hasMany: 'User'
});
Ext.define('User', {
extend: 'Ext.data.Model',
fields: ['id', 'name', 'group_id'], // 指出本users归属于的group的id
belongsTo: 'Group'
});
owner模型中创建来接收子存储的函数名. 若没有具体指定，则使用子模型的名称复数形式.
// 在任意的一个Group模型的实例上创建一个users()方法
Ext.define('Group', {
extend: 'Ext.data.Model',
fields: ['id', 'name'],
hasMany: 'User'
});
var group = new Group();
console.log(group.users());
// 获取users的方法为getUserList
Ext.define('Group', {
extend: 'Ext.data.Model',
fields: ['id', 'name'],
hasMany: {model: 'User', name: 'getUserList'}
});
var group = new Group();
console.log(group.getUserList());
(必选) 拥有association的模型字符串名称
(必选) 拥有association的模型字符串名称
关联模型的主键名称. 一般是模型的Ext.data.Model.idProperty
Defaults to: "id"
一种可以读取关联数据的特殊reader
一种可以读取关联数据的特殊reader
将传递给产生的stroe的可选的配置项. 默认为undefined.
扩展事件
Defaults to: []
在关联最后的模型名称 (例如.若一个User模型hasMany Orders, 该值就为'Order')
在关联最后的模型名称 (例如.若一个User模型hasMany Orders, 该值就为'Order')
本身
获取当前类的引用，此对象被实例化。不同于 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)
返回调用父类的方法的结果。
创建一个方法，返回一个配置为owner模型主键过滤来加载一组数据的Ext.data.Store. 例如，在一个hasMany关系中，Group hasMany Users, 本函数返回一个配置为返回一个单一的Groups的Users的存储Store.
store方法
这个类的初始化配置。典型例子:
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 混入原型 键-值对
读取associated数据
要写入的记录
associated模型的阅读器Reader
原始的associated数据
获取从该对象被实例化的类的引用。 请注意不同于 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 当前类