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

ภาพรวม

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

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

ก่อนอ่านบทแนะนํานี้ คุณควรทําความเข้าใจกระบวนการรวบรวม JavaScript ด้วยเครื่องมือ Closure Compiler (UI บริการคอมไพเลอร์, คอมไพเลอร์ API บริการ หรือแอปพลิเคชันคอมไพเลอร์)

หมายเหตุเกี่ยวกับคําศัพท์: แฟล็กบรรทัดคําสั่ง --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

UI บริการ Closure Compiler, API บริการ และแอปพลิเคชันมีหลายวิธีในการตั้งค่า compilation_level เป็น ADVANCED_OPTIMIZATIONS

วิธีเปิดใช้ ADVANCED_OPTIMIZATIONS ใน UI บริการคอมไพเลอร์

หากต้องการเปิดใช้ ADVANCED_OPTIMIZATIONS สําหรับ UI ของบริการปิด Closure คลิกปุ่มปุ่มตัวเลือก "ขั้นสูง"

วิธีเปิดใช้ ADVANCED_OPTIMIZATIONS ใน Closure Compiler Service API

หากต้องการเปิดใช้ ADVANCED_OPTIMIZATIONS สําหรับ Closure Compiler Service API ให้ใส่พารามิเตอร์คําขอชื่อ compilation_level ที่มีค่าเป็น ADVANCED_OPTIMIZATIONS ดังเช่นในโปรแกรม Python ต่อไปนี้

#!/usr/bin/python2.4

import httplib, urllib, sys

params = urllib.urlencode([
    ('code_url', sys.argv[1]),
    ('compilation_level', 'ADVANCED_OPTIMIZATIONS'),
    ('output_format', 'text'),
    ('output_info', 'compiled_code'),
  ])

headers = { "Content-type": "application/x-www-form-urlencoded" }
conn = httplib.HTTPSConnection('closure-compiler.appspot.com')
conn.request('POST', '/compile', params, headers)
response = conn.getresponse()
data = response.read()
print data
conn.close()

วิธีเปิดใช้ ADVANCED_OPTIMIZATIONS ในแอปพลิเคชัน Closure Compiler

หากต้องการเปิดใช้ ADVANCED_OPTIMIZATIONS สําหรับแอปพลิเคชัน Closure Compiler ให้ใส่แฟล็กบรรทัดคําสั่ง --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 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 ระบุโค้ดที่ควรเก็บไว้ที่จุดแรกเข้านี้ และติดตามขั้นตอนการควบคุมของโปรแกรมนับจากนี้เป็นต้นไป

วิธีแก้ปัญหา: ใส่ตัวอย่างฟังก์ชันที่คุณต้องการแสดง

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

ชื่อที่พักไม่ตรงกัน

การคอมไพล์ Closure จะไม่เปลี่ยนแปลงชุดตัวอักษรตามโค้ดของคุณ แต่ไม่ใช่ระดับการรวบรวมการรวบรวม ซึ่งหมายความว่าการรวบรวมด้วย ADVANCED_OPTIMIZATIONS จะถือว่าพร็อพเพอร์ตี้แตกต่างกัน ขึ้นอยู่กับว่ารหัสของคุณเข้าถึงพร็อพเพอร์ตี้ด้วยสตริงหรือไม่ หากคุณรวมการอ้างอิงสตริงไปยังพร็อพเพอร์ตี้ที่มีการอ้างอิง Syntax ทาง 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 ที่ไม่มีอยู่อีกต่อไป

โซลูชัน: มีความสอดคล้องกันในชื่อพร็อพเพอร์ตี้ของคุณ

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

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

การรวบรวมโค้ด 2 ส่วนแยกกัน

หากแบ่งแอปพลิเคชันออกเป็นส่วนต่างๆ ของโค้ด คุณอาจต้องรวมชิ้นส่วนเป็นส่วนๆ แยกกัน อย่างไรก็ตาม หากโค้ด 2 กลุ่มทํางานรวมกันตลอดเวลา อาจทําให้มีความยุ่งยาก แม้ว่าคุณจะดําเนินการไม่สําเร็จ แต่เอาต์พุตของการคอมไพล์ Closure 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 จะนําฟังก์ชัน getData() ออก ด้วยเหตุผลที่อธิบายไว้ในการนําโค้ดที่คุณต้องการเก็บไว้ออก อย่างที่ 2 เครื่องมือ 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 จะไม่เปลี่ยนสัญพจน์ของสตริงในโค้ด ดังนั้น Cilure Compiler จะไม่เปลี่ยนสตริงที่ส่งไปยังใบแจ้งยอด eval()

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

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

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

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

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

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

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

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

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

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

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

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