Menandai metode sebagai abstrak. Mirip dengan menyetel metode ke goog.abstractMethod, compiler dapat memangkas metode yang dianotasi dengan @abstract untuk mengurangi ukuran kode.

Compiler akan menghasilkan peringatan jika metode yang ditandai dengan @abstract memiliki implementasi yang tidak kosong.

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

Menandai variabel sebagai hanya baca. Compiler dapat menggabungkan variabel @const, yang mengoptimalkan kode JavaScript.

Deklarasi jenis bersifat opsional.

Compiler akan menghasilkan peringatan jika variabel yang ditandai dengan @const diberi nilai lebih dari sekali. Jika variabel adalah objek, perhatikan bahwa compiler tidak melarang perubahan pada properti objek.

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

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

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

Menandai fungsi sebagai konstruktor. Compiler memerlukan anotasi @constructor untuk setiap fungsi yang digunakan dengan kata kunci new

Contoh:

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

Contoh:

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

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

Menandai fungsi, metode, atau properti sehingga penggunaannya akan menghasilkan peringatan compiler yang menunjukkan bahwa fungsi, metode, atau properti tersebut tidak boleh digunakan lagi.

Contoh:

/**
 * 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 digunakan untuk membuat objek dengan jumlah properti yang bervariasi. Jika konstruktor (Foo dalam contoh) dianotasikan dengan @dict, Anda hanya dapat menggunakan notasi kurung untuk mengakses properti objek Foo. Anotasi juga dapat digunakan langsung pada literal objek.

Contoh:

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

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

Menentukan jenis enum. Enum adalah objek yang propertinya membentuk serangkaian konstanta terkait. Tag @enum harus diikuti dengan ekspresi jenis.

Label jenis enum berlaku untuk setiap properti enum. Misalnya, jika enum memiliki jenis number, setiap properti yang di-enum harus berupa angka. Jika jenis enum tidak ditentukan, number akan diasumsikan.

Contoh:

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

Mengingat kode ini

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

saat compiler dijalankan dengan tanda --generate_exports, compiler akan membuat kode:

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

yang akan mengekspor simbol ke kode yang tidak dikompilasi. Anda dapat menulis /** @export {SomeType} */ sebagai singkatan dari

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

Kode yang menggunakan anotasi @export harus

1. mencakup closure/base.js, atau
2. menentukan goog.exportSymbol dan goog.exportProperty dengan tanda tangan metode yang sama dalam codebase-nya sendiri.

Menandai class atau antarmuka sebagai mewarisi dari class lain. Class yang ditandai dengan @extends juga harus ditandai dengan @constructor atau @interface.

Catatan: @extends tidak menyebabkan kelas mewarisi dari kelas lain. Anotasi ini hanya memberi tahu compiler bahwa compiler dapat memperlakukan satu class sebagai subclass dari class lain selama pemeriksaan jenis.

Untuk contoh implementasi pewarisan, lihat fungsi Closure Library goog.inherits().

Contoh:

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

Menunjukkan bahwa class ini tidak boleh diperluas. Untuk metode, menunjukkan bahwa tidak ada subclass yang diizinkan untuk mengganti metode tersebut.

Contoh:

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

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

Digunakan dengan @constructor untuk menunjukkan bahwa class mengimplementasikan antarmuka.

Compiler akan menampilkan peringatan jika Anda memberi tag pada konstruktor dengan @implements, tetapi gagal menerapkan semua metode dan properti yang ditentukan oleh antarmuka.

Contoh:

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

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

Anotasi ini hanya dapat muncul dalam deklarasi properti externs. Properti memiliki jenis yang dideklarasikan, tetapi Anda dapat menetapkan jenis apa pun ke properti tersebut tanpa peringatan. Saat mengakses properti, Anda akan mendapatkan kembali nilai jenis yang dideklarasikan. Misalnya, element.innerHTML dapat ditetapkan ke jenis apa pun, tetapi akan selalu menampilkan string.

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

Menunjukkan bahwa metode atau properti subclass dengan sengaja menyembunyikan metode atau properti superclass, dan memiliki dokumentasi yang sama persis. Perhatikan bahwa tag @inheritDoc menyiratkan tag @override.

Contoh:

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

Menandai fungsi sebagai antarmuka. Antarmuka menentukan anggota yang diperlukan dari suatu jenis. Setiap class yang mengimplementasikan antarmuka harus mengimplementasikan semua metode dan properti yang ditentukan pada prototipe antarmuka. Lihat @implements.

Compiler memverifikasi bahwa antarmuka tidak di-instansiasi. Jika kata kunci new digunakan dengan fungsi antarmuka, compiler akan menghasilkan peringatan.

Contoh:

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

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

Menunjukkan bahwa kunci literal objek harus diperlakukan sebagai properti objek lain. Anotasi ini hanya boleh muncul pada literal objek.

Perhatikan bahwa nama dalam tanda kurung bukan nama jenis seperti dalam anotasi lainnya. Ini adalah nama objek. Objek yang dipinjamkan propertinya. Misalnya, @type {Foo} berarti "instance Foo", tetapi @lends {Foo} berarti "konstruktor Foo".

Dokumen JSDoc Toolkit memiliki informasi selengkapnya tentang anotasi ini.

Contoh:

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

Memberi tahu compiler untuk menyisipkan komentar terkait sebelum kode yang dikompilasi untuk file yang ditandai. Anotasi ini memungkinkan pemberitahuan penting (seperti lisensi hukum atau teks hak cipta) untuk tetap tidak berubah setelah kompilasi. Pemisah baris akan dipertahankan.

Contoh:

/**
 * @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:
 */

Menunjukkan properti yang tidak boleh diciutkan oleh compiler menjadi variabel. Penggunaan utama @nocollapse adalah untuk mengizinkan pengeksporan properti yang dapat diubah. Perhatikan bahwa properti yang tidak diciutkan masih dapat diganti namanya oleh compiler. Jika Anda menganotasi properti yang merupakan objek dengan @nocollapse, semua propertinya juga akan tetap tidak diciutkan.

Contoh:

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

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

window['foobar'] = foo.bar;

Menunjukkan bahwa panggilan ke fungsi eksternal yang dideklarasikan tidak memiliki efek samping. Anotasi ini memungkinkan compiler menghapus panggilan ke fungsi jika nilai yang ditampilkan tidak digunakan. Anotasi hanya diizinkan di extern files.

Contoh:

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

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

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

Menunjukkan bahwa metode atau properti subclass sengaja menyembunyikan metode atau properti superclass. Jika tidak ada anotasi lain yang disertakan, metode atau properti akan otomatis mewarisi anotasi dari superclass-nya.

Contoh:

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

Menandai anggota atau properti sebagai pribadi paket. Hanya kode di direktori yang sama yang dapat mengakses nama yang ditandai @package. Khususnya, kode di direktori induk dan turunan tidak dapat mengakses nama yang ditandai @package.

Konstruktor publik dapat memiliki properti @package untuk membatasi metode yang dapat digunakan pemanggil di luar direktori. Di sisi lain, konstruktor @package dapat memiliki properti publik untuk mencegah pemanggil di luar direktori membuat instance jenis secara langsung.

Contoh:

/**
 * 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() {
  // ...
};

Digunakan dengan definisi metode, fungsi, dan konstruktor untuk menentukan jenis argumen fungsi. Tag @param harus dalam urutan yang sama dengan parameter dalam definisi fungsi.

Tag @param harus diikuti dengan ekspresi jenis.

Atau, Anda dapat menganotasi jenis parameter secara inline (lihat fungsi foo dalam contoh).

Contoh:

/**
 * 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`);
}

Menandai anggota sebagai pribadi. Hanya kode dalam file yang sama yang dapat mengakses variabel dan fungsi global yang ditandai @private. Konstruktor yang ditandai @private hanya dapat di-instansiasi oleh kode dalam file yang sama dan oleh anggota statis dan instance-nya.

Properti statis publik konstruktor yang ditandai @private juga dapat diakses di mana saja, dan operator instanceof selalu dapat mengakses anggota @private.

Contoh:

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

Menunjukkan bahwa anggota atau properti dilindungi.

Properti yang ditandai @protected dapat diakses oleh:

• semua kode dalam file yang sama
• metode statis dan metode instance dari subclass class tempat properti ditentukan.

Contoh:

/**
 * 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) {
  // ...
};

Menandai fungsi sebagai antarmuka struktural. Antarmuka struktural mirip dengan @interface nominal, tetapi memungkinkan penerapan implisit. Artinya, setiap class yang mencakup metode dan properti yang ditentukan pada prototipe antarmuka struktural mengimplementasikan antarmuka struktural, terlepas dari apakah class tersebut menggunakan tag @implements atau tidak. Jenis rekaman dan literal objek juga secara implisit menerapkan antarmuka struktural jika berisi properti yang diperlukan.

Contoh:

/**
 * 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);

Menentukan jenis nilai yang ditampilkan dari definisi metode dan fungsi. Tag @return harus diikuti dengan ekspresi jenis.

Atau, Anda dapat menganotasi jenis nilai yang ditampilkan secara inline (lihat fungsi foo dalam contoh).

Jika fungsi yang tidak ada di externs tidak memiliki nilai yang ditampilkan, Anda dapat menghilangkan tag @return, dan compiler akan mengasumsikan bahwa fungsi tersebut menampilkan undefined.

Contoh:

/**
 * 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 digunakan untuk membuat objek dengan jumlah properti yang tetap. Saat konstruktor (Foo dalam contoh) diberi anotasi dengan @struct, Anda hanya dapat menggunakan notasi titik untuk mengakses properti objek Foo, bukan notasi kurung. Selain itu, Anda tidak dapat menambahkan properti ke instance Foo setelah dibuat. Anotasi juga dapat digunakan langsung pada literal objek.

Contoh:

/**
 * @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

Lihat Jenis Generik.

Contoh:

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

Menentukan jenis objek yang dirujuk oleh kata kunci this dalam fungsi. Tag @this harus diikuti dengan ekspresi jenis.

Untuk mencegah peringatan compiler, Anda harus menggunakan anotasi @this setiap kali this muncul dalam fungsi yang bukan metode prototipe atau fungsi yang ditandai sebagai @constructor.

Contoh:

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

Digunakan untuk mendokumentasikan pengecualian yang dimunculkan oleh fungsi. Pemeriksa jenis saat ini tidak menggunakan informasi ini. Fungsi ini hanya digunakan untuk mengetahui apakah fungsi yang dideklarasikan dalam file externs memiliki efek samping.

Contoh:

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

Mengidentifikasi jenis variabel, properti, atau ekspresi. Tag @type harus diikuti dengan ekspresi jenis.

Saat mendeklarasikan parameter variabel atau fungsi, Anda dapat menulis anotasi jenis inline dengan menghilangkan {} dan @type, seperti pada contoh kedua. Cara pintas ini hanya dapat dilakukan jika parameter variabel atau fungsi dideklarasikan. Jika ingin menyesuaikan jenis nanti, Anda memerlukan pemeran jenis.

Contoh:

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

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

Mendeklarasikan alias untuk jenis yang lebih kompleks. Saat ini, typedef hanya dapat ditentukan di tingkat teratas, bukan di dalam fungsi. Kami telah memperbaiki batasan ini di inferensi jenis baru.

Contoh:

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

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

Menunjukkan bahwa class bukan jenis @struct, atau jenis @dict. Ini adalah default sehingga umumnya tidak perlu ditulis secara eksplisit, kecuali jika Anda menggunakan kata kunci class, yang keduanya menghasilkan class yang secara default adalah @struct.

Contoh:

/**
 * @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