मैथड को ऐब्सट्रैक्ट के तौर पर मार्क करता है. goog.abstractMethod पर सेट करने के तरीके की तरह, कंपाइलर कोड के साइज़ को कम करने के लिए, @abstract के साथ एनोटेट किए गए तरीकों को हटा सकता है.

अगर कंपाइलर @abstract से मार्क किए गए किसी तरीके को लागू नहीं करता है, तो कंपाइलर चेतावनी देता है.

/** @abstract */
foo.MyClass.prototype.abstractMethod = function() {};

वैरिएबल को रीड-ओनली के तौर पर मार्क करता है. कंपाइलर, @const वैरिएबल को इनलाइन कर सकता है, जो JavaScript कोड को ऑप्टिमाइज़ करता है.

जानकारी देना ज़रूरी नहीं है.

जब @const के साथ मार्क किए गए वैरिएबल को एक से ज़्यादा बार वैल्यू असाइन की जाती है, तो कंपाइलर चेतावनी देता है. अगर वैरिएबल एक ऑब्जेक्ट है, तो ध्यान दें कि कंपाइलर ऑब्जेक्ट के प्रॉपर्टी में बदलाव करने पर रोक नहीं लगाता.

/** @const */ var MY_BEER = 'stout';

/**
 * My namespace's favorite kind of beer.
 * @const {string}
 */
mynamespace.MY_BEER = 'stout';

/** @const */ MyClass.MY_BEER = 'stout';

फ़ंक्शन को कंस्ट्रक्टर के रूप में मार्क करता है. कंपाइलर को new कीवर्ड के साथ इस्तेमाल किए जाने वाले किसी भी फ़ंक्शन के लिए, @constructor एनोटेशन की ज़रूरत होती है

उदाहरण के लिए:

/**
 * A rectangle.
 * @constructor
 */
function GM_Rect() {
  ...
}

उदाहरण के लिए:

/** @define {boolean} */
var ENABLE_DEBUG = true;

/** @define {boolean} */
goog.userAgent.ASSUME_IE = false;

किसी फ़ंक्शन, तरीके या प्रॉपर्टी को मार्क करता है, ताकि इसका इस्तेमाल करने पर कंपाइलर चेतावनी मिले. इससे पता चलता है कि अब इसका इस्तेमाल नहीं किया जाना चाहिए.

उदाहरण के लिए:

/**
 * Determines whether a node is a field.
 * @return {boolean} True if the contents of
 *     the element are editable, but the element
 *     itself is not.
 * @deprecated Use isField().
 */
BN_EditUtil.isTopEditableField = function(node) {
  ...
};

@dict का इस्तेमाल, अलग-अलग प्रॉपर्टी वाले वैरिएबल बनाने के लिए किया जाता है. जब Foo में, किसी कंस्ट्रक्टर को @dict के साथ एनोटेट किया जाता है, तो सिर्फ़ Foo ऑब्जेक्ट की प्रॉपर्टी को ऐक्सेस करने के लिए, ब्रैकेट नोटेशन का इस्तेमाल किया जा सकता है. एनोटेशन का इस्तेमाल सीधे ऑब्जेक्ट लिटरल पर भी किया जा सकता है.

उदाहरण के लिए:

/**
 * @constructor
 * @dict
 */
function Foo() {}
var obj1 = new Foo();
obj1['x'] = 123;
obj1.x = 234;  // warning

var obj2 = /** @dict */ { 'x': 321 };
obj2.x = 123;  // warning

इससे enum का प्रकार तय होता है. enum एक ऐसा ऑब्जेक्ट है जिसकी प्रॉपर्टी में उससे जुड़े कॉन्सटेंट का एक सेट बनता है. @enum टैग के बाद एक टाइप एक्सप्रेशन होना चाहिए.

ईनम का प्रकार लेबल, ईनम की हर प्रॉपर्टी पर लागू होता है. उदाहरण के लिए, अगर किसी ईनम का टाइप number है, तो उसकी ईनमरेटेड प्रॉपर्टी में से हर एक संख्या होनी चाहिए. अगर ईनम का टाइप मिटाया गया है, तो उसे number माना जाता है.

उदाहरण के लिए:

/**
 * Enum for tri-state values.
 * @enum {number}
 */
project.TriState = {
  TRUE: 1,
  FALSE: -1,
  MAYBE: 0
};

यह कोड दिया गया

/** @export */
foo.MyPublicClass.prototype.myPublicMethod = function() {
  // ...
};

जब कंपाइलर को --generate_exports फ़्लैग के साथ चलाया जाए, तो वह कोड जनरेट करेगा:

goog.exportProperty(foo.MyPublicClass.prototype, 'myPublicMethod',
  foo.MyPublicClass.prototype.myPublicMethod);

जो सिंबल को कंपाइल किए गए कोड में एक्सपोर्ट करेगा. /** @export {SomeType} */ को

/**
 * @export
 * @type {SomeType}
 */

कोड में @export एनोटेशन का इस्तेमाल करना ज़रूरी है.

1. closure/base.js शामिल करें या
2. अपने कोडबेस में, एक जैसे तरीके से हस्ताक्षर करके goog.exportSymbol और goog.exportProperty, दोनों के बारे में बताएं.

किसी कक्षा या इंटरफ़ेस को दूसरी कक्षा से इनहेरिट की गई के तौर पर मार्क करता है. @extends से मार्क की गई क्लास को @constructor या @interface के साथ भी मार्क किया जाना चाहिए.

ध्यान दें: @extends की वजह से, कोई कक्षा किसी दूसरी क्लास से इनहेरिट नहीं होती. एनोटेशन, कंपाइलर को यह बताता है कि टाइप-चेकिंग के दौरान, यह एक क्लास को दूसरी क्लास की सब-क्लास मान सकता है.

इनहेरिटेंस लागू करने के उदाहरण के लिए, क्लोज़र लाइब्रेरी फ़ंक्शन goog.inherits() देखें.

उदाहरण के लिए:

/**
 * Immutable empty node list.
 * @constructor
 * @extends {goog.ds.BasicNodeList}
 */
goog.ds.EmptyNodeList = function() {
  ...
};

इससे पता चलता है कि इस क्लास को आगे बढ़ाने की अनुमति नहीं है. मैथड के लिए, इससे पता चलता है कि किसी सब-क्लास को उस तरीके को बदलने की अनुमति नहीं है.

उदाहरण के लिए:

/**
 * A class that cannot be extended.
 * @final
 * @constructor
 */
sloth.MyFinalClass = function() { ... }

/**
 * A method that cannot be overridden.
 * @final
 */
sloth.MyFinalClass.prototype.method = function() { ... };

@constructor के साथ इस्तेमाल किया जाता है, ताकि यह बताया जा सके कि क्लास में इंटरफ़ेस लागू है या नहीं.

कंपाइलर, @implements के साथ कंस्ट्रक्टर को टैग करने पर चेतावनी देता है. इसके बाद, वह इंटरफ़ेस में तय किए गए सभी तरीके और प्रॉपर्टी लागू नहीं करता है.

उदाहरण के लिए:

/**
 * A shape.
 * @interface
 */
function Shape() {};
Shape.prototype.draw = function() {};

/**
 * @constructor
 * @implements {Shape}
 */
function Square() {};
Square.prototype.draw = function() {
  ...
};

यह एनोटेशन सिर्फ़ बाहरी प्रॉपर्टी के एलान में दिख सकता है. प्रॉपर्टी का टाइप तय किया गया है, लेकिन आपके पास बिना चेतावनी के, किसी भी तरह का इसे असाइन करने का विकल्प है. प्रॉपर्टी ऐक्सेस करते समय, आपको एलान किए गए टाइप की वैल्यू वापस मिल जाती है. उदाहरण के लिए, element.innerHTML को किसी भी तरह का यूआरएल असाइन किया जा सकता है, लेकिन इससे हमेशा एक स्ट्रिंग मिलेगी.

/**
 * @type {string}
 * @implicitCast
 */
Element.prototype.innerHTML;

इससे पता चलता है कि सब-क्लास का कोई तरीका या प्रॉपर्टी, सुपर क्लास के किसी तरीके या प्रॉपर्टी को अनजाने में छिपा देती है और बिल्कुल वही दस्तावेज़ है. ध्यान दें कि @inheritDoc टैग में @override टैग का इस्तेमाल होता है.

उदाहरण के लिए:

/** @inheritDoc */
project.SubClass.prototype.toString = function() {
  ...
};

फ़ंक्शन को इंटरफ़ेस के तौर पर मार्क करता है. एक इंटरफ़ेस, एक प्रकार के ज़रूरी सदस्यों के बारे में बताता है. किसी भी क्लास में जो इंटरफ़ेस लागू होता है, उसे इंटरफ़ेस के प्रोटोटाइप में बताए गए सभी तरीके और प्रॉपर्टी लागू करनी होंगी. @implements देखें.

कंपाइलर इस बात की पुष्टि करता है कि इंटरफ़ेस, इंस्टैंशिएट नहीं किए गए हैं. अगर new कीवर्ड का इस्तेमाल इंटरफ़ेस फ़ंक्शन के साथ किया जाता है, तो कंपाइलर चेतावनी देता है.

उदाहरण के लिए:

/**
 * A shape.
 * @interface
 */
function Shape() {};
Shape.prototype.draw = function() {};

/**
 * A polygon.
 * @interface
 * @extends {Shape}
 */
function Polygon() {};
Polygon.prototype.getSides = function() {};

यह बताता है कि किसी ऑब्जेक्ट लिटरल की कुंजियों को किसी दूसरे ऑब्जेक्ट की प्रॉपर्टी समझा जाना चाहिए. यह एनोटेशन सिर्फ़ ऑब्जेक्ट लिटरल पर दिखना चाहिए.

ध्यान दें कि ब्रैकेट में मौजूद नाम, टाइप नहीं किया गया है, जैसा कि दूसरी एनोटेशन में दिया गया है. यह ऑब्जेक्ट का नाम है. इसमें उस ऑब्जेक्ट का नाम होता है जिस पर प्रॉपर्टी दी गई है. उदाहरण के लिए, @type {Foo} का मतलब है "Foo का एक इंस्टेंस", लेकिन @lends {Foo} का मतलब है "कंस्ट्रक्टर फ़ू".

JSDoc टूलकिट दस्तावेज़ों में इस एनोटेशन के बारे में ज़्यादा जानकारी है.

उदाहरण के लिए:

goog.object.extend(
    Button.prototype,
    /** @lends {Button.prototype} */ ({
      isButton: function() { return true; }
    }));

कंपाइलर को, मार्क की गई फ़ाइल के लिए कंपाइल किए गए कोड से पहले, उससे जुड़ी टिप्पणी को शामिल करने के लिए कहता है. इस एनोटेशन से, ज़रूरी सूचनाओं (जैसे कि कानूनी लाइसेंस या कॉपीराइट वाले टेक्स्ट) में कोई बदलाव नहीं होता. लाइन ब्रेक को सुरक्षित रखा जाता है.

उदाहरण के लिए:

/**
 * @preserve Copyright 2009 SomeThirdParty.
 * Here is the full license text and copyright
 * notice for this file. Note that the notice can span several
 * lines and is only terminated by the closing star and slash:
 */

यह ऐसी प्रॉपर्टी को दिखाता है जिसे कंपाइलर को वैरिएबल में छोटा नहीं करना चाहिए. @nocollapse का मुख्य इस्तेमाल यह है कि म्यूटेबल प्रॉपर्टी एक्सपोर्ट की जा सकती हैं. ध्यान दें कि जो प्रॉपर्टी छोटी नहीं हैं उनका नाम अब भी कंपाइलर बदल सकता है. अगर आप किसी ऐसी प्रॉपर्टी के बारे में बताते हैं जो @nocollapse वाला एक ऑब्जेक्ट है, तो उसकी सभी प्रॉपर्टी में भी बदलाव नहीं किया जाएगा.

उदाहरण के लिए:

/**
 * A namespace.
 * @const
 */
var foo = {};

/**
 * @nocollapse
 */
foo.bar = 42;

window['foobar'] = foo.bar;

इससे पता चलता है कि एलान किए गए बाहरी फ़ंक्शन को किए जाने वाले कॉल पर कोई असर नहीं होता. इस एनोटेशन से, कंपाइलर फ़ंक्शन के लिए कॉल हटा सकते हैं, अगर रिटर्न वैल्यू इस्तेमाल नहीं की जाती. इस एनोटेशन को सिर्फ़ extern files में इस्तेमाल करने की अनुमति है.

उदाहरण के लिए:

/** @nosideeffects */
function noSideEffectsFn1() {}

/** @nosideeffects */
var noSideEffectsFn2 = function() {};

/** @nosideeffects */
a.prototype.noSideEffectsFn3 = function() {};

इससे पता चलता है कि सब-क्लास का कोई तरीका या प्रॉपर्टी, सुपर-क्लास के तरीके या प्रॉपर्टी को छिपा देती है. अगर कोई और एनोटेशन शामिल नहीं किया जाता है, तो तरीका या प्रॉपर्टी अपने-आप सुपर क्लास से एनोटेशन इनहेरिट कर लेती है.

उदाहरण के लिए:

/**
 * @return {string} Human-readable representation of
 *     project.SubClass.
 * @override
 */
project.SubClass.prototype.toString = function() {
  ...
};

किसी सदस्य या प्रॉपर्टी को पैकेज निजी के रूप में मार्क करता है. सिर्फ़ उसी डायरेक्ट्री में मौजूद कोड, @package के तौर पर मार्क किए गए नाम ऐक्सेस कर सकते हैं. खास तौर पर, पैरंट और चाइल्ड डायरेक्ट्री में दिया गया कोड, @package के तौर पर मार्क किए गए नामों को ऐक्सेस नहीं कर सकता.

सार्वजनिक कंस्ट्रक्टर में, @package प्रॉपर्टी की मदद से ऐसे तरीकों को प्रतिबंधित किया जा सकता है जिन्हें डायरेक्ट्री से बाहर के कॉलर इस्तेमाल कर सकते हैं. वहीं दूसरी ओर, @package के कंस्ट्रक्टर के पास सार्वजनिक प्रॉपर्टी हो सकती हैं, ताकि वे डायरेक्ट्री से बाहर के कॉलर को सीधे तौर पर इंस्टैंशिएट होने से रोक सकें.

उदाहरण के लिए:

/**
 * Returns the window object the foreign document resides in.
 *
 * @return {Object} The window object of the peer.
 * @package
 */
goog.net.xpc.CrossPageChannel.prototype.getPeerWindowObject = function() {
  // ...
};

फ़ंक्शन के तर्कों के टाइप बताने के लिए, मेथड, कंस्ट्रक्टर और कंस्ट्रक्टर डेफ़िनिशन का इस्तेमाल किया जाता है. @param टैग, फ़ंक्शन की परिभाषा में दिए गए पैरामीटर के क्रम में होने चाहिए.

@param टैग के बाद में कोई टाइप एक्सप्रेशन होना चाहिए.

इसके अलावा, इनलाइन के टाइप के बारे में जानकारी दी जा सकती है (उदाहरण में, फ़ंक्शन foo देखें).

उदाहरण के लिए:

/**
 * Queries a Baz for items.
 * @param {number} groupNum Subgroup id to query.
 * @param {string|number|null} term An itemName,
 *     or itemId, or null to search everything.
 */
goog.Baz.prototype.query = function(groupNum, term) {
  ...
};

function foo(/** number */ a, /** number */ b) {
  return a - b + 1;
}

/**
 * @param {{name: string, age: number}} person
 */
function logPerson({name, age}) {
  console.log(`${name} is ${age} years old`);
}

किसी सदस्य को निजी के तौर पर मार्क करता है. सिर्फ़ एक फ़ाइल में मौजूद कोड, @private के तौर पर मार्क किए गए ग्लोबल वैरिएबल और फ़ंक्शन को ऐक्सेस कर सकता है. @private के कंस्ट्रक्टर को सिर्फ़ उसी फ़ाइल में मौजूद कोड से इंस्टैंशिएट किया जा सकता है और उनके स्टैटिक और इंस्टेंस के सदस्य उन्हें इंस्टैंशिएट कर सकते हैं.

@private के तौर पर मार्क किए गए कंस्ट्रक्टर की सार्वजनिक स्टैटिक प्रॉपर्टी को भी कहीं भी ऐक्सेस किया जा सकता है और instanceof ऑपरेटर हमेशा @privateसदस्यों को ऐक्सेस कर सकता है.

उदाहरण के लिए:

/**
 * Handlers that are listening to this logger.
 * @private {Array<Function>}
 */
this.handlers_ = [];

इससे पता चलता है कि कोई सदस्य या प्रॉपर्टी सुरक्षित है.

@protected के तौर पर मार्क की गई प्रॉपर्टी को ऐक्सेस किया जा सकता है:

• एक ही फ़ाइल के सभी कोड
• स्टैटिक क्लास और इंस्टेंस की क्लास जिस पर प्रॉपर्टी के बारे में बताया गया है.

उदाहरण के लिए:

/**
 * Sets the component's root element to the given element.
 * Considered protected and final.
 * @param {Element} element Root element for the component.
 * @protected
 */
goog.ui.Component.prototype.setElementInternal = function(element) {
  // ...
};

फ़ंक्शन को स्ट्रक्चरल इंटरफ़ेस के तौर पर मार्क करता है. स्ट्रक्चरल इंटरफ़ेस नॉर्मल @interface से मिलता-जुलता है, लेकिन यह सीधे तौर पर लागू होता है. इसका मतलब है कि स्ट्रक्चरल इंटरफ़ेस के प्रोटोटाइप में बताए गए तरीके और प्रॉपर्टी, स्ट्रक्चरल इंटरफ़ेस को लागू करती हैं, चाहे वह @implements टैग का इस्तेमाल करता हो या नहीं. अगर रिकॉर्ड प्रॉपर्टी और ऑब्जेक्ट लिटरल में ज़रूरी प्रॉपर्टी शामिल हैं, तो वे भी साफ़ तौर पर स्ट्रक्चरल इंटरफ़ेस को लागू करते हैं.

उदाहरण के लिए:

/**
 * Anything with a draw() method.
 * @record
 */
function Drawable() {};
Drawable.prototype.draw = function() {};

/**
 * A polygon.
 * @param {!Drawable} x
 */
function render(x) { x.draw(); };

var o = { draw() { /* ... */ } };
render(o);

रिटर्न के तरीके के बारे में और फ़ंक्शन की परिभाषाओं के बारे में बताता है. @return टैग के बाद में कोई टाइप एक्सप्रेशन होना चाहिए.

इसके अलावा, आप रिटर्न टाइप के इनलाइन की जानकारी भी दे सकते हैं (उदाहरण में, फ़ंक्शन foo देखें).

अगर कोई बाहरी फ़ंक्शन जो रिटर्न नहीं करता है उसकी कोई वैल्यू नहीं होती है, तो आप @return टैग को हटा सकते हैं. साथ ही, कंपाइलर यह मानेगा कि फ़ंक्शन रिटर्न करता है undefined.

उदाहरण के लिए:

/**
 * Returns the ID of the last item.
 * @return {string} The hex ID.
 */
goog.Baz.prototype.getLastId = function() {
  ...
  return id;
};

function /** number */ foo(x) { return x - 1; }

@struct का इस्तेमाल, तय संख्या वाली प्रॉपर्टी के साथ ऑब्जेक्ट बनाने के लिए किया जाता है. जब Foo में किसी कंस्ट्रक्टर को @struct के साथ दिखाया गया हो, तो सिर्फ़ Foo ऑब्जेक्ट की प्रॉपर्टी को ऐक्सेस करने के लिए, डॉट नोटेशन का इस्तेमाल किया जा सकता है. ब्रैकेट नोटेशन का इस्तेमाल नहीं किया जा सकता. साथ ही, किसी प्रॉपर्टी को बनाने के बाद आप उसमें Foo नहीं जोड़ सकते. एनोटेशन का इस्तेमाल सीधे ऑब्जेक्ट लिटरल पर भी किया जा सकता है.

उदाहरण के लिए:

/**
 * @constructor
 * @struct
 */
function Foo(x) {
  this.x = x;
}
var obj1 = new Foo(123);
var someVar = obj1.x;  // OK
obj1.x = "qwerty";  // OK
obj1['x'] = "asdf";  // warning
obj1.y = 5;  // warning

var obj2 = /** @struct */ { x: 321 };
obj2['x'] = 123;  // warning

सामान्य टाइप देखें.

उदाहरण के लिए:

/**
 * @param {T} t
 * @constructor
 * @template T
 */
Container = function(t) { ... };

ऑब्जेक्ट के उस टाइप को तय करता है जिसे this फ़ंक्शन में इस्तेमाल करता है. @this टैग के बाद में कोई टाइप एक्सप्रेशन होना चाहिए.

कंपाइलर चेतावनियों से बचने के लिए, आपको @this एनोटेशन का इस्तेमाल करना चाहिए. ऐसा तब होता है, जब this किसी ऐसे फ़ंक्शन में दिखता है जो न तो प्रोटोटाइप का तरीका है और न ही @constructor के तौर पर मार्क किए गए फ़ंक्शन में.

उदाहरण के लिए:

chat.RosterWidget.extern('getRosterElement',
    /**
     * Returns the roster widget element.
     * @this {Widget}
     * @return {Element}
     */
    function() {
      return this.getComponent().getElement();
    });

इसका इस्तेमाल, फ़ंक्शन से दिए गए अपवादों को रिकॉर्ड करने के लिए किया जाता है. टाइप चेकर फ़िलहाल इस जानकारी का इस्तेमाल नहीं कर रहा है. इसका इस्तेमाल सिर्फ़ यह पता लगाने के लिए किया जाता है कि बाहरी फ़ाइल में तय फ़ंक्शन का कोई असर होता है या नहीं.

उदाहरण के लिए:

/**
 * @throws {DOMException}
 */
DOMApplicationCache.prototype.swapCache = function() { ... };

इससे पता चलता है कि वैरिएबल, प्रॉपर्टी या एक्सप्रेशन किस तरह का है. @type टैग के बाद एक टाइप एक्सप्रेशन होना चाहिए.

दूसरे वैरिएबल में, किसी वैरिएबल या फ़ंक्शन पैरामीटर के बारे में जानकारी देते समय, {} और @type को छोड़कर, टाइप एनोटेशन को इनलाइन किया जा सकता है. इस शॉर्टकट का इस्तेमाल सिर्फ़ तब किया जा सकता है, जब वैरिएबल या फ़ंक्शन पैरामीटर का एलान किया गया हो. अगर बाद में आप टाइप में बदलाव करना चाहते हैं, तो आपको एक टाइप कास्ट करना होगा.

उदाहरण के लिए:

/**
 * The message hex ID.
 * @type {string}
 */
var hexId = hexId;

var /** string */ name = 'Jamie';
function useSomething(/** (string|number|!Object) */ something) {
...
}

यह ज़्यादा मुश्किल टाइप के लिए उपनाम का एलान करता है. फ़िलहाल, टाइपडेफ़ को सिर्फ़ टॉप लेवल पर तय किया जा सकता है, न कि फ़ंक्शन के अंदर. हमने इस सीमा को नए टाइप के अनुमान में ठीक कर दिया है.

उदाहरण के लिए:

/** @typedef {(string|number)} */
goog.NumberLike;

/** @param {goog.NumberLike} x A number or a string. */
goog.readNumber = function(x) {
  ...
}

इससे पता चलता है कि क्लास न तो @struct टाइप की है और न ही @dict. यह डिफ़ॉल्ट बात है. इसलिए, आम तौर पर इसे अलग से लिखना ज़रूरी नहीं होता. ऐसा तब तक होता है, जब तक आप goog.defineClass या class कीवर्ड का इस्तेमाल न करें, जो दोनों डिफ़ॉल्ट रूप से @struct क्लास बनाते हैं.

उदाहरण के लिए:

/**
 * @constructor
 * @unrestricted
 */
function Foo(x) {
  this.x = x;
}
var obj1 = new Foo(123);
var someVar = obj1.x;  // OK
obj1.x = "qwerty";  // OK
obj1['x'] = "asdf";  // OK
obj1.y = 5;  // OK