ทำเครื่องหมายเมธอดเป็นนามธรรม คล้ายกับการตั้งค่าเมธอดเป็น goog.abstractMethod คอมไพเลอร์สามารถตัดเมธอดที่มีคำอธิบายประกอบด้วย @abstract เพื่อลดขนาดโค้ดได้

คอมไพเลอร์จะแสดงคำเตือนหากเมธอดที่ทำเครื่องหมายด้วย @abstract มีการใช้งานที่ไม่ว่างเปล่า

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

ทำเครื่องหมายตัวแปรเป็นแบบอ่านอย่างเดียว คอมไพเลอร์สามารถ แทรกตัวแปร @const ซึ่งจะเพิ่มประสิทธิภาพโค้ด JavaScript

การประกาศประเภทเป็นแบบไม่บังคับ

คอมไพเลอร์จะแสดงคำเตือนหากมีการกำหนดค่าให้กับตัวแปรที่ทำเครื่องหมายด้วย @const มากกว่า 1 ครั้ง หาก ตัวแปรเป็นออบเจ็กต์ โปรดทราบว่าคอมไพเลอร์ไม่ได้ห้าม การเปลี่ยนแปลงพร็อพเพอร์ตี้ของออบเจ็กต์

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

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

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

ทำเครื่องหมายฟังก์ชันเป็นตัวสร้าง คอมไพเลอร์ต้องมีคำอธิบายประกอบ @constructor สำหรับฟังก์ชัน ใดก็ตามที่ใช้กับคีย์เวิร์ด new

เช่น

/**
 * 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 ต้อง ตามด้วยนิพจน์ประเภท

ป้ายกำกับประเภทของ Enum จะมีผลกับพร็อพเพอร์ตี้แต่ละรายการของ Enum เช่น หากการแจงนับมีประเภท number พร็อพเพอร์ตี้ที่แจงนับแต่ละรายการต้องเป็นตัวเลข หากไม่ระบุประเภทของ Enum ระบบจะถือว่าค่าเป็น 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() ของ Closure Library

เช่น

/**
 * 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} หมายถึง "ตัวสร้าง 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 ดังตัวอย่างที่ 2 คุณจะใช้ทางลัดนี้ได้เฉพาะในที่ที่ประกาศตัวแปรหรือพารามิเตอร์ฟังก์ชันเท่านั้น หากต้องการปรับประเภทในภายหลัง คุณจะต้องใช้การแคสต์ประเภท

เช่น

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

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

ประกาศชื่อแทนสำหรับประเภทที่ซับซ้อนกว่า ปัจจุบันสามารถกำหนด typedef ได้ที่ระดับบนสุดเท่านั้น ไม่ใช่ภายในฟังก์ชัน เราได้แก้ไขข้อจำกัดนี้ใน การอนุมานประเภทใหม่แล้ว

เช่น

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

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

ระบุว่าคลาสไม่ใช่ประเภท @struct และไม่ใช่ประเภท @dict นี่คือค่าเริ่มต้น ดังนั้นโดยทั่วไปจึง ไม่จำเป็นต้องเขียนอย่างชัดเจน เว้นแต่คุณจะใช้คีย์เวิร์ด class ซึ่งทั้ง 2 คีย์เวิร์ด จะสร้างคลาสที่เป็น @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