functions

Classes


Public Protected Private

Global Functions

goog.functions.FALSE()
Always returns false.
code »
goog.functions.NULL()
Always returns NULL.
code »
goog.functions.TRUE()
Always returns true.
code »
goog.functions.and(var_args) function(...[?]):boolean
Creates a function that returns true if each of its components evaluates to true. The components are evaluated in order, and the evaluation will be short-circuited as soon as a function returns false. For example, (goog.functions.and(f, g))(x) is equivalent to f(x) && g(x).
Arguments:
var_args : ...Function
A list of functions.
Returns: function(...[?]):boolean  A function that ANDs its component functions.
code »
goog.functions.cacheReturnValue(fn) !function():T
Gives a wrapper function that caches the return value of a parameterless function when first called. When called for the first time, the given function is called and its return value is cached (thus this is only appropriate for idempotent functions). Subsequent calls will return the cached return value. This allows the evaluation of expensive functions to be delayed until first used. To cache the return values of functions with parameters, see goog.memoize.
Arguments:
fn : !function():T
A function to lazily evaluate.
Returns: !function():T  A wrapped version the function.
code »
goog.functions.compose(fnvar_args) function(...[?]):T
Creates the composition of the functions passed in. For example, (goog.functions.compose(f, g))(a) is equivalent to f(g(a)).
Arguments:
fn : function(...[?]):T
The final function.
var_args : ...Function
A list of functions.
Returns: function(...[?]):T  The composition of all inputs.
code »
goog.functions.constant(retValue) function():T
Creates a function that always returns the same value.
Arguments:
retValue : T
The value to return.
Returns: function():T  The new function.
code »
goog.functions.create(constructorvar_args) !Object
Generic factory function to construct an object given the constructor and the arguments. Intended to be bound to create object factories. Callers should cast the result to the appropriate type for proper type checking by the compiler.
Arguments:
constructor : !Function
The constructor for the Object.
var_args : ...*
The arguments to be passed to the constructor.
Returns: !Object  A new instance of the class given in constructor.
code »
goog.functions.error(message) !Function
Creates a function that always throws an error with the given message.
Arguments:
message : string
The error message.
Returns: !Function  The error-throwing function.
code »
goog.functions.fail(err) !Function
Creates a function that throws the given object.
Arguments:
err : *
An object to be thrown.
Returns: !Function  The error-throwing function.
code »
goog.functions.identity(opt_returnValuevar_args) T
A simple function that returns the first argument of whatever is passed into it.
Arguments:
opt_returnValue : T=
The single value that will be returned.
var_args : ...*
Optional trailing arguments. These are ignored.
Returns: T  The first argument passed in, or undefined if nothing was passed.
code »
goog.functions.lock(fopt_numArgs) !Function
Given a function, create a function that keeps opt_numArgs arguments and silently discards all additional arguments.
Arguments:
f : Function
The original function.
opt_numArgs : number=
The number of arguments to keep. Defaults to 0.
Returns: !Function  A version of f that only keeps the first opt_numArgs arguments.
code »
goog.functions.not(f) function(...[?]):boolean
Creates a function that returns the Boolean opposite of a provided function. For example, (goog.functions.not(f))(x) is equivalent to !f(x).
Arguments:
f : !Function
The original function.
Returns: function(...[?]):boolean  A function that delegates to f and returns opposite.
code »
goog.functions.nth(n) !Function
Creates a function that returns its nth argument.
Arguments:
n : number
The position of the return argument.
Returns: !Function  A new function.
code »
goog.functions.or(var_args) function(...[?]):boolean
Creates a function that returns true if any of its components evaluates to true. The components are evaluated in order, and the evaluation will be short-circuited as soon as a function returns true. For example, (goog.functions.or(f, g))(x) is equivalent to f(x) || g(x).
Arguments:
var_args : ...Function
A list of functions.
Returns: function(...[?]):boolean  A function that ORs its component functions.
code »
goog.functions.sequence(var_args) !Function
Creates a function that calls the functions passed in in sequence, and returns the value of the last function. For example, (goog.functions.sequence(f, g))(x) is equivalent to f(x),g(x).
Arguments:
var_args : ...Function
A list of functions.
Returns: !Function  A function that calls all inputs in sequence.
code »
goog.functions.withReturnValue(fretValue) function(...[?]):T
Given a function, create a new function that swallows its return value and replaces it with a new one.
Arguments:
f : Function
A function.
retValue : T
A new return value.
Returns: function(...[?]):T  A new function.
code »

Global Properties

goog.functions.CACHE_RETURN_VALUE :
No description.
Code »

Package functions

Package Reference