goog NamespacegoogBase 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.
.DEBUGgoog.Delay ClassDeprecated. Use goog.async.Delay instead.
A deprecated alias. … more
goog.Disposable ClassClass that provides the basic implementation for disposable objects. If your class holds one or more references to COM objects, DOM nodes, or other disposable objects, it should extend this class or implement the disposable interface (defined in goog.disposable.IDisposable). … more
.ENABLE_DEBUG_LOADERgoog.History ClassA history management object. Can be instantiated in user-visible mode (uses the address fragment to manage state) or in hidden mode. This object should be created from a script in the document body before the document has finished loading. To store the hidden states in browsers other than IE, a hidden iframe is used. It must point to a valid html page on the same domain (which can and probably should be blank.) Sample instantiation and usage:
// Instantiate history to use the address bar for state.
var h = new goog.History();
goog.events.listen(h, goog.history.EventType.NAVIGATE, navCallback);
h.setEnabled(true);
// Any changes to the location hash will call the following function.
function navCallback(e) {
alert('Navigated to state "' + e.token + '"');
}
// The history token can also be set from code directly.
h.setToken('foo');
… more
.LOCALE.NATIVE_ARRAY_PROTOTYPESgoog.Throttle ClassDeprecated. Use goog.async.Throttle instead.
A deprecated alias. … more
goog.Timer ClassClass for handling timing events. … more
goog.Uri ClassThis class contains setters and getters for the parts of the URI.
The getXyz/setXyz methods return the decoded part
-- sogoog.Uri.parse('/foo%20bar').getPath() will return the
decoded path, /foo bar.
The constructor accepts an optional unparsed, raw URI string. The parser
is relaxed, so special characters that aren't escaped but don't cause
ambiguities will not cause parse failures.
All setters return this and so may be chained, a la
goog.Uri.parse('/foo').setFragment('part').toString().
… more
.abstractMethod() {!Function}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.
.addDependency(relPath, provides, requires)Adds a dependency from a file to the files it requires.
relPath {string}
provides {Array}
requires {Array}
.addSingletonGetter(ctor)Adds a {@code getInstance} static method that always return the same instance object.
ctor {!Function}
goog.array Namespacegoog.asserts Namespacegoog.async Namespace.base(me, opt_methodName, var_args)Call up to the superclass. If this is called from a constructor, then this calls the superclass contructor 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.
me {!Object}
opt_methodName {*=}
var_args {...*}
.basePath {string}Path for included scripts
.bind(fn, selfObj, var_args)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: {@link #partial}.
Usage:
var barMethBound = bind(myFunction, myObj, 'arg1', 'arg2');
barMethBound('arg3', 'arg4');
fn {Function}
selfObj {Object|undefined}
var_args {...*}
Function}
.cloneObject(obj) [deprecated]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.
obj {*}
goog.color Namespacegoog.crypt Namespacegoog.cssom Namespacegoog.date Namespacegoog.db Namespacegoog.debug Namespacegoog.demos Namespacegoog.disposable Namespace.dispose(obj)Calls {@code dispose} on the argument if it supports it. If obj is not an object with a dispose() method, this is a no-op.
obj {*}
.disposeAll(var_args)Calls {@code dispose} on each member of the list that supports it. (If the member is an ArrayLike, then {@code goog.disposeAll()} will be called recursively on each of its members.) If the member is not an object with a {@code dispose()} method, then it is ignored.
var_args {...*}
goog.dom Namespacegoog.ds Namespacegoog.editor Namespacegoog.events Namespace.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);
object {Object}
publicName {string}
symbol {*}
.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();
publicPath {string}
object {*}
opt_objectToExportTo {Object=}
goog.format Namespacegoog.fs Namespacegoog.functions Namespacegoog.fx Namespacegoog.gears Namespace.getCssName(className, opt_modifier)Handles strings that are intended to be used as CSS class names. This function works in tandem with
className {string}
opt_modifier {string=}
string}
.getHashCode [deprecated]Deprecated. Use goog.getUid instead.
Adds a hash code field to an object. The hash code is unique for the given object.
obj {Object}
number}
.getMsg(str, opt_values)Abstract implementation of goog.getMsg for use with localized messages.
str {string}
opt_values {Object=}
string}
.getObjectByName(name, opt_obj)Returns an object based on its fully qualified external name. If you are using a compilation pass that renames property names beware that using this function will not find renamed properties.
name {string}
opt_obj {Object=}
.getUid(obj)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 {@code getUid}. There is no guarantee that the ID is unique or consistent across sessions. It is unsafe to generate unique ID for function prototypes.
obj {Object}
number}
goog.global NamespaceReference to the global context. In most cases this will be 'window'. … more
.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.
script {string}
.globalize(obj, opt_global) [deprecated]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.
obj {Object}
opt_global {Object=}
goog.graphics Namespacegoog.history Namespacegoog.i18n Namespace.identityFunction(opt_returnValue, var_args) [deprecated]Deprecated. Use goog.functions.identity instead.
The identity function. Returns its first argument.
opt_returnValue {*=}
var_args {...*}
.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(); // 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
};
childCtor {Function}
parentCtor {Function}
.isArray(val)Returns true if the specified value is an array
val {*}
boolean}
.isArrayLike(val)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.
val {*}
boolean}
.isBoolean(val)Returns true if the specified value is a boolean
val {*}
boolean}
.isDateLike(val)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.
val {*}
boolean}
.isDef(val)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. Additionally, this function assumes that the global undefined variable has not been redefined.
val {*}
boolean}
.isDefAndNotNull(val)Returns true if the specified value is defined and not null
val {*}
boolean}
.isFunction(val)Returns true if the specified value is a function
val {*}
boolean}
.isNull(val)Returns true if the specified value is |null|
val {*}
boolean}
.isNumber(val)Returns true if the specified value is a number
val {*}
boolean}
.isObject(val)Returns true if the specified value is an object. This includes arrays and functions.
val {*}
boolean}
.isString(val)Returns true if the specified value is a string
val {*}
boolean}
goog.iter Namespacegoog.json Namespacegoog.labs Namespacegoog.locale Namespacegoog.math Namespacegoog.memoize NamespaceDecorator around functions that caches the inner function's return values. … more
goog.messaging Namespace.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.
target {Object}
source {Object}
goog.module Namespacegoog.net Namespace.nownumber}
.nullFunction()Null function used for default values of callbacks, etc.
void}
goog.object Namespacegoog.osapi Namespace.partial(fn, var_args)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);
fn {Function}
var_args {...*}
Function}
goog.positioning Namespacegoog.proto Namespacegoog.proto2 Namespace.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. Build tools also scan for provide/require statements to discern dependencies, build dependency files (see deps.js), etc.
name {string}
goog.pubsub Namespacegoog.reflect Namespace.removeHashCode [deprecated]Deprecated. Use goog.removeUid instead.
Removes the hash code field from an object.
obj {Object}
.removeUid(obj)Removes the unique ID from an object. This is useful if the object was previously mutated using {@code goog.getUid} in which case the mutation is undone.
obj {Object}
.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.
name {string}
.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.
fn {function()}
.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.
mapping {!Object}
opt_style {string=}
.setTestOnly(opt_message)Marks that the current file should only be used for testing, and never for live code in production.
opt_message {string=}
goog.silverlight Namespacegoog.soy Namespacegoog.spell Namespacegoog.stats Namespacegoog.storage Namespacegoog.string Namespacegoog.structs Namespacegoog.style Namespacegoog.style_test Namespacegoog.testing Namespacegoog.text Namespacegoog.tweak Namespace.typeOf(value)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'.
value {*}
string}
goog.ui Namespacegoog.uri Namespacegoog.userAgent Namespacegoog.vec Namespacegoog.webgl Namespacegoog.window Namespace