About Utilities

Ext provides a series of general utility functions for working with Javascript and JSON. They vary in their functionality, but all of them aim to make your life as the developer easier.

apply and applyIf

apply
The apply function is used to copy the properties of one object literal to another. The first argument is the destination object. The second argument is the source to copy from. Note that all properties in the source will be copied over, even if they exists in the destination. Also, the destination object will be modified as a result of calling the method.
```
var person = {
    name: 'John Smith',
    age: 30
};

Ext.apply(person, {
    hobby: 'Coding',
    city: 'London'
}); // person literal now contains hobby and city as well
```
applyIf
This function is very similar to apply. The only difference is that applyIf only copies properties that don't exist in the destination object. If they already exist in both, the destination object takes precedence and the property is not copied.
```
var person = {
    name: 'John Smith',
    age: 30,
    hobby: 'Rock Band'
};

Ext.applyIf(person, {
    hobby: 'Coding',
    city: 'London'
}); // hobby is not copied over
```

Url Encoding/Decoding

These methods are useful for transforming JSON data to a format that can be transmitted as part of a GET string and vice versa.

urlEncode
Converts an object-literal into a string that can be passed as a parameter using a GET request. The string will be in the format key1=value1&key2=value2....
```
var params = {
    foo: 'value1',
    bar: 100
};

var s = Ext.encode(params); // s is now foo=value1&bar=100
```
urlDecode
This method is the opposite of urlEncode. It takes a string in the form of key1=value1&key2=value and converts it into a JavaScript object.
```
var s = 'foo=value1&bar=100';
var o = Ext.decode(s); // o now contains 2 properties, foo and bar.
alert(o.bar);
```

Array Handling

The core provides methods for working with arrays and other collections within Javascript.

each
The each method allows you to iterate over an array or other collections (including Nodelists or CompositeElements). eac takes a function as the first argument. This function is called for each member in the collection. Returning false at any point stops iteration.
```
Ext.each([1, 2, 3, 4, 5], function(num){
    alert(num);
});
```

toArray

This method converts an iterable collection (or single element) into an proper javascript array.

var arr1 = Ext.toArray(1); // arr1 = [1];
// arr2 now contains an array of Ext elements.
var arr2 = Ext.toArray(Ext.select('div));

JSON

JSON stands for Javascript Object Notation. It is used as a data exchange format, where the data looks very similar to javascript object literals. When sending and retrieving data from the server, it is necessary to convert data to and from it's native javascript form. These helper functions assist you to do this. More information about JSON can be found at json.org.

encode
Takes a javascript object or array and encodes it as the string representation of the JSON that can be passed to an external source.
```
var s = Ext.encode({
    foo: 1,
    bar: 2
}); //s now contains '{foo=1,bar=2}'
```
decode
The opposite of encode, this is used to convert the string representation of JSON into a javascript object. This method is often called when reading the response from an Ajax callback.
```
var s = '{foo=1,bar=2}';
var o = Ext.decode(s); o is now an object with 2 properties, foo and bar.
```

Browser & OS Detection

JavaScript

Ext offers a number of browser-detection features allowing developers to work around implementation issues due to differences between the major browsers. Ext provides detection in both javascript and css, to allow for greater functionality in both these areas.

The following browser detection is available for javascript:

Internet Explorer - Ext.isIE, Ext.isIE6, Ext.isIE7, Ext.isIE8
Firefox - Ext.isGecko, Ext.isGecko2, Ext.isGecko3
Opera - Ext.isOpera
Chrome - Ext.isChrome
Safari - Ext.isSafari, Ext.isSafari2, Ext.isSafari3
WebKit - Ext.isWebKit
Operating Systems - Ext.isLinux, Ext.isWindows, Ext.isMac

if(Ext.isIE){
    // Do browser specific code here
}

CSS

A similar mechanism is applied in the CSS, various class names are added to the root element and the body depending on the current operating environment. This allows for easier style rules to get around browser quirks. If in strict mode, ext-strict is added to the root. The rest of these are added to the body when appropriate:

.ext-ie, .ext-ie6, .ext-ie7, .ext-ie8
.ext-gecko, .ext-gecko2, .ext-gecko3
.ext-opera
.ext-safari
.ext-chrome
.ext-mac, .ext-linux

/* When in strict mode and using safari, change the font-size. */
.ext-strict .ext-safari .sample-item{
    font-size: 20px; 
}

Type Detection

Since JavaScript is a loosely typed language, it is often necessary to interrogate variables to retrieve their type. Ext provides a series of methods for help in this regard:

isEmpty
Checks whether the passed value is empty, which includes undefined, null or an empty string.
```
alert(Ext.isEmpty(''));
```
isArray
Checks whether the passed value is an array.
```
alert(Ext.isArray([1, 2, 3]));
```
isObject
Checks whether the passed value is an object.
```
alert(Ext.isObject({}));
```
isFunction
Checks whether the passed value is a function.
```
alert(Ext.isFunction(function(){
}));
```

Miscellaneous

id
Returns a string that contains a unique identifier. Any call to Ext.id() is guaranteed to return a new id that hasn't been used. The first parameter is an optional element, which the id is to be assigned to. The second optional parameter is a prefix for the id.
```
var s = Ext.id(null, 'prefix'); // No element specified here
var s = Ext.id(Ext.get(document.body)); // Assign the id to an element
```