Instance Methods
Adds Model instance to the Store. This method accepts either:
- An array of Model instances or Model configuration objects.
- Any number of Model instance or Model configuration object arguments.
The new Model instances will be added at the end of the existing collection.
Sample usage:
myStore.add({some: 'data'}, {some: 'other data'});
Note that if this Store is sorted, the new Model instances will be inserted
at the correct point in the Store to maintain the sort order.
record :
Ext.data.Model[]/Ext.data.Model.../Object[]/Object...
An array of
records or configuration objects, or variable number of record or config arguments.
:
Ext.data.Model[]
The record instances that were added.
This method applies a versioned, deprecation declaration to this class. This
is typically called by the deprecated config.
Runs the aggregate function for all the records in the store.
When store is filtered, only items within the filter are aggregated.
fn :
Function
The function to execute. The function is called with a single parameter,
an array of records for that group.
scope :
Object
(optional)
The scope to execute the function in. Defaults to the store.
grouped :
Boolean
(optional)
True to perform the operation for each group
in the store. The value returned will be an object literal with the key being the group
name and the group average being the value. The grouped parameter is only honored if
the store has a groupField.
field :
String
The field to get the value from
:
Object
An object literal with the group names and their appropriate values.
Gets the average value in the store.
When store is filtered, only items within the filter are aggregated.
grouped :
Boolean
(optional)
True to perform the operation for each group
in the store. The value returned will be an object literal with the key being the group
name and the group average being the value. The grouped parameter is only honored if
the store has a groupField.
:
Object
The average value, if no items exist, 0.
Call the original method that was previously overridden with Ext.Base#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"
args :
Array/Arguments
The arguments, either an array or the arguments object
from the current method, for example: this.callOverridden(arguments)
:
Object
Returns the result of calling the overridden method
Deprecated since version 4.1.0
Use method-callParent instead.
Call the "parent" method of the current method. That is the method previously
overridden by derivation or by an override (see 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
This can be used with an override as follows:
Ext.define('My.DerivedOverride', {
override: 'My.Derived',
constructor: function (x) {
this.callParent([x*2]); // calls original My.Derived constructor
}
});
var obj = new My.Derived();
alert(obj.x); // now alerts 42
This also works with static and private methods.
Ext.define('My.Derived2', {
extend: 'My.Base',
// privates: {
statics: {
method: function (x) {
return this.callParent([x*2]); // calls My.Base.method
}
}
});
alert(My.Base.method(10)); // alerts 10
alert(My.Derived2.method(10)); // alerts 20
Lastly, it also works with overridden static methods.
Ext.define('My.Derived2Override', {
override: 'My.Derived2',
// privates: {
statics: {
method: function (x) {
return this.callParent([x*2]); // calls My.Derived2.method
}
}
});
alert(My.Derived2.method(10); // now alerts 40
To override a method and replace it and also call the superclass method, use
method-callSuper. This is often done to patch a method to fix a bug.
args :
Array/Arguments
The arguments, either an array or the arguments object
from the current method, for example: this.callParent(arguments)
:
Object
Returns the result of calling the parent method
This method is used by an override to call the superclass method but
bypass any overridden method. This is often done to "patch" a method that
contains a bug but for whatever reason cannot be fixed directly.
Consider:
Ext.define('Ext.some.Class', {
method: function () {
console.log('Good');
}
});
Ext.define('Ext.some.DerivedClass', {
extend: 'Ext.some.Class',
method: function () {
console.log('Bad');
// ... logic but with a bug ...
this.callParent();
}
});
To patch the bug in Ext.some.DerivedClass.method, the typical solution is to create an
override:
Ext.define('App.patches.DerivedClass', {
override: 'Ext.some.DerivedClass',
method: function () {
console.log('Fixed');
// ... logic but with bug fixed ...
this.callSuper();
}
});
The patch method cannot use method-callParent to call the superclass
method since that would call the overridden method containing the bug. In
other words, the above patch would only produce "Fixed" then "Good" in the
console log, whereas, using callParent would produce "Fixed" then "Bad"
then "Good".
args :
Array/Arguments
The arguments, either an array or the arguments object
from the current method, for example: this.callSuper(arguments)
:
Object
Returns the result of calling the superclass method
Collects unique values for a particular dataIndex from this store.
Note that the filtered option can also be passed as a separate parameter for
compatibility with previous versions.
var store = Ext.create('Ext.data.Store', {
fields: ['name'],
data: [{
name: 'Larry'
}, {
name: 'Darryl'
}, {
name: 'Darryl'
}]
});
store.collect('name');
// returns ["Larry", "Darryl"]
includeOptions :
Object
(optional)
An object which contains options which modify how
the store is traversed. For compatibility, this argument may be the allowNull
value itself. If so, the next argument is the filtered value.
allowNull :
Boolean
(optional)
Pass true to allow null, undefined or
empty string values.
filtered :
Boolean
(optional)
Pass true to collect from all records,
even ones which are filtered.
filtered :
Boolean
(optional)
This argument only applies when the legacy call form
is used and includeOptions is actually the allowNull value.
:
Object[]
An array of the unique values
Gets the count of items in the store.
When store is filtered, only items within the filter are counted.
grouped :
Boolean
(optional)
True to perform the operation for each group
in the store. The value returned will be an object literal with the key being the group
name and the count for each group being the value. The grouped parameter is only honored if
the store has a groupField.
:
Number
Converts a literal to a model, if it's not a model already
record :
Ext.data.Model/Object
:
Ext.data.Model
This method is called to cleanup an object and its resources. After calling
this method, the object should not be used any further in any way, including
access to its methods and properties.
To prevent potential memory leaks, all object references will be nulled
at the end of destruction sequence, unless clearPropertiesOnDestroy
is set to false.
Destroys member properties by name.
If a property name is the name of a config, the getter is not invoked, so
if the config has not been initialized, nothing will be done.
The property will be destroyed, and the corrected name (if the property is a config
and config names are prefixed) will set to null in this object's dictionary.
args :
String...
One or more names of the properties to destroy and remove from the object.
Calls the specified function for each Ext.data.Model in the store.
When store is filtered, only loops over the filtered records.
fn :
Function
The function to call. The Ext.data.Model is passed as the first parameter.
Returning false aborts and exits the iteration.
scope :
Object
(optional)
The scope (this reference) in which the function is executed.
Defaults to the current Ext.data.Model in the iteration.
includeOptions :
Object/Boolean
(optional)
An object which contains options which
modify how the store is traversed. Or simply the filtered option.
filtered :
Boolean
(optional)
Pass true to include filtered out
nodes in the iteration.
Convenience function for getting the first model instance in the store.
When store is filtered, will return first item within the filter.
grouped :
Boolean
(optional)
True to perform the operation for each group
in the store. The value returned will be an object literal with the key being the group
name and the first record being the value. The grouped parameter is only honored if
the store has a groupField.
:
Ext.data.Model/undefined
The first model instance in the store, or undefined
Get the Record with the specified id.
This method is not affected by filtering, lookup will be performed from all records
inside the store, filtered or not.
id :
Mixed
The id of the Record to find.
:
Ext.data.Model
The Record with the passed id. Returns null if not found.
Get the Record with the specified internalId.
This method is not affected by filtering, lookup will be performed from all records
inside the store, filtered or not.
internalId :
Mixed
The id of the Record to find.
:
Ext.data.Model
The Record with the passed internalId. Returns null if not found.
Returns a specified config property value. If the name parameter is not passed,
all current configuration options will be returned as key value pairs.
name :
String
(optional)
The name of the config property to get.
peek :
Boolean
(optional)
true to peek at the raw value without calling the getter.
Defaults to: false
ifInitialized :
Boolean
(optional)
true to only return the initialized property value,
not the raw config value, and not to trigger initialization. Returns undefined if the
property has not yet been initialized.
Defaults to: false
:
Object
The config property value.
Returns the complete unfiltered collection.
Returns the initial configuration passed to the constructor when
instantiating this class.
Given this example Ext.button.Button definition and instance:
Ext.define('MyApp.view.Button', {
extend: 'Ext.button.Button',
xtype: 'mybutton',
scale: 'large',
enableToggle: true
});
var btn = Ext.create({
xtype: 'mybutton',
renderTo: Ext.getBody(),
text: 'Test Button'
});
Calling btn.getInitialConfig() would return an object including the config
options passed to the create method:
xtype: 'mybutton',
renderTo: // The document body itself
text: 'Test Button'
Calling btn.getInitialConfig('text')returns 'Test Button'.
name :
String
(optional)
Name of the config option to return.
:
Object/Mixed
The full config object or a single config value
when name parameter specified.
Get the index of the record within the store.
When store is filtered, records outside of filter will not be found.
record :
Ext.data.Model
The Ext.data.Model object to find.
:
Number
The index of the passed Record. Returns -1 if not found.
Get the index within the store of the Record with the passed id.
Like #indexOf, this method is affected by filtering.
id :
String
The id of the Record to find.
:
Number
The index of the Record. Returns -1 if not found.
Initialize configuration for this class. a typical example:
Ext.define('My.awesome.Class', {
// The default config
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'
:
Ext.Base
Inserts Model instances into the Store at the given index and fires the add event.
See also method-add.
index :
Number
The start index at which to insert the passed Records.
records :
Ext.data.Model/Ext.data.Model[]/Object/Object[]
An Ext.data.Model instance, the
data needed to populate an instance or an array of either of these.
:
Ext.data.Model[]
records The added records
Convenience function for getting the last model instance in the store.
When store is filtered, will return last item within the filter.
grouped :
Boolean
(optional)
True to perform the operation for each group
in the store. The value returned will be an object literal with the key being the group
name and the last record being the value. The grouped parameter is only honored if
the store has a groupField.
:
Ext.data.Model/undefined
The last model instance in the store, or undefined
Adds a "destroyable" object to an internal list of objects that will be destroyed
when this instance is destroyed (via destroy).
:
Object
Gets the maximum value in the store.
When store is filtered, only items within the filter are aggregated.
grouped :
Boolean
(optional)
True to perform the operation for each group
in the store. The value returned will be an object literal with the key being the group
name and the maximum in the group being the value. The grouped parameter is only honored if
the store has a groupField.
:
Object
The maximum value, if no items exist, undefined.
Gets the minimum value in the store.
When store is filtered, only items within the filter are aggregated.
grouped :
Boolean
(optional)
True to perform the operation for each group
in the store. The value returned will be an object literal with the key being the group
name and the minimum in the group being the value. The grouped parameter is only honored if
the store has a groupField.
:
Object
The minimum value, if no items exist, undefined.
Query all the cached records in this Store by name/value pair.
The parameters will be used to generated a filter function that is given
to the queryBy method.
This method complements queryBy by generating the query function automatically.
This method is not affected by filtering, it will always search all records in the store
regardless of filtering.
property :
String
The property to create the filter function for
value :
String/RegExp
The string/regex to compare the property value to
anyMatch :
Boolean
(optional)
True to match any part of the string, not just the
beginning.
Defaults to: false
caseSensitive :
Boolean
(optional)
true to create a case-sensitive regex.
Defaults to: false
exactMatch :
Boolean
(optional)
True to force exact match (^ and $ characters
added to the regex). Ignored if anyMatch is true.
Defaults to: false
:
Ext.util.Collection
Query all the cached records in this Store using a filtering function. The specified function
will be called with each record in this Store. If the function returns true the record is
included in the results.
This method is not affected by filtering, it will always search all records in the store
regardless of filtering.
fn :
Function
The function to be called. It will be passed the following parameters:
id :
Object
The ID of the Record passed.
scope :
Object
(optional)
The scope (this reference) in which the function is executed
Defaults to this Store.
:
Ext.util.Collection
Query all the cached records in this Store by field.
This method is not affected by filtering, it will always search all records in the store
regardless of filtering.
field :
String
The field from each record to use.
:
Ext.data.Model[]
Query all the cached records in this Store using a filtering function. The specified function
will be called with each record in this Store. If the function returns true the record is
included in the results.
This method is not affected by filtering, it will always search all records in the store
regardless of filtering.
fn :
Function
The function to be called. It will be passed the following parameters:
scope :
Object
(optional)
The scope (this reference) in which the function is executed
Defaults to this Store.
:
Ext.data.Model[]
Sets a single/multiple configuration options.
name :
String/Object
The name of the property to set, or a set of key value pairs to set.
value :
Object
(optional)
The value to set for the name parameter.
:
Ext.Base
Get the reference to the class from which this object was instantiated. Note that unlike Ext.Base#self,
this.statics() is scope-independent and it always returns the class from which it was called, regardless of what
this points to during run-time
Ext.define('My.Cat', {
statics: {
totalCreated: 0,
speciesName: 'Cat' // My.Cat.speciesName = 'Cat'
},
constructor: function() {
var statics = this.statics();
alert(statics.speciesName); // always equals to 'Cat' no matter what 'this' refers to
// equivalent to: My.Cat.speciesName
alert(this.self.speciesName); // dependent on 'this'
statics.totalCreated++;
},
clone: function() {
var cloned = new this.self(); // dependent on 'this'
cloned.groupName = this.statics().speciesName; // equivalent to: 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', then alerts 'Cat'
var snowLeopard = new My.SnowLeopard(); // alerts 'Cat', then alerts '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.Class
Sums the value of field for each Ext.data.Model in store
and returns the result.
When store is filtered, only sums items within the filter.
grouped :
Boolean
(optional)
True to perform the operation for each group
in the store. The value returned will be an object literal with the key being the group
name and the sum for that group being the value. The grouped parameter is only honored if
the store has a groupField.
:
Number
Destroys a given set of linked objects. This is only needed if
the linked object is being destroyed before this instance.
names :
String[]
The names of the linked objects to destroy.
:
Ext.Base
Static Methods
Adds new config properties to this class. This is called for classes when they
are declared, then for any mixins that class may define and finally for any
overrides defined that target the class.
mixinClass :
Ext.Class
(optional)
The mixin class if the configs are from a mixin.
Add methods / properties to the prototype of this class.
Ext.define('My.awesome.Cat', {
constructor: function() {
...
}
});
My.awesome.Cat.addMembers({
meow: function() {
alert('Meowww...');
}
});
var kitty = new My.awesome.Cat();
kitty.meow();
members :
Object
The members to add to this class.
isStatic :
Boolean
(optional)
Pass true if the members are static.
Defaults to: false
privacy :
Boolean
(optional)
Pass true if the members are private. This
only has meaning in debug mode and only for methods.
Defaults to: false
:
Add / override static properties of this class.
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() { ... };
});
:
Ext.Base
Borrow another class' members to the prototype of this class.
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 '$$$$$$$'
fromClass :
Ext.Base
The class to borrow members from
members :
Array/String
The names of the members to borrow
:
Ext.Base
Create a new instance of this Class.
Ext.define('My.cool.Class', {
...
});
My.cool.Class.create({
someConfig: true
});
All parameters are passed to the constructor of the class.
:
Object
Create aliases for existing prototype methods. Example:
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()
alias :
String/Object
The new method name, or an object to set multiple aliases. See
flexSetter
Get the current class' name in string format.
Ext.define('My.cool.Class', {
constructor: function() {
alert(this.self.getName()); // alerts 'My.cool.Class'
}
});
My.cool.Class.getName(); // 'My.cool.Class'
:
String
Used internally by the mixins pre-processor
:
Override members of this class. Overridden methods can be invoked via
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"
Direct use of this method should be rare. Use Ext.define
instead:
Ext.define('My.CatOverride', {
override: 'My.Cat',
constructor: function() {
alert("I'm going to be a cat!");
this.callParent(arguments);
alert("Meeeeoooowwww");
}
});
The above accomplishes the same result but can be managed by the Ext.Loader
which can properly order the override and its target class and the build process
can determine whether the override is needed based on the required state of the
target class (My.Cat).
members :
Object
The properties to add to this class. This should be
specified as an object literal containing one or more properties.
:
Ext.Base
Ext JS | Terms of Use
