โดยปกติเมื่อคุณใช้คำแนะนำใน NG ฟังก์ชั่นลิงค์ที่ใช้ส่วนใหญ่คือแอตทริบิวต์ลิงก์ บทความต่อไปนี้จะบอกคุณถึงการใช้งานและความแตกต่างระหว่างการร้องเรียนการเชื่อมโยงล่วงหน้าและโพสต์ลิงก์
คำแนะนำใน AngularJs นั้นมีมนต์ขลังมากช่วยให้คุณสร้างส่วนประกอบที่มีความหมายและนำกลับมาใช้ใหม่ได้สูงซึ่งสามารถเข้าใจได้ว่าเป็นผู้บุกเบิกส่วนประกอบของเว็บ
มีบทความและหนังสือที่เกี่ยวข้องมากมายบนอินเทอร์เน็ตที่แนะนำวิธีการใช้คำแนะนำ หากคุณเปรียบเทียบพวกเขาคุณไม่ค่อยแนะนำความแตกต่างระหว่างการคอมไพล์และลิงก์
บทช่วยสอนส่วนใหญ่บอกว่าการรวบรวมจะถูกใช้ภายใน NG และขอแนะนำให้คุณใช้แอตทริบิวต์ลิงก์เท่านั้นซึ่งเป็นกรณีในคำแนะนำส่วนใหญ่
สิ่งนี้โชคร้ายมากเพราะการทำความเข้าใจความแตกต่างระหว่างฟังก์ชั่นเหล่านี้อย่างถูกต้องจะช่วยปรับปรุงความเข้าใจของคุณเกี่ยวกับกลไกการทำงานภายในของ NG และช่วยให้คุณพัฒนาคำแนะนำที่กำหนดเองได้ดีขึ้น
ดังนั้นติดตามฉันเพื่อดูเนื้อหาต่อไปนี้ทีละขั้นตอนเพื่อทำความเข้าใจว่าฟังก์ชั่นเหล่านี้คืออะไรและควรใช้เมื่อใด
บทความนี้สันนิษฐานว่าคุณมีความเข้าใจบางอย่างเกี่ยวกับคำแนะนำ ถ้าไม่แนะนำอย่างยิ่งให้คุณอ่านบทความคู่มือผู้พัฒนา AngularJS เรื่องนี้เกี่ยวกับคำสั่ง
วิธีประมวลผลคำแนะนำใน NG
ก่อนที่จะเริ่มการวิเคราะห์ลองมาดูกันว่า NG-Chinese จัดการคำแนะนำอย่างไร
เมื่อเบราว์เซอร์แสดงหน้าหน้ามันจะอ่านตัวตน HTML เป็นหลักจากนั้นสร้างโหนด DOM และออกอากาศเหตุการณ์ให้เราหลังจากสร้างต้นไม้ DOM
เมื่อคุณใช้แท็กสคริปต์เพื่อโหลดรหัสแอปพลิเคชัน NG ในหน้า NG จะฟังเหตุการณ์ DOM ที่เสร็จสมบูรณ์ข้างต้นและค้นหาองค์ประกอบที่มีแอตทริบิวต์ NG-APP
หลังจากค้นหาองค์ประกอบดังกล่าว NG จะเริ่มประมวลผล DOM ด้วยจุดเริ่มต้นขององค์ประกอบนี้ดังนั้นหากเพิ่ม NG-APP ลงในองค์ประกอบ HTML NG จะเริ่มการประมวลผล DOM ด้วยองค์ประกอบ HTML
เริ่มต้นจากจุดเริ่มต้นนี้ NG เริ่มค้นหาองค์ประกอบของเด็กทั้งหมดซ้ำซึ่งสอดคล้องกับกฎคำสั่งที่กำหนดไว้ในแอปพลิเคชัน
วิธีจัดการกับคำแนะนำของ NG นั้นขึ้นอยู่กับคุณสมบัติของวัตถุที่กำหนดไว้ คุณสามารถกำหนดฟังก์ชั่นคอมไพล์หรือลิงก์หรือใช้ฟังก์ชั่น pre-link และ post-link แทนลิงก์
แล้วฟังก์ชั่นเหล่านี้แตกต่างกันอย่างไร? ทำไมต้องใช้มัน? และเมื่อไหร่?
ด้วยคำถามเหล่านี้ติดตามฉันทีละขั้นตอนเพื่อตอบความลึกลับเหล่านี้
ชิ้นส่วนของรหัส
เพื่ออธิบายความแตกต่างระหว่างฟังก์ชั่นเหล่านี้ฉันจะใช้ตัวอย่างที่ง่ายและเข้าใจง่ายด้านล่าง
1. หากคุณมีคำถามใด ๆ โปรดอย่าลังเลที่จะเพิ่มความคิดเห็นของคุณด้านล่าง
ตรวจสอบรหัสแท็ก HTML ต่อไปนี้
การคัดลอกรหัสมีดังนี้:
<level-one>
<ระดับสอง>
<level-Three>
สวัสดี
</level-Three>
</ระดับสอง>
</level-one>
จากนั้นก็มีรหัส JS ชิ้นหนึ่ง
การคัดลอกรหัสมีดังนี้:
var app = angular.module ('plunker', []);
ฟังก์ชั่น createDirective (ชื่อ) {
return function () {
กลับ {
จำกัด : 'e',
คอมไพล์: ฟังก์ชั่น (telem, tattrs) {
console.log (ชื่อ + ': รวบรวม');
กลับ {
pre: ฟังก์ชัน (ขอบเขต, ielem, iattrs) {
console.log (ชื่อ + ': ลิงก์ก่อน');
-
โพสต์: ฟังก์ชั่น (ขอบเขต, ielem, iattrs) {
console.log (ชื่อ + ': โพสต์ลิงก์');
-
-
-
-
-
-
app.directive ('levelone', createDirective ('levelone'));
app.directive ('leveltwo', createDirective ('leveltwo'));
App.directive ('LevelThree', CreateDirective ('LevelThree'));
ผลลัพธ์นั้นง่ายมาก: ให้ NG จัดการคำแนะนำที่ซ้อนกันสามคำสั่งและแต่ละคำสั่งมีฟังก์ชั่นที่น่ารำคาญ, ลิงค์ล่วงหน้าและโพสต์ลิงค์ของตัวเอง แต่ละฟังก์ชั่นจะพิมพ์บรรทัดในคอนโซลเพื่อระบุตัวเอง
ตัวอย่างนี้ช่วยให้เราสามารถเข้าใจกระบวนการภายในของ NG โดยย่อเมื่อประมวลผลคำแนะนำ
เอาต์พุตรหัส
ด้านล่างเป็นภาพหน้าจอของผลลัพธ์ผลลัพธ์บนคอนโซล
หากคุณต้องการลองตัวอย่างนี้ด้วยตัวเองโปรดคลิก PLNKR นี้แล้วดูผลลัพธ์ในคอนโซล
รหัสการวิเคราะห์
สิ่งแรกที่ควรทราบคือลำดับของการโทรของฟังก์ชั่นเหล่านี้:
การคัดลอกรหัสมีดังนี้:
// คอมไพล์เฟส
// levelone: ฟังก์ชั่นคอมไพล์เรียกว่า
// levelTwo: ฟังก์ชั่นคอมไพล์เรียกว่า
// LevelThree: ฟังก์ชั่นคอมไพล์เรียกว่า
// เฟสพรีลิงค์
// levelone: ฟังก์ชั่นลิงค์ก่อนเรียก
// leveltwo: ฟังก์ชันลิงก์ก่อน
// levelThree: ฟังก์ชันลิงก์ก่อนเรียก
// เฟสโพสต์ลิงก์ (สังเกตคำสั่งย้อนกลับ)
// LevelThree: Post Link Function เรียกว่า
// levelTwo: ฟังก์ชันลิงก์โพสต์เรียกว่า
// levelone: Post Link Function เรียกว่า
ตัวอย่างนี้แสดงให้เห็นอย่างชัดเจนว่า NG รวบรวมคำแนะนำทั้งหมดก่อนลิงค์จากนั้นลิงก์จะถูกแบ่งออกเป็นขั้นตอนการเชื่อมโยงล่วงหน้าและโพสต์ลิงก์
โปรดทราบว่าลำดับการดำเนินการของการคอมไพล์และลิงก์ล่วงหน้าจะดำเนินการตามลำดับ แต่โพสต์ลิงก์นั้นตรงกันข้าม
ดังนั้นข้างต้นได้ระบุขั้นตอนที่แตกต่างกันอย่างชัดเจน แต่อะไรคือความแตกต่างระหว่างการรวบรวมและการเชื่อมโยงล่วงหน้า? พวกเขาทั้งคู่อยู่ในลำดับการดำเนินการเดียวกันดังนั้นทำไมเราต้องแบ่งพวกเขาออกเป็นสองฟังก์ชั่นที่แตกต่างกัน?
ดอม
เพื่อที่จะขุดลึกลงไปลองแก้ไขรหัสด้านบนซึ่งจะพิมพ์ตัวแปรองค์ประกอบในรายการพารามิเตอร์ในแต่ละฟังก์ชัน
การคัดลอกรหัสมีดังนี้:
var app = angular.module ('plunker', []);
ฟังก์ชั่น createDirective (ชื่อ) {
return function () {
กลับ {
จำกัด : 'e',
คอมไพล์: ฟังก์ชั่น (telem, tattrs) {
console.log (ชื่อ + ': compile =>' + telem.html ());
กลับ {
pre: ฟังก์ชัน (ขอบเขต, ielem, iattrs) {
console.log (ชื่อ + ': pre link =>' + ielem.html ());
-
โพสต์: ฟังก์ชั่น (ขอบเขต, ielem, iattrs) {
console.log (ชื่อ + ': post link =>' + ielem.html ());
-
-
-
-
-
-
app.directive ('levelone', createDirective ('levelone'));
app.directive ('leveltwo', createDirective ('leveltwo'));
App.directive ('LevelThree', CreateDirective ('LevelThree'));
ให้ความสนใจกับผลลัพธ์ใน console.log ยกเว้นเอาต์พุตของแท็ก HTML ดั้งเดิมโดยทั่วไปจะไม่มีการเปลี่ยนแปลงอื่น ๆ
สิ่งนี้ควรทำให้เราเข้าใจบริบทของฟังก์ชั่นเหล่านี้ลึกซึ้งยิ่งขึ้น
เรียกใช้รหัสอีกครั้งเพื่อดู
เอาท์พุท
ด้านล่างเป็นภาพหน้าจอของผลลัพธ์ผลลัพธ์บนคอนโซล
หากคุณยังต้องการเรียกใช้ตัวเองเพื่อดูเอฟเฟกต์คุณสามารถคลิก PLNKR นี้แล้วดูผลลัพธ์ผลลัพธ์ในคอนโซล
สังเกต
ผลลัพธ์ของผลลัพธ์ DOM สามารถเปิดเผยสิ่งที่น่าสนใจได้: เนื้อหา DOM นั้นแตกต่างกันในฟังก์ชั่นทั้งสองคอมไพล์และลิงค์ล่วงหน้า
แล้วเกิดอะไรขึ้น?
รวบรวม
เรารู้อยู่แล้วว่าเมื่อ NG พบว่าการสร้าง DOM เสร็จสมบูรณ์เราจะเริ่มประมวลผล DOM
ดังนั้นเมื่อ NG ผ่าน DOM เขาจะพบองค์ประกอบระดับหนึ่งและเรียนรู้จากคำจำกัดความว่าฟังก์ชั่นที่จำเป็นบางอย่างจำเป็นต้องดำเนินการ
เนื่องจากฟังก์ชั่นคอมไพล์ถูกกำหนดไว้ในวัตถุคำสั่งของคำสั่งระดับหนึ่งมันจะถูกเรียกและส่งผ่านวัตถุองค์ประกอบเป็นพารามิเตอร์ของมัน
หากคุณมองอย่างใกล้ชิดคุณจะเห็นว่าเมื่อเบราว์เซอร์สร้างวัตถุองค์ประกอบนี้มันยังคงเป็นแท็ก HTML ดั้งเดิมที่สุด
1. ใน NG, DOM ดั้งเดิมมักจะใช้เพื่อระบุองค์ประกอบเทมเพลตดังนั้นฉันจึงใช้ชื่อ telem เมื่อกำหนดพารามิเตอร์ฟังก์ชันคอมไพล์และตัวแปรนี้ชี้ไปที่องค์ประกอบเทมเพลต
เมื่อฟังก์ชั่นการคอมไพล์ในคำสั่ง LevelOne เปิดใช้งาน NG จะสำรวจโหนด DOM ของมันซ้ำแล้วซ้ำอีกแล้วทำซ้ำการดำเนินการเหล่านี้ในระดับสองและระดับสาม
โพสต์ลิงค์
ก่อนที่เราจะเข้าสู่ฟังก์ชั่น pre-link ลองมาดูฟังก์ชั่นโพสต์ลิงก์
2. หากคุณใช้ฟังก์ชั่นลิงค์เดียวเมื่อกำหนดคำสั่ง NG จะปฏิบัติต่อฟังก์ชั่นนี้เป็นโพสต์ลิงก์ดังนั้นเราต้องพูดถึงฟังก์ชั่นนี้ก่อน
หลังจากที่ NG เดินทางผ่าน DOMs ทั้งหมดและใช้ฟังก์ชั่นคอมไพล์ทั้งหมดฟังก์ชั่นโพสต์ลิงค์ที่เกี่ยวข้องจะถูกเรียกในสิ่งที่ตรงกันข้าม
ตอนนี้ DOM เริ่มย้อนกลับและดำเนินการฟังก์ชันโพสต์ลิงก์ ดังนั้นการโทรย้อนกลับนี้ดูเหมือนจะแปลกไปเล็กน้อยมาก่อน แต่จริง ๆ แล้วมันสมเหตุสมผลที่จะทำเช่นนั้น
เมื่อเรียกใช้คำสั่งโพสต์ลิงค์ที่มีการแนะนำย่อยกฎหลังการเชื่อมโยงย้อนกลับสามารถมั่นใจได้ว่าการโพสต์ลิงก์ของการแนะนำการแนะนำ
ดังนั้นเมื่อเรียกใช้ฟังก์ชั่นโพสต์ลิงก์ของคำสั่งระดับหนึ่งเราสามารถมั่นใจได้ว่าโพสต์ลิงก์ของระดับสองและระดับสามได้รับการเรียกใช้จริง
นี่คือเหตุผลที่ผู้คนคิดว่าโพสต์ลิงก์เป็นสถานที่ที่ปลอดภัยหรือเริ่มต้นในการเขียนตรรกะทางธุรกิจ
แต่ทำไมองค์ประกอบถึงแตกต่างจากองค์ประกอบในการคอมไพล์?
เมื่อ NG เรียกฟังก์ชั่นคอมไพล์ของคำสั่งวัตถุอินสแตนซ์องค์ประกอบขององค์ประกอบเทมเพลตจะถูกสร้างขึ้นและวัตถุขอบเขตมีให้สำหรับมัน ขอบเขตนี้อาจเป็นอินสแตนซ์ใหม่หรืออาจมีอยู่แล้วอาจเป็นขอบเขตย่อยหรืออาจเป็นขอบเขตอิสระ สิ่งเหล่านี้ขึ้นอยู่กับค่าแอตทริบิวต์ขอบเขตในวัตถุคำจำกัดความคำสั่ง
ดังนั้นเมื่อการเชื่อมโยงเกิดขึ้นองค์ประกอบอินสแตนซ์และวัตถุขอบเขตนี้มีอยู่แล้วและจะถูกส่งผ่านเป็นพารามิเตอร์โดย NG ไปยังรายการพารามิเตอร์ของฟังก์ชันโพสต์ลิงก์
1. ฉันมักจะใช้ชื่อ IElem เพื่อกำหนดพารามิเตอร์ของฟังก์ชันลิงก์และชี้ไปที่อินสแตนซ์องค์ประกอบ
ดังนั้นวัตถุพารามิเตอร์องค์ประกอบของฟังก์ชั่นโพสต์ลิงก์ (ลิงก์ล่วงหน้า) จึงเป็นอินสแตนซ์องค์ประกอบแทนองค์ประกอบเทมเพลต
ดังนั้นผลลัพธ์ในตัวอย่างข้างต้นจึงแตกต่างกัน
ลิงค์ล่วงหน้า
เมื่อเขียนฟังก์ชั่นโพสต์ลิงก์คุณสามารถมั่นใจได้ว่าเมื่อดำเนินการฟังก์ชั่นโพสต์ลิงก์ฟังก์ชั่นโพสต์ลิงก์ของคำแนะนำเด็กทั้งหมดได้ถูกดำเนินการแล้ว
ในกรณีส่วนใหญ่มันสามารถทำได้ดีกว่าดังนั้นเรามักจะใช้มันเพื่อเขียนรหัสคำสั่ง
อย่างไรก็ตาม NG ให้กลไกเบ็ดเพิ่มเติมแก่เรานั่นคือฟังก์ชั่น pre-link ซึ่งสามารถมั่นใจได้ว่ารหัสอื่นบางอย่างจะทำงานก่อนที่จะดำเนินการฟังก์ชั่นหลังการเชื่อมโยงของการแนะนำย่อยทั้งหมด
ประโยคนี้มีค่าควรพิจารณาซ้ำ ๆ
ฟังก์ชั่น pre-link สามารถตรวจสอบให้แน่ใจว่ามันถูกดำเนินการในอินสแตนซ์องค์ประกอบและก่อนการโพสต์ลิงก์ของการแนะนำย่อยของมันทำงาน
ดังนั้นจึงเหมาะสมที่จะย้อนกลับฟังก์ชั่นโพสต์ลิงก์มันจะดำเนินการฟังก์ชั่น pre-link ในลำดับต้นฉบับ
นอกจากนี้ยังหมายความว่าฟังก์ชั่นการเชื่อมโยงล่วงหน้าทำงานก่อนที่ฟังก์ชั่นการเชื่อมโยงล่วงหน้าของการแนะนำย่อยทั้งหมดดังนั้นเหตุผลที่สมบูรณ์คือ:
ฟังก์ชั่นการเชื่อมโยงล่วงหน้าขององค์ประกอบสามารถรับประกันได้ว่าจะดำเนินการก่อนที่จะมีการเรียกใช้งานหลังการเชื่อมโยงและการเชื่อมโยงล่วงหน้าของการแนะนำย่อยทั้งหมด ดูรูปด้านล่าง:
ทบทวน
หากเรามองย้อนกลับไปที่ผลลัพธ์ดั้งเดิมด้านบนเราสามารถรับรู้ได้อย่างชัดเจนว่าเกิดอะไรขึ้น:
การคัดลอกรหัสมีดังนี้:
// ที่นี่องค์ประกอบยังคงเป็นองค์ประกอบแม่แบบดั้งเดิม
// คอมไพล์เฟส
// levelone: ฟังก์ชั่นคอมไพล์เรียกว่าต้นฉบับ DOM
// leveltwo: ฟังก์ชั่นคอมไพล์เรียกว่า Original DOM
// levelThree: ฟังก์ชั่นคอมไพล์เรียกว่าต้นฉบับ DOM
// ณ ที่นี่องค์ประกอบได้รับการยกตัวอย่างและ
// ถูกผูกไว้กับขอบเขต
// (เช่น Ng-repeat จะมีหลายอินสแตนซ์)
// เฟสพรีลิงค์
// levelone: ฟังก์ชั่นลิงก์ก่อนเรียกใช้ในอินสแตนซ์องค์ประกอบ
// levelTwo: ฟังก์ชันลิงก์ก่อนเรียกใช้อินสแตนซ์องค์ประกอบ
// levelThree: ฟังก์ชันลิงก์ก่อนเรียกใช้อินสแตนซ์องค์ประกอบ
// เฟสโพสต์ลิงก์ (สังเกตคำสั่งย้อนกลับ)
// levelThree: ฟังก์ชันโพสต์ลิงก์เรียกใช้ในอินสแตนซ์องค์ประกอบ
// levelTwo: ฟังก์ชั่นการเชื่อมโยงโพสต์เรียกใช้อินสแตนซ์องค์ประกอบ
// levelone: ฟังก์ชั่นลิงก์โพสต์เรียกในอินสแตนซ์องค์ประกอบ
สรุป
เมื่อมองย้อนกลับไปที่การวิเคราะห์ข้างต้นเราสามารถอธิบายความแตกต่างและการใช้งานของฟังก์ชั่นเหล่านี้:
ฟังก์ชั่นคอมไพล์
ใช้ฟังก์ชั่นคอมไพล์เพื่อเปลี่ยน DOM ดั้งเดิม (องค์ประกอบเทมเพลต) ก่อนที่ NG จะสร้างอินสแตนซ์ DOM ดั้งเดิมและอินสแตนซ์ขอบเขต
สามารถนำไปใช้กับสถานการณ์ที่จำเป็นต้องสร้างอินสแตนซ์องค์ประกอบหลายอย่างและมีองค์ประกอบเทมเพลตเพียงอย่างเดียว NG-Repeat เป็นตัวอย่างที่ดีที่สุด มันเปลี่ยน DOM ดั้งเดิมในขั้นตอนฟังก์ชันคอมไพล์เพื่อสร้างโหนด DOM ดั้งเดิมหลายโหนดจากนั้นแต่ละตัวสร้างอินสแตนซ์องค์ประกอบ เนื่องจากการคอมไพล์จะทำงานเพียงครั้งเดียวจึงสามารถปรับปรุงประสิทธิภาพได้เมื่อคุณต้องการสร้างอินสแตนซ์องค์ประกอบหลายอย่าง
องค์ประกอบเทมเพลตและแอตทริบิวต์ที่เกี่ยวข้องจะถูกส่งผ่านเป็นพารามิเตอร์ไปยังฟังก์ชันคอมไพล์ แต่ไม่สามารถใช้ขอบเขตได้ในเวลานี้:
นี่คือฟังก์ชั่นดูเหมือนว่า:
การคัดลอกรหัสมีดังนี้:
-
* ฟังก์ชั่นคอมไพล์
-
* @Param Telem - องค์ประกอบแม่แบบ
* @param tattrs - คุณลักษณะขององค์ประกอบเทมเพลต
-
ฟังก์ชั่น (telem, tattrs) {
-
-
ฟังก์ชั่น pre-link
ใช้ฟังก์ชั่น pre-link เพื่อเรียกใช้รหัสธุรกิจบางอย่างหลังจาก NG ได้ดำเนินการฟังก์ชั่นคอมไพล์ แต่ก่อนที่ฟังก์ชั่นหลังการเชื่อมโยงของการแนะนำย่อยทั้งหมดจะถูกดำเนินการ
อินสแตนซ์วัตถุขอบเขตและองค์ประกอบจะถูกส่งเป็นพารามิเตอร์ไปยังฟังก์ชัน pre-link:
นี่คือฟังก์ชั่นดูเหมือนว่า:
การคัดลอกรหัสมีดังนี้:
-
* ฟังก์ชัน pre-link
-
* ขอบเขต @param - ขอบเขตที่เกี่ยวข้องกับ istance นี้
* @Param Ielem - องค์ประกอบอินสแตนซ์
* @param iattrs - คุณลักษณะขององค์ประกอบอินสแตนซ์
-
ฟังก์ชั่น (ขอบเขต, iElem, iattrs) {
-
-
ฟังก์ชั่นโพสต์ลิงค์
ใช้ฟังก์ชั่นโพสต์ลิงก์เพื่อดำเนินการตรรกะทางธุรกิจ ในขั้นตอนนี้มันรู้อยู่แล้วว่าการแนะนำย่อยทั้งหมดได้รับการรวบรวมและฟังก์ชั่น pre-link และ post-link ได้ถูกดำเนินการแล้ว
นี่คือสิ่งที่ถือว่าเป็นรหัสตรรกะการเขียนที่ปลอดภัยและเริ่มต้นและเริ่มต้น
อินสแตนซ์ขอบเขตและอินสแตนซ์ขององค์ประกอบจะถูกส่งเป็นพารามิเตอร์ไปยังฟังก์ชันโพสต์ลิงก์:
นี่คือฟังก์ชั่นดูเหมือนว่า:
การคัดลอกรหัสมีดังนี้:
-
* ฟังก์ชั่นโพสต์ลิงค์
-
* ขอบเขต @param - ขอบเขตที่เกี่ยวข้องกับ istance นี้
* @Param Ielem - องค์ประกอบอินสแตนซ์
* @param iattrs - คุณลักษณะขององค์ประกอบอินสแตนซ์
-
ฟังก์ชั่น (ขอบเขต, iElem, iattrs) {
-
-
สรุป
ตอนนี้คุณควรมีความเข้าใจที่ชัดเจนเกี่ยวกับความแตกต่างระหว่างการคอมไพล์, ลิงค์ล่วงหน้า, โพสต์ลิงก์และฟังก์ชั่นนี้
หากคุณยังไม่ได้อยู่แล้วและคุณเป็นนักพัฒนา NG ที่จริงจังฉันขอแนะนำให้คุณอ่านบทความนี้อีกครั้งจนกว่าคุณจะเข้าใจ
การทำความเข้าใจแนวคิดเหล่านี้มีความสำคัญมากซึ่งสามารถช่วยให้คุณเข้าใจว่าคำแนะนำดั้งเดิมของ NG ทำงานอย่างไรและยังสามารถช่วยให้คุณเพิ่มประสิทธิภาพคำแนะนำที่กำหนดเองของคุณเอง
หากคุณมีคำถามใด ๆ โปรดเพิ่มคำถามของคุณในความคิดเห็นด้านล่าง
ในอนาคตเราจะวิเคราะห์คำถามอื่น ๆ อีกสองข้อเกี่ยวกับคำแนะนำ:
1. Directive ใช้แอตทริบิวต์ transclusion ทำงานอย่างไร?
2. ฟังก์ชั่นคอนโทรลเลอร์ของคำสั่งที่เกี่ยวข้องอย่างไร?
สุดท้ายหากคุณพบว่ามีบางอย่างผิดปกติกับบทความนี้โปรดแสดงความคิดเห็นในเวลา
ขอบคุณ!