![]()
Always returns false.
|
code » | |||
![]()
Always returns NULL.
|
code » | |||
![]()
Always returns true.
|
code » | |||
![]()
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:
Returns: function(...[?]):boolean
A function that ANDs its component
functions.
|
code » | |||
![]()
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:
Returns: !function():T
A wrapped version the function.
|
code » | |||
![]()
Creates the composition of the functions passed in.
For example, (goog.functions.compose(f, g))(a) is equivalent to f(g(a)).
Arguments:
Returns: function(...[?]):T
The composition of all inputs.
|
code » | |||
![]()
Creates a function that always returns the same value.
Arguments:
Returns: function():T
The new function.
|
code » | |||
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.
|
code » | |||
Creates a function that always throws an error with the given message.
|
code » | |||
Creates a function that throws the given object.
Arguments:
Returns: !Function
The error-throwing function.
|
code » | |||
![]()
A simple function that returns the first argument of whatever is passed
into it.
Arguments:
Returns: T
The first argument passed in, or undefined if nothing was passed.
|
code » | |||
Given a function, create a function that keeps opt_numArgs arguments and
silently discards all additional arguments.
|
code » | |||
![]()
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:
Returns: function(...[?]):boolean
A function that delegates to f and returns
opposite.
|
code » | |||
Creates a function that returns its nth argument.
|
code » | |||
![]()
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:
Returns: function(...[?]):boolean
A function that ORs its component
functions.
|
code » | |||
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:
Returns: !Function
A function that calls all inputs in sequence.
|
code » | |||
![]()
Given a function, create a new function that swallows its return value
and replaces it with a new one.
Arguments:
Returns: function(...[?]):T
A new function.
|
code » |