การรวบรวมขั้นสูง

ภาพรวม

การใช้ Closure Compiler กับ compilation_level of ADVANCED_OPTIMIZATIONS จะให้อัตราการบีบอัดที่ดีกว่า การคอมไพล์ด้วย SIMPLE_OPTIMIZATIONS หรือ WHITESPACE_ONLY การคอมไพล์ ด้วย ADVANCED_OPTIMIZATIONS จะบีบอัดเพิ่มเติมได้โดย การเพิ่มความเข้มงวดในวิธีที่ใช้แปลงโค้ดและเปลี่ยนชื่อ สัญลักษณ์ อย่างไรก็ตาม วิธีการที่เข้มงวดมากขึ้นนี้หมายความว่าคุณต้อง ระมัดระวังมากขึ้นเมื่อใช้ ADVANCED_OPTIMIZATIONS เพื่อให้มั่นใจว่าโค้ดเอาต์พุตทำงานในลักษณะเดียวกับโค้ดอินพุต

บทแนะนำนี้จะอธิบายว่าADVANCED_OPTIMIZATIONS ระดับการคอมไพล์ทำอะไรได้บ้าง และสิ่งที่คุณทำได้เพื่อให้แน่ใจว่าโค้ดจะ ทำงานได้หลังจากการคอมไพล์ด้วย ADVANCED_OPTIMIZATIONS นอกจากนี้ ยังแนะนำแนวคิดของ extern ซึ่งเป็นสัญลักษณ์ที่กำหนดไว้ในโค้ดภายนอกโค้ดที่คอมไพเลอร์ประมวลผล

ก่อนอ่านบทแนะนำนี้ คุณควรคุ้นเคยกับกระบวนการ คอมไพล์ JavaScript ด้วยเครื่องมือ Closure Compiler อย่างใดอย่างหนึ่ง เช่น แอปพลิเคชันคอมไพเลอร์ที่ใช้ Java

หมายเหตุเกี่ยวกับคำศัพท์: --compilation_levelแฟล็กบรรทัดคำสั่ง รองรับตัวย่อที่ใช้กันโดยทั่วไปอย่าง ADVANCED และ SIMPLE รวมถึงตัวย่อที่แม่นยำกว่าอย่าง ADVANCED_OPTIMIZATIONS และ SIMPLE_OPTIMIZATIONS เอกสารนี้ใช้รูปแบบที่ยาวกว่า แต่คุณอาจใช้ชื่อแทนกันในบรรทัดคำสั่งได้

1. การบีบอัดที่ดียิ่งขึ้น
2. วิธี เปิดใช้ ADVANCED_OPTIMIZATIONS
3. สิ่งที่ควรระวังเมื่อ ใช้ ADVANCED_OPTIMIZATIONS
   1. การนำโค้ดที่คุณต้องการเก็บไว้ออก
   2. ชื่อที่พักไม่สอดคล้องกัน
   3. การคอมไพล์โค้ด 2 ส่วน แยกกัน
   4. การอ้างอิงที่เสียระหว่างโค้ดที่คอมไพล์แล้วกับโค้ดที่ยังไม่ได้คอมไพล์

การบีบอัดที่ดียิ่งขึ้น

เมื่อใช้ระดับการคอมไพล์เริ่มต้น ของ SIMPLE_OPTIMIZATIONS ตัวคอมไพเลอร์ Closure จะทำให้ JavaScript มีขนาดเล็กลงโดยการเปลี่ยนชื่อตัวแปรภายใน อย่างไรก็ตาม มีสัญลักษณ์ อื่นๆ นอกเหนือจากตัวแปรภายในที่ย่อได้ และมีวิธี ย่อโค้ดนอกเหนือจากการเปลี่ยนชื่อสัญลักษณ์ การคอมไพล์ ด้วย ADVANCED_OPTIMIZATIONS จะใช้ประโยชน์จากความเป็นไปได้ทั้งหมดในการ ลดขนาดโค้ด

เปรียบเทียบเอาต์พุตสำหรับ SIMPLE_OPTIMIZATIONS และ ADVANCED_OPTIMIZATIONS สำหรับโค้ดต่อไปนี้

function unusedFunction(note) {
  alert(note['text']);
}

function displayNoteTitle(note) {
  alert(note['title']);
}

var flowerNote = {};
flowerNote['title'] = "Flowers";
displayNoteTitle(flowerNote);

การคอมไพล์ด้วย SIMPLE_OPTIMIZATIONS จะย่อ โค้ดเป็นดังนี้

function unusedFunction(a){alert(a.text)}function displayNoteTitle(a){alert(a.title)}var flowerNote={};flowerNote.title="Flowers";displayNoteTitle(flowerNote);

การคอมไพล์ด้วย ADVANCED_OPTIMIZATIONS จะย่อโค้ด ให้เหลือเพียงเท่านี้

alert("Flowers");

ทั้ง 2 สคริปต์นี้จะสร้างการแจ้งเตือนที่อ่านว่า "Flowers", แต่สคริปต์ที่ 2 จะมีขนาดเล็กกว่ามาก

ระดับ ADVANCED_OPTIMIZATIONS มีความซับซ้อนมากกว่าการย่อชื่อตัวแปรแบบง่ายๆ ในหลายๆ ด้าน เช่น

• การเปลี่ยนชื่อที่เข้มงวดมากขึ้น:

  การคอมไพล์ด้วย SIMPLE_OPTIMIZATIONS เท่านั้น จะเปลี่ยนชื่อพารามิเตอร์ note ของ ฟังก์ชัน displayNoteTitle() และ unusedFunction() เนื่องจากพารามิเตอร์เหล่านี้เป็น ตัวแปรเดียวในสคริปต์ที่อยู่ในฟังก์ชัน ADVANCED_OPTIMIZATIONS ยังเปลี่ยนชื่อ ตัวแปรส่วนกลางflowerNoteด้วย

• การนำโค้ดที่ไม่ได้ใช้แล้วออก:

  การคอมไพล์ด้วย ADVANCED_OPTIMIZATIONS จะนำ ฟังก์ชัน unusedFunction() ออกทั้งหมด เนื่องจากไม่มีการเรียกใช้ในโค้ด เลย

• การแทรกฟังก์ชัน:

  การคอมไพล์ด้วย ADVANCED_OPTIMIZATIONS จะแทนที่ การเรียกใช้ displayNoteTitle() ด้วย alert() เดียวที่ประกอบเป็นเนื้อหา ของฟังก์ชัน การแทนที่การเรียกฟังก์ชันด้วยเนื้อหาของฟังก์ชัน นี้เรียกว่า "การแทรกโค้ด" หากฟังก์ชันยาวขึ้นหรือซับซ้อนมากขึ้น การแทรกอินไลน์อาจเปลี่ยนลักษณะการทำงานของโค้ด แต่ Closure Compiler ระบุว่าในกรณีนี้ การแทรกอินไลน์ ปลอดภัยและประหยัดพื้นที่ การคอมไพล์ ด้วย ADVANCED_OPTIMIZATIONS ยังฝังค่าคงที่ และตัวแปรบางรายการเมื่อพิจารณาแล้วว่าทำได้อย่าง ปลอดภัย

รายการนี้เป็นเพียงตัวอย่างของการแปลงที่ลดขนาด ที่การคอมไพล์ ADVANCED_OPTIMIZATIONS สามารถทำได้

วิธีเปิดใช้ ADVANCED_OPTIMIZATIONS

หากต้องการเปิดใช้ ADVANCED_OPTIMIZATIONS สำหรับแอปพลิเคชัน Closure Compiler ให้ใส่ Flag บรรทัดคำสั่ง --compilation_level ADVANCED_OPTIMIZATIONS ดังใน คำสั่งต่อไปนี้

java -jar compiler.jar --compilation_level ADVANCED_OPTIMIZATIONS --js hello.js

สิ่งที่ควรระวังเมื่อใช้ ADVANCED_OPTIMIZATIONS

ด้านล่างนี้คือผลลัพธ์ที่ไม่พึงประสงค์ที่พบบ่อยบางส่วน ของ ADVANCED_OPTIMIZATIONS และขั้นตอนที่คุณทำได้เพื่อหลีกเลี่ยง

การนำโค้ดที่คุณต้องการเก็บไว้ออก

หากคุณคอมไพล์เฉพาะฟังก์ชันด้านล่าง ด้วย ADVANCED_OPTIMIZATIONS, Closure Compiler จะสร้าง เอาต์พุตที่ว่างเปล่า

function displayNoteTitle(note) {
  alert(note['myTitle']);
}

เนื่องจากไม่มีการเรียกใช้ฟังก์ชันใน JavaScript ที่คุณส่งไปยังคอมไพเลอร์ Closure Compiler จึงถือว่าไม่จำเป็นต้องใช้โค้ดนี้

ในหลายๆ กรณี ลักษณะการทำงานนี้เป็นสิ่งที่คุณต้องการ ตัวอย่างเช่น หากคุณคอมไพล์โค้ดร่วมกับไลบรารีขนาดใหญ่ Closure Compiler จะ ระบุได้ว่าคุณใช้ฟังก์ชันใดจากไลบรารีนั้นจริง และทิ้งฟังก์ชันที่คุณไม่ได้ใช้

อย่างไรก็ตาม หากพบว่า Closure Compiler นำฟังก์ชันที่คุณต้องการเก็บออก คุณสามารถป้องกันไม่ให้เกิดเหตุการณ์นี้ได้ 2 วิธีดังนี้

• ย้ายการเรียกฟังก์ชันไปยังโค้ดที่ Closure Compiler ประมวลผล
• รวมไฟล์ภายนอกสำหรับฟังก์ชันที่ต้องการเปิดเผย

ส่วนถัดไปจะอธิบายแต่ละตัวเลือกโดยละเอียด

วิธีแก้ปัญหา: ย้ายการเรียกใช้ฟังก์ชันไปยังโค้ด ที่คอมไพเลอร์ Closure ประมวลผล

คุณอาจพบการนำโค้ดที่ไม่ต้องการออกหากคอมไพล์โค้ดเพียงบางส่วนด้วย Closure Compiler เช่น คุณอาจมีไฟล์ไลบรารีที่มีเฉพาะคำจำกัดความของฟังก์ชัน และไฟล์ HTML ที่มีไลบรารีและมีโค้ดที่เรียกใช้ฟังก์ชันเหล่านั้น ในกรณีนี้ หากคุณคอมไพล์ไฟล์ไลบรารีด้วย ADVANCED_OPTIMIZATIONS Closure Compiler จะนำฟังก์ชันไลบรารีทั้งหมดออก

วิธีแก้ปัญหานี้ที่ง่ายที่สุดคือการคอมไพล์ฟังก์ชัน พร้อมกับส่วนของโปรแกรมที่เรียกใช้ฟังก์ชันเหล่านั้น ตัวอย่างเช่น Closure Compiler จะไม่นำ displayNoteTitle() ออกเมื่อคอมไพล์โปรแกรมต่อไปนี้

function displayNoteTitle(note) {
  alert(note['myTitle']);
}
displayNoteTitle({'myTitle': 'Flowers'});

ฟังก์ชัน displayNoteTitle() จะไม่ถูกนำออกในกรณีนี้เนื่องจาก Closure Compiler เห็นว่ามีการเรียกใช้ฟังก์ชันดังกล่าว

กล่าวคือ คุณป้องกันไม่ให้ระบบนำโค้ดที่ไม่ต้องการออกได้โดยใส่จุดแรกเข้าของโปรแกรมไว้ในโค้ดที่ส่งไปยัง Closure Compiler จุดแรกเข้าของโปรแกรมคือตำแหน่งในโค้ดที่โปรแกรมเริ่มดำเนินการ ตัวอย่างเช่น ในโปรแกรมโน้ตดอกไม้จากส่วนก่อนหน้า ระบบจะเรียกใช้ 3 บรรทัดสุดท้ายทันทีที่โหลด JavaScript ในเบราว์เซอร์ นี่คือจุดเริ่มต้นของโปรแกรมนี้ หากต้องการ พิจารณาว่าต้องเก็บโค้ดใดไว้ Closure Compiler จะเริ่มที่ จุดแรกเข้าและติดตามโฟลว์การควบคุมของโปรแกรมไปข้างหน้าจาก จุดนั้น

วิธีแก้ปัญหา: ใส่ Externs สำหรับฟังก์ชันที่ต้องการเปิดเผย

ดูข้อมูลเพิ่มเติมเกี่ยวกับโซลูชันนี้ได้ด้านล่าง และในหน้าเกี่ยวกับการฝึกงานและการส่งออก

ชื่อที่พักไม่สอดคล้องกัน

การคอมไพล์ Closure Compiler จะไม่เปลี่ยนแปลงสตริงลิเทอรัลในโค้ด ไม่ว่าคุณจะใช้ระดับการคอมไพล์ใดก็ตาม ซึ่งหมายความว่าการคอมไพล์ ด้วย ADVANCED_OPTIMIZATIONS จะถือว่าพร็อพเพอร์ตี้แตกต่างกัน ขึ้นอยู่กับว่าโค้ดของคุณเข้าถึงพร็อพเพอร์ตี้เหล่านั้นด้วยสตริงหรือไม่ หากคุณผสมการอ้างอิงสตริงกับพร็อพเพอร์ตี้กับการอ้างอิงแบบไวยากรณ์จุด Closure Compiler จะเปลี่ยนชื่อการอ้างอิงบางรายการไปยังพร็อพเพอร์ตี้นั้น แต่จะไม่เปลี่ยนชื่อรายการอื่นๆ ด้วยเหตุนี้ โค้ดของคุณจึงอาจทำงานไม่ถูกต้อง

ตัวอย่างเช่น ลองดูโค้ดต่อไปนี้

function displayNoteTitle(note) {
  alert(note['myTitle']);
}
var flowerNote = {};
flowerNote.myTitle = 'Flowers';

alert(flowerNote.myTitle);
displayNoteTitle(flowerNote);

คำสั่ง 2 รายการสุดท้ายในซอร์สโค้ดนี้ทํางานเหมือนกันทุกประการ อย่างไรก็ตาม เมื่อบีบอัดโค้ด ด้วย ADVANCED_OPTIMIZATIONS คุณจะได้รับผลลัพธ์ดังนี้

var a={};a.a="Flowers";alert(a.a);alert(a.myTitle);

คำสั่งสุดท้ายในโค้ดที่บีบอัดจะทำให้เกิดข้อผิดพลาด เราได้เปลี่ยนชื่อการอ้างอิงโดยตรงไปยังพร็อพเพอร์ตี้ myTitle เป็น a แล้ว แต่การอ้างอิงที่ยกมาถึง myTitle ภายในฟังก์ชัน displayNoteTitle ยังไม่ได้ เปลี่ยนชื่อ ด้วยเหตุนี้ ข้อความสุดท้ายจึงอ้างอิงถึงพร็อพเพอร์ตี้ myTitle ที่ไม่มีอยู่อีกต่อไป

วิธีแก้ไข: ตั้งชื่อพร็อพเพอร์ตี้ให้สอดคล้องกัน

โซลูชันนี้ค่อนข้างง่าย สำหรับออบเจ็กต์หรือประเภทใดก็ตาม ให้ใช้ไวยากรณ์แบบจุด หรือสตริงที่ยกมาเท่านั้น อย่าใช้ไวยากรณ์ผสมกัน โดยเฉพาะอย่างยิ่งในการอ้างอิง พร็อพเพอร์ตี้เดียวกัน

นอกจากนี้ หากเป็นไปได้ ให้ใช้ไวยากรณ์แบบจุด เนื่องจากรองรับการตรวจสอบและการเพิ่มประสิทธิภาพได้ดีกว่า ใช้การเข้าถึงพร็อพเพอร์ตี้สตริงที่ยกมาเฉพาะในกรณีที่คุณไม่ต้องการให้ Closure Compiler เปลี่ยนชื่อ เช่น เมื่อชื่อมาจากแหล่งที่มาภายนอก เช่น JSON ที่ถอดรหัสแล้ว

การคอมไพล์โค้ด 2 ส่วนแยกกัน

หากคุณแยกแอปพลิเคชันออกเป็นโค้ดหลายๆ ส่วน คุณอาจต้องการคอมไพล์แต่ละส่วนแยกกัน อย่างไรก็ตาม หากโค้ด 2 กลุ่ม มีการโต้ตอบกัน การทำเช่นนี้อาจทำให้เกิดปัญหาได้ แม้ว่าคุณจะ ทำได้ แต่เอาต์พุตของการเรียกใช้ Closure Compiler ทั้ง 2 ครั้งจะใช้ร่วมกันไม่ได้

ตัวอย่างเช่น สมมติว่าแอปพลิเคชันแบ่งออกเป็น 2 ส่วน ได้แก่ ส่วนที่ดึงข้อมูล และส่วนที่แสดงข้อมูล

โค้ดสำหรับการดึงข้อมูลมีดังนี้

function getData() {
  // In an actual project, this data would be retrieved from the server.
  return {title: 'Flower Care', text: 'Flowers need water.'};
}

โค้ดสําหรับแสดงข้อมูลมีดังนี้

var displayElement = document.getElementById('display');
function displayData(parent, data) {
  var textElement = document.createTextNode(data.text);
  parent.appendChild(textElement);
}
displayData(displayElement, getData());

หากพยายามคอมไพล์โค้ด 2 ส่วนนี้แยกกัน คุณจะพบปัญหาหลายอย่าง ก่อนอื่น Closure Compiler จะนำgetData()ฟังก์ชันออกด้วยเหตุผลที่อธิบายไว้ในการนำโค้ดที่ต้องการเก็บไว้ออก ประการที่สอง Closure Compiler จะสร้างข้อผิดพลาดร้ายแรงเมื่อประมวลผลโค้ด ที่แสดงข้อมูล

input:6: ERROR - variable getData is undefined
displayData(displayElement, getData());

เนื่องจากคอมไพเลอร์ไม่มีสิทธิ์เข้าถึงฟังก์ชัน getData() เมื่อคอมไพล์โค้ดที่แสดงข้อมูล คอมไพเลอร์จึง ถือว่า getData ไม่ได้กำหนดไว้

วิธีแก้ไข: รวบรวมโค้ดทั้งหมดสำหรับหน้าเว็บไว้ด้วยกัน

คอมไพล์โค้ดทั้งหมดของหน้าเว็บพร้อมกันในการคอมไพล์ครั้งเดียวเพื่อให้มั่นใจว่าการคอมไพล์จะถูกต้อง Closure Compiler รับไฟล์ JavaScript และสตริง JavaScript หลายรายการเป็นอินพุตได้ คุณจึงส่งโค้ดไลบรารีและโค้ดอื่นๆ พร้อมกันในคำขอการคอมไพล์เดียวได้

หมายเหตุ: วิธีนี้จะใช้ไม่ได้หากคุณต้องการผสมโค้ดที่คอมไพล์แล้วและโค้ดที่ยังไม่ได้คอมไพล์ ดูเคล็ดลับในการจัดการสถานการณ์นี้ได้ที่การอ้างอิงที่เสียระหว่างโค้ดที่คอมไพล์แล้วกับโค้ดที่ยังไม่ได้คอมไพล์

การอ้างอิงที่เสียระหว่างโค้ดที่คอมไพล์แล้วกับโค้ดที่ยังไม่ได้คอมไพล์

การเปลี่ยนชื่อสัญลักษณ์ใน ADVANCED_OPTIMIZATIONS จะทำให้การสื่อสารระหว่างโค้ดที่ Closure Compiler ประมวลผลกับโค้ดอื่นๆ ใช้ไม่ได้ การคอมไพล์จะเปลี่ยนชื่อฟังก์ชันที่กำหนดไว้ในซอร์สโค้ด โค้ดภายนอกที่เรียกใช้ฟังก์ชันจะหยุดทำงานหลังจากที่คุณคอมไพล์ เนื่องจากโค้ดยังคงอ้างอิงชื่อฟังก์ชันเก่า ในทำนองเดียวกัน การอ้างอิงในโค้ดที่คอมไพล์ไปยังสัญลักษณ์ที่กำหนดภายนอกอาจ เปลี่ยนแปลงโดย Closure Compiler

โปรดทราบว่า "โค้ดที่ยังไม่ได้คอมไพล์" รวมถึงโค้ดที่ส่งไปยังฟังก์ชัน eval() เป็นสตริง Closure Compiler จะไม่เปลี่ยนแปลง สตริงลิเทอรัลในโค้ด ดังนั้น Closure Compiler จึงไม่เปลี่ยนสตริงที่ส่งไปยัง คำสั่ง eval()

โปรดทราบว่าปัญหาเหล่านี้มีความเกี่ยวข้องแต่แตกต่างกัน ได้แก่ การรักษา การสื่อสารที่คอมไพล์แล้วกับภายนอก และการรักษา การสื่อสารจากภายนอกไปยังที่คอมไพล์แล้ว ปัญหาที่แยกกันเหล่านี้มีวิธีแก้ปัญหา ร่วมกัน แต่ก็มีรายละเอียดปลีกย่อยในแต่ละด้าน คุณควรทำความเข้าใจกรณีที่คุณมีเพื่อช่วยให้ได้รับประโยชน์สูงสุดจาก Closure Compiler

ก่อนดำเนินการต่อ คุณอาจต้องทำความคุ้นเคยกับ extern และ exports

โซลูชันสำหรับการเรียกใช้โค้ดภายนอกจากโค้ดที่คอมไพล์แล้ว: การคอมไพล์ด้วย Externs

หากคุณใช้โค้ดที่สคริปต์อื่นใส่ไว้ในหน้าเว็บ คุณต้องตรวจสอบว่า Closure Compiler ไม่ได้เปลี่ยนชื่อการอ้างอิงของคุณเป็นสัญลักษณ์ที่กำหนดไว้ในไลบรารีภายนอกนั้น โดยใส่ไฟล์ที่มี Externs สำหรับไลบรารีภายนอกลงในการคอมไพล์ ซึ่งจะบอก Closure Compiler ว่าชื่อใดที่คุณควบคุมไม่ได้และ จึงไม่สามารถเปลี่ยนแปลงได้ โค้ดต้องใช้ชื่อเดียวกันกับที่ไฟล์ภายนอกใช้

ตัวอย่างที่พบบ่อยของ API ประเภทนี้ ได้แก่ OpenSocial API และ Google Maps API เช่น หากโค้ดเรียกใช้ฟังก์ชัน OpenSocial opensocial.newDataRequest() โดยไม่มีไฟล์ภายนอกที่เหมาะสม Closure Compiler จะแปลง การเรียกนี้เป็น a.b()

โซลูชันสำหรับการเรียกใช้โค้ดที่คอมไพล์จาก โค้ดภายนอก: การใช้ Externs

หากมีโค้ด JavaScript ที่นำกลับมาใช้ใหม่เป็นไลบรารี คุณอาจต้องการ ใช้ Closure Compiler เพื่อลดขนาดเฉพาะไลบรารี ในขณะที่ยังอนุญาตให้ โค้ดที่ไม่ได้คอมไพล์เรียกใช้ฟังก์ชันในไลบรารีได้

วิธีแก้ปัญหาในกรณีนี้คือการใช้ชุดไฟล์ภายนอกที่กำหนด API สาธารณะของไลบรารี โค้ดของคุณจะให้คำจำกัดความ สำหรับสัญลักษณ์ที่ประกาศไว้ในไฟล์ภายนอกเหล่านี้ ซึ่งหมายถึงคลาสหรือฟังก์ชันใดๆ ที่ฟังก์ชันภายนอกของคุณกล่าวถึง นอกจากนี้ยังอาจหมายถึงการมีคลาส ที่ใช้การประกาศอินเทอร์เฟซในไฟล์ภายนอก

การฝึกงานเหล่านี้มีประโยชน์ต่อผู้อื่นด้วย ไม่ใช่แค่ตัวคุณเอง ผู้ใช้ไลบรารีของคุณจะต้องรวมไฟล์เหล่านี้ไว้ด้วยหากคอมไพล์โค้ด เนื่องจากไลบรารีของคุณแสดงถึงสคริปต์ภายนอกจากมุมมองของผู้ใช้ ให้คิดว่าเอกสารการฝึกงานเป็นสัญญาที่ทำระหว่างคุณกับผู้บริโภค ซึ่งทั้ง 2 ฝ่ายต้องมีสำเนา

ดังนั้น เมื่อคอมไพล์โค้ด โปรดตรวจสอบว่าได้รวม ไฟล์ภายนอกไว้ในการคอมไพล์ด้วย ซึ่งอาจดูแปลกเนื่องจากเรามักคิดว่า Externs "มาจากที่อื่น" แต่จำเป็นต้องบอก Closure Compiler ว่าคุณกำลังเปิดเผยสัญลักษณ์ใดเพื่อไม่ให้มีการเปลี่ยนชื่อ

ข้อควรระวังที่สำคัญอย่างหนึ่งคือคุณอาจได้รับข้อความวินิจฉัย "คำจำกัดความซ้ำ" เกี่ยวกับโค้ดที่กำหนดสัญลักษณ์ภายนอก Closure Compiler ถือว่าสัญลักษณ์ใดๆ ในไฟล์ภายนอกมาจากไลบรารีภายนอก และปัจจุบันไม่สามารถเข้าใจว่าคุณตั้งใจให้คำจำกัดความ คุณระงับการวินิจฉัยเหล่านี้ได้อย่างปลอดภัย และการระงับถือเป็นการยืนยันว่าคุณกำลังใช้ API จริงๆ

นอกจากนี้ Closure Compiler ยังอาจตรวจสอบประเภทเพื่อให้แน่ใจว่าคำจำกัดความของคุณตรงกับ ประเภทของการประกาศภายนอก ซึ่งจะช่วยยืนยันเพิ่มเติม ว่าคำจำกัดความของคุณถูกต้อง