Class CoreObject

public
Defined in: packages/@ember/-internals/runtime/lib/system/core_object.js:249
Module: @ember/object

CoreObject is the base class for all Ember constructs. It establishes a class system based on Ember's Mixin system, and provides the basis for the Ember Object Model. CoreObject should generally not be used directly, instead you should use EmberObject.

Usage

You can define a class by extending from CoreObject using the extend method:

1
2
3

const Person = CoreObject.extend({
  name: 'Tomster',
});

For detailed usage, see the Object Model section of the guides.

Usage with Native Classes

Native JavaScript class syntax can be used to extend from any CoreObject based class:

1
2
3
4
5
6

class Person extends CoreObject {
  init() {
    super.init(...arguments);
    this.name = 'Tomster';
  }
}

Some notes about class usage:

  • new syntax is not currently supported with classes that extend from EmberObject or CoreObject. You must continue to use the create method when making new instances of classes, even if they are defined using native class syntax. If you want to use new syntax, consider creating classes which do not extend from EmberObject or CoreObject. Ember features, such as computed properties and decorators, will still work with base-less classes.
  • Instead of using this._super(), you must use standard super syntax in native classes. See the MDN docs on classes for more details.
  • Native classes support using constructors to set up newly-created instances. Ember uses these to, among other things, support features that need to retrieve other entities by name, like Service injection and getOwner. To ensure your custom instance setup logic takes place after this important work is done, avoid using the constructor in favor of init.
  • Properties passed to create will be available on the instance by the time init runs, so any code that requires these values should work at that time.
  • Using native classes, and switching back to the old Ember Object model is fully supported.

Show:

concatenatedProperties public

Module: @ember/object

Defined in packages/@ember/-internals/runtime/lib/system/core_object.js:428

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 Component from @ember/component.

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
14
15
16
17
18

import EmberObject from '@ember/object';

const Bar = EmberObject.extend({
  // Configure which properties to concatenate
  concatenatedProperties: ['concatenatedProperty'],

  someNonConcatenatedProperty: ['bar'],
  concatenatedProperty: ['bar']
});

const FooBar = Bar.extend({
  someNonConcatenatedProperty: ['foo'],
  concatenatedProperty: ['foo']
});

let fooBar = FooBar.create();
fooBar.get('someNonConcatenatedProperty'); // ['foo']
fooBar.get('concatenatedProperty'); // ['bar', 'foo']

This behavior extends to object creation as well. Continuing the above example:

1
2
3
4
5
6

let fooBar = FooBar.create({
  someNonConcatenatedProperty: ['baz'],
  concatenatedProperty: ['baz']
})
fooBar.get('someNonConcatenatedProperty'); // ['baz']
fooBar.get('concatenatedProperty'); // ['bar', 'foo', 'baz']

Adding a single property that is not an array will just add it in the array:

1
2
3
4

let fooBar = FooBar.create({
  concatenatedProperty: 'baz'
})
view.get('concatenatedProperty'); // ['bar', 'foo', 'baz']

Using the concatenatedProperties property, we can tell Ember to mix the content of the properties.

In Component the classNames, classNameBindings and attributeBindings properties are concatenated.

This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently. Since it changes expectations about behavior of properties, you should properly document its usage in each individual concatenated property (to not mislead your users to think they can override the property in a subclass).

isDestroyed public

Module: @ember/object

Defined in packages/@ember/-internals/runtime/lib/system/core_object.js:577

Destroyed object property flag.

if this property is true the observers and bindings were already removed by the effect of calling the destroy() method.

isDestroying public

Module: @ember/object

Defined in packages/@ember/-internals/runtime/lib/system/core_object.js:595

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.

mergedProperties public

Module: @ember/object

Defined in packages/@ember/-internals/runtime/lib/system/core_object.js:502

Defines the properties that will be merged 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 merging the superclass property value with the subclass property's value. An example of this in use within Ember is the queryParams property of routes.

Here is some sample code showing the difference between a merged property and a normal one:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

import EmberObject from '@ember/object';

const Bar = EmberObject.extend({
  // Configure which properties are to be merged
  mergedProperties: ['mergedProperty'],

  someNonMergedProperty: {
    nonMerged: 'superclass value of nonMerged'
  },
  mergedProperty: {
    page: { replace: false },
    limit: { replace: true }
  }
});

const FooBar = Bar.extend({
  someNonMergedProperty: {
    completelyNonMerged: 'subclass value of nonMerged'
  },
  mergedProperty: {
    limit: { replace: false }
  }
});

let fooBar = FooBar.create();

fooBar.get('someNonMergedProperty');
// => { completelyNonMerged: 'subclass value of nonMerged' }
//
// Note the entire object, including the nonMerged property of
// the superclass object, has been replaced

fooBar.get('mergedProperty');
// => {
//   page: {replace: false},
//   limit: {replace: false}
// }
//
// Note the page remains from the superclass, and the
// `limit` property's value of `false` has been merged from
// the subclass.

This behavior is not available during object create calls. It is only available at extend time.

In Route the queryParams property is merged.

This feature is available for you to use throughout the Ember object model, although typical app developers are likely to use it infrequently. Since it changes expectations about behavior of properties, you should properly document its usage in each individual merged property (to not mislead your users to think they can override the property in a subclass).