Namespace goog
code »Base namespace for the Closure library. Checks to see goog is already defined in the current scope before assigning to prevent clobbering if base.js is loaded more than once.
Classes
|
Global Functions
When defining a class Foo with an abstract method bar(), you can do:
Foo.prototype.bar = goog.abstractMethod
Now if a subclass of Foo fails to override bar(), an error will be thrown
when bar() is invoked.
Note: This does not take the name of the function to override as an argument
because that would make it more difficult to obfuscate our JavaScript code.
Throws |
---|
|
code »goog.addDependency ( relPath, provides, requires )Adds a dependency from a file to the files it requires.
code »goog.addSingletonGetter ( ctor )Adds a getInstance
static method that always returns the same
instance object.
getInstance
static method that always returns the same
instance object.Parameters |
---|
|
Call up to the superclass.
If this is called from a constructor, then this calls the superclass
constructor with arguments 1-N.
If this is called from a prototype method, then you must pass the name of the
method as the second argument to this function. If you do not, you will get a
runtime error. This calls the superclass' method with arguments 2-N.
This function only works if you use goog.inherits to express inheritance
relationships between your classes.
This function is a compiler primitive. At compile-time, the compiler will do
macro expansion to remove a lot of the extra overhead that this function
introduces. The compiler will also enforce a lot of the assumptions that this
function makes, and treat it as a compiler error if you break them.
Parameters |
---|
|
Returns |
|
Partially applies this function to a particular 'this object' and zero or
more arguments. The result is a new function with some arguments of the first
function pre-filled and the value of this 'pre-specified'.
Remaining arguments specified at call-time are appended to the pre-specified
ones.
Also see: #partial
.
Usage:
var barMethBound = bind(myFunction, myObj, 'arg1', 'arg2');
barMethBound('arg3', 'arg4');
#partial
.
Usage:
Parameters |
---|
|
Returns |
|
code »goog.bindJs_ ( fn, selfObj, var_args ) ⇒ !Function
A pure-JS implementation of goog.bind.
!Function
Parameters |
---|
Returns |
|
code »goog.bindNative_ ( fn, selfObj, var_args ) ⇒ !Function
A native implementation of goog.bind.
!Function
Parameters |
---|
Returns |
|
code »goog.cloneObject ( obj ) ⇒ *
Deprecated: goog.cloneObject is unsafe. Prefer the goog.object methods.Clones a value. The input may be an Object, Array, or basic type. Objects and
arrays will be cloned recursively.
WARNINGS:
goog.cloneObject
does not detect reference loops. Objects that
refer to themselves will cause infinite recursion.
goog.cloneObject
is unaware of unique identifiers, and copies
UIDs created by getUid
into cloned results.
*
goog.cloneObject
does not detect reference loops. Objects that
refer to themselves will cause infinite recursion.
goog.cloneObject
is unaware of unique identifiers, and copies
UIDs created by getUid
into cloned results.Parameters |
---|
|
Returns |
|
code »goog.define ( name, defaultValue )Defines a named value. In uncompiled mode, the value is retreived from
CLOSURE_DEFINES or CLOSURE_UNCOMPILED_DEFINES if the object is defined and
has the property specified, and otherwise used the defined defaultValue.
When compiled, the default can be overridden using compiler command-line
options.
Parameters |
---|
|
code »goog.exportPath_ ( name, opt_object, opt_objectToExportTo )Builds an object structure for the provided namespace path, ensuring that
names that already exist are not overwritten. For example:
"a.b.c" -> a = {};a.b={};a.b.c={};
Used by goog.provide and goog.exportSymbol.
code »goog.exportProperty ( object, publicName, symbol )Exports a property unobfuscated into the object's namespace.
ex. goog.exportProperty(Foo, 'staticFunction', Foo.staticFunction);
ex. goog.exportProperty(Foo.prototype, 'myMethod', Foo.prototype.myMethod);
code »goog.exportSymbol ( publicPath, object, opt_objectToExportTo )Exposes an unobfuscated global namespace path for the given object.
Note that fields of the exported object *will* be obfuscated, unless they are
exported in turn via this function or goog.exportProperty.
Also handy for making public items that are defined in anonymous closures.
ex. goog.exportSymbol('public.path.Foo', Foo);
ex. goog.exportSymbol('public.path.Foo.staticFunction', Foo.staticFunction);
public.path.Foo.staticFunction();
ex. goog.exportSymbol('public.path.Foo.prototype.myMethod',
Foo.prototype.myMethod);
new public.path.Foo().myMethod();
Tries to detect the base path of base.js script that bootstraps Closure.
code »goog.forwardDeclare ( name )Forward declares a symbol. This is an indication to the compiler that the
symbol may be used in the source yet is not required and may not be provided
in compilation.
The most common usage of forward declaration is code that takes a type as a
function parameter but does not need to require it. By forward declaring
instead of requiring, no hard dependency is made, and (if not required
elsewhere) the namespace may never be required and thus, not be pulled
into the JavaScript binary. If it is required elsewhere, it will be type
checked as normal.
Parameters |
---|
|
code »goog.getCssName ( className, opt_modifier ) ⇒ string
Handles strings that are intended to be used as CSS class names.
This function works in tandem with @see goog.setCssNameMapping.
Without any mapping set, the arguments are simple joined with a hyphen and
passed through unaltered.
When there is a mapping, there are two possible styles in which these
mappings are used. In the BY_PART style, each part (i.e. in between hyphens)
of the passed in css name is rewritten according to the map. In the BY_WHOLE
style, the full css name is looked up in the map directly. If a rewrite is
not specified by the map, the compiler will output a warning.
When the mapping is passed to the compiler, it will replace calls to
goog.getCssName with the strings from the mapping, e.g.
var x = goog.getCssName('foo');
var y = goog.getCssName(this.baseClass, 'active');
becomes:
var x= 'foo';
var y = this.baseClass + '-active';
If one argument is passed it will be processed, if two are passed only the
modifier will be processed, as it is assumed the first argument was generated
as a result of calling goog.getCssName.
string
code »goog.getHashCode ( obj ) ⇒ number
Deprecated: Use goog.getUid instead.Adds a hash code field to an object. The hash code is unique for the
given object.
number
Parameters |
---|
|
Returns |
|
code »goog.getMsg ( str, opt_values ) ⇒ string
Gets a localized message.
This function is a compiler primitive. If you give the compiler a localized
message bundle, it will replace the string at compile-time with a localized
version, and expand goog.getMsg call to a concatenated string.
Messages must be initialized in the form:
var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
string
var MSG_NAME = goog.getMsg('Hello {$placeholder}', {'placeholder': 'world'});
code »goog.getMsgWithFallback ( a, b ) ⇒ string
Gets a localized message. If the message does not have a translation, gives a
fallback message.
This is useful when introducing a new message that has not yet been
translated into all languages.
This function is a compiler primitive. Must be used in the form:
var x = goog.getMsgWithFallback(MSG_A, MSG_B);
where MSG_A and MSG_B were initialized with goog.getMsg.
string
var x = goog.getMsgWithFallback(MSG_A, MSG_B);
where MSG_A and MSG_B were initialized with goog.getMsg.code »goog.getObjectByName ( name, opt_obj )Returns an object based on its fully qualified external name. The object
is not found if null or undefined. If you are using a compilation pass that
renames property names beware that using this function will not find renamed
properties.
code »goog.getPathFromDeps_ ( rule ) ⇒ ?string
Looks at the dependency rules and tries to determine the script file that
fulfills a particular rule.
?string
Parameters |
---|
|
Returns |
|
code »goog.getUid ( obj ) ⇒ number
Gets a unique ID for an object. This mutates the object so that further calls
with the same object as a parameter returns the same value. The unique ID is
guaranteed to be unique across the current session amongst objects that are
passed into getUid
. There is no guarantee that the ID is unique or
consistent across sessions. It is unsafe to generate unique ID for function
prototypes.
number
getUid
. There is no guarantee that the ID is unique or
consistent across sessions. It is unsafe to generate unique ID for function
prototypes.Parameters |
---|
|
Returns |
|
code »goog.globalEval ( script )Evals JavaScript in the global scope. In IE this uses execScript, other
browsers use goog.global.eval. If goog.global.eval does not evaluate in the
global scope (for example, in Safari), appends a script tag instead.
Throws an exception if neither execScript or eval is defined.
Parameters |
---|
|
code »goog.globalize ( obj, opt_global )Deprecated: Properties may be explicitly exported to the global scope, but
this should no longer be done in bulk.Globalizes a whole namespace, such as goog or goog.lang.
code »goog.hasUid ( obj ) ⇒ boolean
Whether the given object is alreay assigned a unique ID.
This does not modify the object.
boolean
Parameters |
---|
|
Returns |
|
code »goog.identityFunction ( opt_returnValue, var_args )Deprecated: Use goog.functions.identity instead.The identity function. Returns its first argument.
Parameters |
---|
|
Returns |
|
code »goog.importScript_ ( src )Imports a script if, and only if, that script hasn't already been imported.
(Must be called at execution time)
Parameters |
---|
|
Tries to detect whether is in the context of an HTML document.
Returns |
---|
|
code »goog.inherits ( childCtor, parentCtor )Inherit the prototype methods from one constructor into another.
Usage:
function ParentClass(a, b) { }
ParentClass.prototype.foo = function(a) { }
function ChildClass(a, b, c) {
goog.base(this, a, b);
}
goog.inherits(ChildClass, ParentClass);
var child = new ChildClass('a', 'b', 'see');
child.foo(); // This works.
In addition, a superclass' implementation of a method can be invoked as
follows:
ChildClass.prototype.foo = function(a) {
ChildClass.superClass_.foo.call(this, a);
// Other code here.
};
code »goog.isArray ( val ) ⇒ boolean
Returns true if the specified value is an array.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isArrayLike ( val ) ⇒ boolean
Returns true if the object looks like an array. To qualify as array like
the value needs to be either a NodeList or an object with a Number length
property.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isBoolean ( val ) ⇒ boolean
Returns true if the specified value is a boolean.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isDateLike ( val ) ⇒ boolean
Returns true if the object looks like a Date. To qualify as Date-like the
value needs to be an object and have a getFullYear() function.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isDef ( val ) ⇒ boolean
Returns true if the specified value is not undefined.
WARNING: Do not use this to test if an object has a property. Use the in
operator instead.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isDefAndNotNull ( val ) ⇒ boolean
Returns true if the specified value is defined and not null.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isFunction ( val ) ⇒ boolean
Returns true if the specified value is a function.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isNull ( val ) ⇒ boolean
Returns true if the specified value is null.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isNumber ( val ) ⇒ boolean
Returns true if the specified value is a number.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isObject ( val ) ⇒ boolean
Returns true if the specified value is an object. This includes arrays and
functions.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isProvided_ ( name ) ⇒ boolean
Check if the given name has been goog.provided. This will return false for
names that are available only as implicit namespaces.
boolean
Parameters |
---|
|
Returns |
|
code »goog.isString ( val ) ⇒ boolean
Returns true if the specified value is a string.
boolean
Parameters |
---|
|
Returns |
|
code »goog.mixin ( target, source )Copies all the members of a source object to a target object. This method
does not work on all browsers for all objects that contain keys such as
toString or hasOwnProperty. Use goog.object.extend for this purpose.
code »goog.nullFunction ( ) ⇒ void
Null function used for default values of callbacks, etc.
void
Returns |
---|
|
code »goog.partial ( fn, var_args ) ⇒ !Function
Like bind(), except that a 'this object' is not required. Useful when the
target function is already bound.
Usage:
var g = partial(f, arg1, arg2);
g(arg3, arg4);
!Function
Parameters |
---|
|
Returns |
|
code »goog.provide ( name )Creates object stubs for a namespace. The presence of one or more
goog.provide() calls indicate that the file defines the given
objects/namespaces. Provided objects must not be null or undefined.
Build tools also scan for provide/require statements
to discern dependencies, build dependency files (see deps.js), etc.
Parameters |
---|
|
code »goog.removeHashCode ( obj )Deprecated: Use goog.removeUid instead.Removes the hash code field from an object.
Parameters |
---|
|
code »goog.removeUid ( obj )Removes the unique ID from an object. This is useful if the object was
previously mutated using goog.getUid
in which case the mutation is
undone.
goog.getUid
in which case the mutation is
undone.Parameters |
---|
|
code »goog.require ( name )Implements a system for the dynamic resolution of dependencies that works in
parallel with the BUILD system. Note that all calls to goog.require will be
stripped by the JSCompiler when the --closure_pass option is used.
Parameters |
---|
|
code »goog.scope ( fn )Allow for aliasing within scope functions. This function exists for
uncompiled code - in compiled code the calls will be inlined and the aliases
applied. In uncompiled code the function is simply run since the aliases as
written are valid JavaScript.
Parameters |
---|
|
code »goog.setCssNameMapping ( mapping, opt_style )Sets the map to check when returning a value from goog.getCssName(). Example:
goog.setCssNameMapping({
"goog": "a",
"disabled": "b",
});
var x = goog.getCssName('goog');
// The following evaluates to: "a a-b".
goog.getCssName('goog') + ' ' + goog.getCssName(x, 'disabled')
When declared as a map of string literals to string literals, the JSCompiler
will replace all calls to goog.getCssName() using the supplied map if the
--closure_pass flag is set.
code »goog.setTestOnly ( opt_message )Marks that the current file should only be used for testing, and never for
live code in production.
In the case of unit tests, the message may optionally be an exact namespace
for the test (e.g. 'goog.stringTest'). The linter will then ignore the extra
provide (if not explicitly defined in the code).
Parameters |
---|
|
code »goog.typeOf ( value ) ⇒ string
This is a "fixed" version of the typeof operator. It differs from the typeof
operator in such a way that null returns 'null' and arrays return 'array'.
string
Parameters |
---|
|
Returns |
|
code »goog.writeScriptTag_ ( src ) ⇒ boolean
The default implementation of the import function. Writes a script tag to
import the script.
boolean
Parameters |
---|
|
Returns |
|
Resolves dependencies based on the dependencies added using addDependency
and calls importScript_ in the correct order.
Global Properties
True if goog.dependencies_ is available.
Name for unique ID property. Initialized in a way to help avoid collisions
with other closure JavaScript on the same page.
Path for included scripts.
Optional obfuscation style for CSS class names. Should be set to either
'BY_WHOLE' or 'BY_PART' if defined.
Optional map of CSS class names to obfuscated names used with
goog.getCssName().
This object is used to keep track of dependencies and other data that is
used for loading scripts.
Indicates whether or not we can call 'eval' directly to eval code in the
global scope. Set to a Boolean by the first call to goog.globalEval (which
empirically tests whether eval works for globals). @see goog.globalEval
code »goog.global : global this
Reference to the global context. In most cases this will be 'window'.
global this
Namespaces implicitly defined by goog.provide. For example,
goog.provide('goog.events.Event') implicitly declares that 'goog' and
'goog.events' must be namespaces.
Object used to keep track of urls that have already been added. This record
allows the prevention of circular dependencies.
All singleton classes that have been instantiated, for testing. Don't read
it directly, use the goog.testing.singleton
module. The compiler
removes this variable if unused.
goog.testing.singleton
module. The compiler
removes this variable if unused.