Ember.CoreObject Class packages/ember-runtime/lib/system/core_object.js:519
Defined in: packages/ember-runtime/lib/system/core_object.js:519
Module: ember-runtime
Methods
Properties
_scheduledDestroy
private
destroy
Ember.Object
Destroys an object by setting the isDestroyed flag and removing its
metadata, which effectively destroys observers and bindings.
If you try to set a property on a destroyed object, an exception will be raised.
Note that destruction is scheduled for the end of the run loop and does not happen immediately. It will set an isDestroying flag immediately.
Returns:
- Ember.Object
- receiver
eachComputedProperty
(callback, binding)
Iterate over each computed property for the class, passing its name
and any associated metadata (see metaForProperty) to the callback.
Parameters:
- callback Function
- binding Object
init
An overridable method called when objects are instantiated. By default, does nothing unless it is overridden during class definition.
Example:
1 2 3 4 5 6 7 8 9 10 11 12 |
App.Person = Ember.Object.extend({
init: function() {
this._super();
alert('Name is ' + this.get('name'));
}
});
var steve = App.Person.create({
name: "Steve"
});
// alerts 'Name is Steve'.
|
NOTE: If you do override init for a framework class like Ember.View or
Ember.ArrayController, be sure to call this._super() in your
init declaration! If you don't, Ember may not have an opportunity to
do important setup work, and you'll see strange behavior in your
application.
metaForProperty
(key)
In some cases, you may want to annotate computed properties with additional metadata about how they function or what values they operate on. For example, computed property functions may close over variables that are then no longer available for introspection.
You can pass a hash of these values to a computed property like this:
1 2 3 4 |
person: function() { var personId = this.get('personId'); return App.Person.create({ id: personId }); }.property().meta({ type: App.Person }) |
Once you've done this, you can retrieve the values saved to the computed property from your class like this:
1 |
MyClass.metaForProperty('person');
|
This will return the original hash that was passed to meta().
Parameters:
- key String
- property name
toString
String
Returns a string representation which attempts to provide more information
than Javascript's toString typically does, in a generic way for all Ember
objects.
1 2 3 |
App.Person = Em.Object.extend()
person = App.Person.create()
person.toString() //=> "<App.Person:ember1024>"
|
If the object's class is not defined on an Ember namespace, it will indicate it is a subclass of the registered superclass:
1 2 3 |
Student = App.Person.extend()
student = Student.create()
student.toString() //=> "<(subclass of App.Person):ember1025>"
|
If the method toStringExtension is defined, its return value will be
included in the output.
1 2 3 4 5 6 7 |
App.Teacher = App.Person.extend({
toStringExtension: function(){
return this.get('fullName');
}
});
teacher = App.Teacher.create()
teacher.toString(); //=> "<App.Teacher:ember1026:Tom Dale>"
|
Returns:
- String
- string representation
concatenatedProperties
Array
Defines the properties that will be concatenated from the superclass (instead of overridden).
By default, when you extend an Ember class a property defined in
the subclass overrides a property with the same name that is defined
in the superclass. However, there are some cases where it is preferable
to build up a property's value by combining the superclass' property
value with the subclass' value. An example of this in use within Ember
is the classNames property of Ember.View.
Here is some sample code showing the difference between a concatenated property and a normal one:
1 2 3 4 5 6 7 8 9 10 11 12 13 |
App.BarView = Ember.View.extend({
someNonConcatenatedProperty: ['bar'],
classNames: ['bar']
});
App.FooBarView = App.BarView.extend({
someNonConcatenatedProperty: ['foo'],
classNames: ['foo'],
});
var fooBarView = App.FooBarView.create();
fooBarView.get('someNonConcatenatedProperty'); // ['foo']
fooBarView.get('classNames'); // ['ember-view', 'bar', 'foo']
|
This behavior extends to object creation as well. Continuing the above example:
1 2 3 4 5 6 |
var view = App.FooBarView.create({ someNonConcatenatedProperty: ['baz'], classNames: ['baz'] }) view.get('someNonConcatenatedProperty'); // ['baz'] view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz'] |
Adding a single property that is not an array will just add it in the array:
1 2 3 4 |
var view = App.FooBarView.create({ classNames: 'baz' }) view.get('classNames'); // ['ember-view', 'bar', 'foo', 'baz'] |
Using the concatenatedProperties property, we can tell to Ember that mix
the content of the properties.
In Ember.View the classNameBindings and attributeBindings properties
are also concatenated, in addition to classNames.
This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently.
Default: null
isDestroyed
Destroyed object property flag.
if this property is true the observers and bindings were already
removed by the effect of calling the destroy() method.
Default: false
isDestroying
Destruction scheduled flag. The destroy() method has been called.
The object stays intact until the end of the run loop at which point
the isDestroyed flag is set.
Default: false
Fork Us!