Ember Namespace

Alias for jQuery

Creates an Ember.NativeArray from an Array like object. Does not modify the original object.

Add an event listener

Makes a method available via an additional name.

1
2
3
4
5
6
7
8

App.Person = Ember.Object.extend({
  name: function(){
    return 'Tomhuda Katzdale';
  },
  moniker: Ember.aliasMethod('name')
});

var goodGuy = App.Person.create()

Define an assertion that will throw an exception if the condition is not met. Ember build tools will remove any calls to Ember.assert() when doing a production build. Example:

1
2
3
4

// Test for truthiness
Ember.assert('Must pass a valid object', obj);
// Fail unconditionally
Ember.assert('This code path should never be run')

Global helper method to create a new binding. Just pass the root object along with a to and from path to create and connect the binding.

Returns the cached value for a property, if one exists. This can be useful for peeking at the value of a computed property that is generated lazily, without accidentally causing it to be created.

Checks to see if the methodName exists on the obj.

Make a series of property changes together in an exception-safe way.

1
2
3
4

Ember.changeProperties(function() {
  obj1.set('foo', mayBlowUpWhenSet);
  obj2.set('bar', baz);
});

This will compare two javascript values of possibly different types. It will tell you which one is greater than the other by returning:

• -1 if the first is smaller than the second,
• 0 if both are equal,
• 1 if the first is greater than the second.

The order is calculated based on Ember.ORDER_DEFINITION, if types are different. In case they have the same type an appropriate comparison for this type is made.

1
2
3

 Ember.compare('hello', 'hello');  // 0
 Ember.compare('abc', 'dfg');      // -1
 Ember.compare(2, 1);              // 1

This helper returns a new property descriptor that wraps the passed computed property function. You can use this helper to define properties with mixins or via Ember.defineProperty().

The function you pass will be used to both get and set property values. The function should accept two parameters, key and value. If value is not undefined you should set the value first. In either case return the current value of the property.

Creates a clone of the passed object. This function can take just about any type of object and create a clone of it, including primitive values (which are not actually cloned because they are immutable).

If the passed object implements the clone() method, then this function will simply call that method and return the result.

Identical to Object.create(). Implements if not available natively.

Display a debug notice. Ember build tools will remove any calls to Ember.debug() when doing a production build.

1

Ember.debug("I'm a debug notice!");

Display a deprecation warning with the provided message and a stack trace (Chrome and Firefox only). Ember build tools will remove any calls to Ember.deprecate() when doing a production build.

Display a deprecation warning with the provided message and a stack trace (Chrome and Firefox only) when the wrapped method is called.

Ember build tools will not remove calls to Ember.deprecateFunc(), though no warnings will be shown in production.

Tears down the meta on an object so that it can be garbage collected. Multiple calls will have no effect.

Gets the value of a property on an object. If the property is computed, the function will be invoked. If the property is not defined but the object implements the unknownProperty method then that will be invoked.

If you plan to run on IE8 and older browsers then you should use this method anytime you want to retrieve a property on an object that you don't know for sure is private. (Properties beginning with an underscore '_' are considered private.)

On all newer browsers, you only need to use this method to retrieve properties if the property might not be defined on the object and you want to respect the unknownProperty handler. Otherwise you can ignore this method.

Note that if the object itself is undefined, this method will throw an error.

Convenience method to inspect an object. This method will attempt to convert the object into a useful string description.

It is a pretty simple implementation. If you want something more robust, use something like JSDump: https://github.com/NV/jsDump

Returns true if the passed object is an array or Array-like.

Ember Array Protocol:

• the object has an objectAt property
• the object is a native Array
• the object is an Object, and has a length property

Unlike Ember.typeOf this method returns true even if the passed object is not formally array but appears to be array-like (i.e. implements Ember.Array)

1
2
3

Ember.isArray();                                            // false
Ember.isArray([]);                                          // true
Ember.isArray( Ember.ArrayProxy.create({ content: [] }) );  // true

Verifies that a value is null or an empty string, empty array, or empty function.

Constrains the rules on Ember.isNone by returning false for empty string and empty arrays.

1
2
3
4
5
6
7

Ember.isEmpty();                // true
Ember.isEmpty(null);            // true
Ember.isEmpty(undefined);       // true
Ember.isEmpty('');              // true
Ember.isEmpty([]);              // true
Ember.isEmpty('Adam Hawkins');  // false
Ember.isEmpty([0,1,2]);         // false

Compares two objects, returning true if they are logically equal. This is a deeper comparison than a simple triple equal. For sets it will compare the internal objects. For any other object that implements isEqual() it will respect that method.

1
2
3

Ember.isEqual('hello', 'hello');  // true
Ember.isEqual(1, 2);              // false
Ember.isEqual([4,2], [4,2]);      // false

Returns true if the passed value is null or undefined. This avoids errors from JSLint complaining about use of ==, which can be technically confusing.

1
2
3
4
5
6

Ember.isNone();              // true
Ember.isNone(null);          // true
Ember.isNone(undefined);     // true
Ember.isNone('');            // false
Ember.isNone([]);            // false
Ember.isNone(function(){});  // false

Returns all of the keys defined on an object or hash. This is useful when inspecting objects for debugging. On browsers that support it, this uses the native Object.keys implementation.

Forces the passed object to be part of an array. If the object is already an array or array-like, returns the object. Otherwise adds the object to an array. If obj is null or undefined, returns an empty array.

1
2
3
4
5
6
7
8

Ember.makeArray();                           // []
Ember.makeArray(null);                       // []
Ember.makeArray(undefined);                  // []
Ember.makeArray('lindsay');                  // ['lindsay']
Ember.makeArray([1,2,42]);                   // [1,2,42]

var controller = Ember.ArrayProxy.create({ content: [] });
Ember.makeArray(controller) === controller;  // true

This function is called just after an object property has changed. It will notify any observers and clear caches among other things.

Normally you will not need to call this method directly but if for some reason you can't directly watch a property you can invoke this method manually along with Ember.propertyWilLChange() which you should call just before the property value changes.

This function is called just before an object property is about to change. It will notify any before observers and prepare caches among other things.

Normally you will not need to call this method directly but if for some reason you can't directly watch a property you can invoke this method manually along with Ember.propertyDidChange() which you should call just after the property value changes.

Remove an event listener

Arguments should match those passed to {{#crossLink "Ember/addListener"}}{{/crossLink}}

Denotes a required property for a mixin

Sets the value of a property on an object, respecting computed properties and notifying observers and other listeners of the change. If the property is not defined but the object implements the unknownProperty method then that will be invoked as well.

If you plan to run on IE8 and older browsers then you should use this method anytime you want to set a property on an object that you don't know for sure is private. (Properties beginning with an underscore '_' are considered private.)

On all newer browsers, you only need to use this method to set properties if the property might not be defined on the object and you want to respect the unknownProperty handler. Otherwise you can ignore this method.

Set a list of properties on an object. These properties are set inside a single beginPropertyChanges and endPropertyChanges batch, so observers will be buffered.

Provides try { } catch finally { } functionality, while working around Safari's double finally bug.

Provides try { } finally { } functionality, while working around Safari's double finally bug.

Checks to see if the methodName exists on the obj, and if it does, invokes it with the arguments passed.

Error-tolerant form of Ember.set. Will not blow up if any part of the chain is undefined, null, or destroyed.

This is primarily used when syncing bindings, which may try to update after an object has been destroyed.

Returns a consistent type for the passed item.

Use this instead of the built-in typeof to get the type of an item. It will return the same result across all browsers and includes a bit more detail. Here is what will be returned:

1
2
3
4
5
6
7
8
9
10
11
12
13

| Return Value  | Meaning                                              |
|---------------|------------------------------------------------------|
| 'string'      | String primitive                                     |
| 'number'      | Number primitive                                     |
| 'boolean'     | Boolean primitive                                    |
| 'null'        | Null value                                           |
| 'undefined'   | Undefined value                                      |
| 'function'    | A function                                           |
| 'array'       | An instance of Array                                 |
| 'class'       | An Ember class (created using Ember.Object.extend()) |
| 'instance'    | An Ember object instance                             |
| 'error'       | An instance of the Error object                      |
| 'object'      | A JavaScript object not inheriting from Ember.Object |

Examples:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Ember.typeOf();                       // 'undefined'
Ember.typeOf(null);                   // 'null'
Ember.typeOf(undefined);              // 'undefined'
Ember.typeOf('michael');              // 'string'
Ember.typeOf(101);                    // 'number'
Ember.typeOf(true);                   // 'boolean'
Ember.typeOf(Ember.makeArray);        // 'function'
Ember.typeOf([1,2,90]);               // 'array'
Ember.typeOf(Ember.Object.extend());  // 'class'
Ember.typeOf(Ember.Object.create());  // 'instance'
Ember.typeOf(new Error('teamocil'));  // 'error'

// "normal" JavaScript object
Ember.typeOf({a: 'b'});              // 'object'

Display a warning with the provided message. Ember build tools will remove any calls to Ember.warn() when doing a production build.