Clear Up
SharpKit Reference

Function Class

Namespace: Ext

Base Types

System.Object

Constructors

Name Description
Function()

Methods

Name Description
alias(object, JsString) Create an alias to the provided method property with name `methodName` of `object`. Note that the execution scope will still be bound to the provided `object` itself. * @param {Object/Function} object @param {String} methodName @return {Function} aliasFn
bind(JsAction, object, JsArray, object) Create a new function from the provided `fn`, change `this` to the provided scope, optionally overrides arguments for the call. (Defaults to the arguments passed by the caller) * {@link Ext#bind Ext.bind} is alias for {@link Ext.Function#bind Ext.Function.bind} * @param {Function} fn The function to delegate. @param {Object} scope (optional) The scope (`this` reference) in which the function is executed. **If omitted, defaults to the browser window.** @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller) @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position @return {Function} The new function
clone(JsAction) Create a "clone" of the provided method. The returned method will call the given method passing along all arguments and the "this" pointer and return its result. * @param {Function} method @return {Function} cloneFn
createBuffered(JsAction, JsNumber, object, JsArray) Creates a delegate function, optionally with a bound scope which, when called, buffers the execution of the passed function for the configured number of milliseconds. If called again within that period, the impending invocation will be canceled, and the timeout period will begin again. * @param {Function} fn The function to invoke on a buffered timer. @param {Number} buffer The number of milliseconds by which to buffer the invocation of the function. @param {Object} scope (optional) The scope (`this` reference) in which the passed function is executed. If omitted, defaults to the scope specified by the caller. @param {Array} args (optional) Override arguments for the call. Defaults to the arguments passed by the caller. @return {Function} A function which invokes the passed function after buffering for the specified time.
createDelayed(JsAction, JsNumber, object, JsArray, object) Creates a delegate (callback) which, when called, executes after a specific delay. * @param {Function} fn The function which will be called on a delay when the returned function is called. Optionally, a replacement (or additional) argument list may be specified. @param {Number} delay The number of milliseconds to defer execution by whenever called. @param {Object} scope (optional) The scope (`this` reference) used by the function at execution time. @param {Array} args (optional) Override arguments for the call. (Defaults to the arguments passed by the caller) @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position. @return {Function} A function which, when called, executes the original function after the specified delay.
createInterceptor(JsAction, JsAction, object, object) Creates an interceptor function. The passed function is called before the original one. If it returns false, the original one is not called. The resulting function returns the results of the original function. The passed function is called with the parameters of the original function. Example usage: * var sayHi = function(name){ alert('Hi, ' + name); } * sayHi('Fred'); // alerts "Hi, Fred" * // create a new function that validates input without // directly modifying the original function: var sayHiToFriend = Ext.Function.createInterceptor(sayHi, function(name){ return name == 'Brian'; }); * sayHiToFriend('Fred'); // no alert sayHiToFriend('Brian'); // alerts "Hi, Brian" * @param {Function} origFn The original function. @param {Function} newFn The function to call before the original @param {Object} scope (optional) The scope (`this` reference) in which the passed function is executed. **If omitted, defaults to the scope in which the original function is called or the browser window.** @param {Object} returnValue (optional) The value to return if the passed function return false (defaults to null). @return {Function} The new function
createSequence(JsAction, JsAction, object) Create a combined function call sequence of the original function + the passed function. The resulting function returns the results of the original function. The passed function is called with the parameters of the original function. Example usage: * var sayHi = function(name){ alert('Hi, ' + name); } * sayHi('Fred'); // alerts "Hi, Fred" * var sayGoodbye = Ext.Function.createSequence(sayHi, function(name){ alert('Bye, ' + name); }); * sayGoodbye('Fred'); // both alerts show * @param {Function} originalFn The original function. @param {Function} newFn The function to sequence @param {Object} scope (optional) The scope (`this` reference) in which the passed function is executed. If omitted, defaults to the scope in which the original function is called or the browser window. @return {Function} The new function
createThrottled(JsAction, JsNumber, object) Creates a throttled version of the passed function which, when called repeatedly and rapidly, invokes the passed function only after a certain interval has elapsed since the previous invocation. * This is useful for wrapping functions which may be called repeatedly, such as a handler of a mouse move event when the processing is expensive. * @param {Function} fn The function to execute at a regular time interval. @param {Number} interval The interval **in milliseconds** on which the passed function is executed. @param {Object} scope (optional) The scope (`this` reference) in which the passed function is executed. If omitted, defaults to the scope specified by the caller. @returns {Function} A function which invokes the passed function at the specified interval.
defer(JsAction, JsNumber, object, JsArray, object) Calls this function after the number of millseconds specified, optionally in a specific scope. Example usage: * var sayHi = function(name){ alert('Hi, ' + name); } * // executes immediately: sayHi('Fred'); * // executes after 2 seconds: Ext.Function.defer(sayHi, 2000, this, ['Fred']); * // this syntax is sometimes useful for deferring // execution of an anonymous function: Ext.Function.defer(function(){ alert('Anonymous'); }, 100); * {@link Ext#defer Ext.defer} is alias for {@link Ext.Function#defer Ext.Function.defer} * @param {Function} fn The function to defer. @param {Number} millis The number of milliseconds for the setTimeout call (if less than or equal to 0 the function is executed immediately) @param {Object} scope (optional) The scope (`this` reference) in which the function is executed. **If omitted, defaults to the browser window.** @param {Array} args (optional) Overrides arguments for the call. (Defaults to the arguments passed by the caller) @param {Boolean/Number} appendArgs (optional) if True args are appended to call args instead of overriding, if a number the args are inserted at the specified position @return {Number} The timeout id that can be used with clearTimeout
flexSetter(JsAction) A very commonly used method throughout the framework. It acts as a wrapper around another method which originally accepts 2 arguments for `name` and `value`. The wrapped function then allows "flexible" value setting of either: * - `name` and `value` as 2 arguments - one single object argument with multiple key - value pairs * For example: * var setValue = Ext.Function.flexSetter(function(name, value) { this[name] = value; }); * // Afterwards // Setting a single name - value setValue('name1', 'value1'); * // Settings multiple name - value pairs setValue({ name1: 'value1', name2: 'value2', name3: 'value3' }); * @param {Function} setter @returns {Function} flexSetter
interceptAfter(object, object, object)
interceptBefore(object, object, object)
pass(JsAction, JsArray, object) Create a new function from the provided `fn`, the arguments of which are pre-set to `args`. New arguments passed to the newly created callback when it's invoked are appended after the pre-set ones. This is especially useful when creating callbacks. * For example: * var originalFunction = function(){ alert(Ext.Array.from(arguments).join(' ')); }; * var callback = Ext.Function.pass(originalFunction, ['Hello', 'World']); * callback(); // alerts 'Hello World' callback('by Me'); // alerts 'Hello World by Me' * {@link Ext#pass Ext.pass} is alias for {@link Ext.Function#pass Ext.Function.pass} * @param {Function} fn The original function @param {Array} args The arguments to pass to new callback @param {Object} scope (optional) The scope (`this` reference) in which the function is executed. @return {Function} The new callback function
© Copyright 2005-2011 SharpKit. All rights reserved.