แผนผังองค์ประกอบของเอกสาร html คืออะไร การจัดโครงสร้างข้อมูลโดยใช้ JavaScript: Tree เลือกรายการตามประเภท
อายุน้อยกว่า). องค์ประกอบของต้นไม้ทั้งหมดคือ ลูกหลานรูตและนั่นคือของพวกเขา บรรพบุรุษ. ในกรณีนี้ องค์ประกอบและข้อความทั้งหมดที่ประกอบเป็นเนื้อหาจะเป็นดังนี้ โหนดต้นไม้เอกสาร
แต่ละองค์ประกอบในแผนผังนี้สอดคล้องกับองค์ประกอบ HTML ดังนั้นจึงมีแท็ก เนื้อหา และชุดแอตทริบิวต์ หากต้องการย้ายไปยังโมเดลออบเจ็กต์เอกสาร เหลือเพียงขั้นตอนเดียวเท่านั้นที่ต้องทำ: เรียกออบเจ็กต์องค์ประกอบแผนผังทั้งหมด และทำให้แอตทริบิวต์สามารถอ่านและเปลี่ยนแปลงได้จากสคริปต์และแอปเพล็ต เป็นผลให้แผนผังขององค์ประกอบเอกสาร HTML ได้รับการจัดการแบบไดนามิก ยิ่งไปกว่านั้น ขณะนี้เราสามารถเพิ่มคุณสมบัติใหม่ให้กับแต่ละองค์ประกอบได้อย่างง่ายดาย นอกเหนือจากแอตทริบิวต์ HTML มาตรฐาน
เป็นแนวทางนี้ที่ใช้เป็นพื้นฐานสำหรับโมเดล HTML แบบไดนามิกของเบราว์เซอร์ Microsoft จากนั้นจึงนำไปใช้เป็นพื้นฐานสำหรับมาตรฐาน W3C ที่เรียกว่า แบบจำลองวัตถุเอกสาร(Document Object Model หรือ DOM) ในเวลาเดียวกัน W3C ได้ขยายแนวคิดของ DOM ไปยังเอกสาร XML ใดๆ โดยพิจารณาว่า HTML DOM เป็นกรณีพิเศษเฉพาะที่มีความสามารถเพิ่มเติม ดังนั้น DOM จึงเป็นโมเดลเอกสาร HTML และ XML ที่ไม่ขึ้นอยู่กับแพลตฟอร์มและภาษาที่กำหนด:
- อินเทอร์เฟซและวัตถุที่ใช้เพื่อแสดงและจัดการเอกสาร
- ความหมายของอินเทอร์เฟซและวัตถุเหล่านี้ รวมถึงคุณลักษณะและการตอบสนองต่อเหตุการณ์
- ความสัมพันธ์ระหว่างอินเทอร์เฟซและวัตถุเหล่านี้
จนถึงปัจจุบัน W3C ได้กำหนดมาตรฐาน DOM ระดับหนึ่งและสอง (DOM 1 และ DOM 2) DOM 3 อยู่ในขั้นตอนร่างการทำงาน ตัวย่อเหล่านี้ตามลำดับหมายถึงสิ่งต่อไปนี้:
- DOM 1 อธิบายการแสดงพื้นฐานของเอกสาร XML และ HTML เป็นแผนผังของวัตถุ
- DOM 2 ขยายอินเทอร์เฟซหลัก DOM 1 และเพิ่มการรองรับเหตุการณ์และสไตล์
- DOM 3 อธิบายการโหลดและแยกวิเคราะห์เอกสาร ตลอดจนการแสดงผลและการจัดรูปแบบ
เมื่อพิจารณาถึงสถานะปัจจุบัน เรากำลังพิจารณาเฉพาะ DOM 2 (และ DOM 1 ที่ประกอบด้วย) ที่นี่เท่านั้น DOM 2 ประกอบด้วยกลุ่มอินเทอร์เฟซที่เกี่ยวข้องกันดังต่อไปนี้:
- อินเทอร์เฟซพื้นฐานหลักที่กำหนดมุมมองแผนผังของเอกสาร XML ใด ๆ
- ดูอินเทอร์เฟซที่อธิบายการแสดงเอกสารที่เป็นไปได้
- อินเทอร์เฟซเหตุการณ์ที่กำหนดลำดับการสร้างและการประมวลผลเหตุการณ์
- อินเทอร์เฟซสไตล์ที่กำหนดการประยุกต์ใช้สไตล์ชีตกับเอกสาร
- อินเทอร์เฟซ Traversal & Range ที่กำหนดการเคลื่อนที่ของแผนผังเอกสารและการจัดการพื้นที่ของเนื้อหา
- อินเทอร์เฟซ HTML ที่กำหนดมุมมองแบบต้นไม้ของเอกสาร HTML
เริ่มต้นด้วยการกำหนดอินเทอร์เฟซพื้นฐานที่รองรับข้อกำหนดเพิ่มเติมทั้งหมด
4.2.2. แนวคิดพื้นฐานDOM 2 Core แสดงถึงเอกสาร XML ในรูปแบบต้นไม้ที่ประกอบด้วยโหนด ซึ่งในทางกลับกันก็เป็นอ็อบเจ็กต์และใช้อินเทอร์เฟซพิเศษเพิ่มเติม โหนดบางประเภทสามารถมีลูกได้นั่นคือพวกมันเองเป็นแผนผังย่อยในขณะที่โหนดบางประเภทเป็นใบไม้นั่นคือพวกมันไม่มีลูก ตารางต่อไปนี้สรุปประเภทโหนดเอกสารนามธรรมที่เป็นไปได้ทั้งหมด สำหรับโหนดแต่ละประเภท โหนดเหล่านั้นที่สามารถเป็นรายการย่อยได้จะแสดงรายการไว้ สำหรับแนวคิดที่สอดคล้องกับโหนดที่แสดง โปรดดูคำอธิบายของโครงสร้างเอกสาร XML
เอกสาร | องค์ประกอบ (สูงสุด 1 รายการ), ProcessingInstruction , Comment , DocumentType (สูงสุด 1 รายการ) | |
ส่วนเอกสาร | องค์ประกอบ, คำแนะนำในการประมวลผล, ความคิดเห็น, ข้อความ, CDATASection, EntityReference | |
ประเภทเอกสาร | ประเภทเอกสาร | ไม่มีลูก |
การอ้างอิงเอนทิตี | ลิงค์ส่วน | องค์ประกอบ, คำแนะนำในการประมวลผล, ความคิดเห็น, ข้อความ, CDATASection, EntityReference |
องค์ประกอบ | องค์ประกอบ | องค์ประกอบ, คำแนะนำในการประมวลผล, ความคิดเห็น, ข้อความ, CDATASection, EntityReference |
Attr | คุณลักษณะ | ข้อความ, EntityReference |
คำแนะนำในการประมวลผล | คำสั่ง XML | ไม่มีลูก |
ความคิดเห็น | ความคิดเห็น | ไม่มีลูก |
ข้อความ | ข้อความ | ไม่มีลูก |
ส่วน CDATA | ส่วนซีดีต้า | ไม่มีลูก |
เอนทิตี | บท | องค์ประกอบ, คำแนะนำในการประมวลผล, ความคิดเห็น, ข้อความ, CDATASection, EntityReference |
สัญกรณ์ | สัญกรณ์ | ไม่มีลูก |
นอกจากนี้ DOM 2 Core ยังมีข้อกำหนดของอินเทอร์เฟซ NodeList (รายการเรียงลำดับของโหนดที่สามารถเข้าถึงได้ตามหมายเลขในรายการ) และอินเทอร์เฟซ NamedNodeMap (รายการแบบไม่เรียงลำดับของโหนดที่สามารถเข้าถึงได้ด้วยชื่อ) วัตถุเหล่านี้ก็คือ มีชีวิตอยู่กล่าวคือ การเปลี่ยนแปลงใดๆ ในเอกสารจะนำมาซึ่งการเปลี่ยนแปลงในรายการทั้งหมดที่เกี่ยวข้องโดยอัตโนมัติ
ควรเน้นย้ำว่า DOM 2 Core มีอินเทอร์เฟซสองชุด ซึ่งแต่ละชุดให้การเข้าถึงองค์ประกอบเอกสารทั้งหมดได้อย่างเต็มที่ ชุดแรกแสดงถึงแนวทางเชิงวัตถุที่มีลำดับชั้นการสืบทอดดังต่อไปนี้: บันทึกองค์ประกอบที่เป็นส่วนประกอบของคุณลักษณะและเนื้อหาข้อความ เมื่อพิจารณาแผนผังเอกสารในลักษณะนี้เรากำลังพูดถึง ลำดับชั้นของวัตถุ. แนวทางที่ 2 ยึดหลักการ “ทุกอย่างคือโหนด (Nodes)” ที่นี่ ส่วนประกอบทั้งหมดของเอกสารถือเป็นโหนดที่เท่ากันของแผนผัง และเราสามารถพูดถึงได้เท่านั้น ลำดับชั้นของโหนด. ดังนั้น DOM 2 จึงมีความซ้ำซ้อนโดยธรรมชาติ แต่ทำให้เราสามารถดูเอกสารไม่ทางใดก็ทางหนึ่งได้ ขึ้นอยู่กับงาน
อินเทอร์เฟซ DOM 2 Core ทั้งหมดแบ่งออกเป็นพื้นฐาน (พื้นฐาน) และเพิ่มเติม (ขยาย) อินเทอร์เฟซหลัก ได้แก่ , , , , Node , NodeList , NamedNodeMap , CharacterData , Attr , Element , Text และ Comment อินเทอร์เฟซเหล่านี้ต้องได้รับการสนับสนุนโดยการใช้งาน DOM ทั้งหมดสำหรับทั้งเอกสาร XML และ HTML อินเทอร์เฟซเพิ่มเติมกำหนดเป้าหมายเอกสาร XML ดังนั้นการใช้งาน HTML DOM อาจไม่รองรับ ซึ่งรวมถึง CDATASection, DocumentType, สัญลักษณ์, เอนทิตี, EntityReference และ ProcessingInstruction
เพื่อให้เป็นภาษาและแพลตฟอร์มที่เป็นอิสระ DOM จึงกำหนดประเภทต่อไปนี้:
DOMStringสตริงข้อความที่ประกอบด้วยอักขระ Unicode ในรูปแบบ UTF-16 ใน JavaScript และ Java มันถูกนำไปใช้โดยประเภทสตริง DOMTimeStampวันที่และเวลาในรูปแบบที่ยอมรับได้สำหรับภาษาเฉพาะ ตัวอย่างเช่น ใน JavaScript นี่จะเป็นอ็อบเจ็กต์ Date และใน Java มันจะเป็นประเภทจำนวนเต็มแบบยาวซึ่งมีจำนวนมิลลิวินาทีด้านล่างนี้เป็นคำอธิบายโดยย่อของอินเทอร์เฟซ DOM ทั้งหมด ซึ่งระบุระดับโมเดล (DOM 1 หรือ DOM 2) ซึ่งมีการกำหนดคุณสมบัติอินเทอร์เฟซนี้หรือนั้นไว้ ข้อมูลจำเพาะของ W3C เขียนด้วยภาษา IDL ที่ไม่ขึ้นกับแพลตฟอร์ม เรานำเสนอตามไวยากรณ์ของ JavaScript ซึ่งเป็นภาษาสคริปต์หลักในปัจจุบัน
นอกจากคำอธิบายของมาตรฐานแล้ว เรายังให้คำอธิบายโดยย่อเกี่ยวกับการนำไปใช้ในโมเดลออบเจ็กต์ของ Microsoft และ Gecko ควรสังเกตว่าการใช้งาน XML และ HTML ของ Microsoft นั้นเป็นอิสระอย่างสมบูรณ์ (ใช้งานโดยส่วนประกอบซอฟต์แวร์ XMLDOM และ MSHTML ตามลำดับ) ในขณะที่ Gecko โมเดลวัตถุจะเหมือนกันสำหรับเอกสาร HTML และ XML การสนทนาต่อไปนี้มุ่งเน้นไปที่ DOM สำหรับ HTML; XML DOM จะกล่าวถึงรายละเอียดในส่วนที่ 8
4.2.3. ข้อยกเว้น: อินเทอร์เฟซ DOMExceptionวัตถุ DOMException เป็นต้นแบบของข้อยกเว้นทั้งหมดที่อาจเกิดขึ้นขณะประมวลผลเอกสาร มีรหัสคุณสมบัติเดียวประเภท Number ซึ่งประกอบด้วยหมายเลขข้อยกเว้นตามตารางต่อไปนี้:
INDEX_SIZE_ERR | 1 | ดัชนีอยู่นอกช่วง | โดม 1 |
DOMSTRING_SIZE_ERR | 2 | ไม่สามารถโยนข้อความที่กำหนดเพื่อพิมพ์ได้ | โดม 1 |
HIERARCHY_REQUEST_ERR | 3 | มีความพยายามในการแทรกโหนดในตำแหน่งที่ไม่ถูกต้องในแผนผัง | โดม 1 |
WRONG_DOCUMENT_ERR | 4 | ประเภทเอกสารไม่ถูกต้อง | โดม 1 |
INVALID_CHARACTER_ERR | 5 | พบอักขระที่ไม่ถูกต้อง | โดม 1 |
NO_DATA_ALLOWED_ERR | 6 | โหนดไม่มีข้อมูล | โดม 1 |
NO_MODIFICATION_ALLOWED_ERR | 7 | มีความพยายามในการปรับเปลี่ยนวัตถุในลักษณะที่ผิดกฎหมาย | โดม 1 |
NOT_FOUND_ERR | 8 | การเข้าถึงโหนดที่ไม่มีอยู่จริง | โดม 1 |
NOT_SUPPORTED_ERR | 9 | ไม่มีการใช้พารามิเตอร์หรือการดำเนินการ | โดม 1 |
INUSE_ATTRIBUTE_ERR | 10 | มีความพยายามที่จะเพิ่มแอตทริบิวต์ที่มีอยู่แล้ว | โดม 1 |
INVALID_STATE_ERR | 11 | หมายถึงวัตถุที่ไม่มีอยู่จริง | โดม 1 |
SYNTAX_ERR | 12 | ข้อผิดพลาดทางไวยากรณ์ | โดม 2 |
INVALID_MODIFICATION_ERR | 13 | มีความพยายามที่จะเปลี่ยนประเภทของออบเจ็กต์ | โดม 2 |
NAMESPACE_ERR | 14 | มีความพยายามในการสร้างหรือแก้ไขวัตถุที่ไม่สอดคล้องกับเนมสเปซ XML | โดม 2 |
INVALID_ACCESS_ERR | 15 | อ็อบเจ็กต์ไม่รองรับพารามิเตอร์หรือการดำเนินการ | โดม 2 |
อินเทอร์เฟซ DOMImplementation ประกอบด้วยวิธีการซึ่งการดำเนินการไม่ขึ้นอยู่กับโมเดลวัตถุเอกสารเฉพาะ สามารถเข้าถึงได้ผ่านทางวัตถุ.
วิธีการ createCSSStyleSheet ไวยากรณ์ : วัตถุ.createCSSStyleSheet(title, media) อาร์กิวเมนต์: ชื่อ, นิพจน์ประเภทสื่อ ผลลัพธ์: วัตถุ CSSStyleSheet ใหม่ ข้อยกเว้น: การสนับสนุน SYNTAX_ERRวิธีการ createCSSStyleSheet สร้างวัตถุ CSSStyleSheet ใหม่และส่งคืนตัวชี้ไปที่มัน วิธีการนี้ควรได้รับการสนับสนุนโดยการใช้งาน DOM ที่รองรับ CSS เท่านั้น วัตถุถูกสร้างขึ้นนอกบริบทของเอกสาร DOM 2 ไม่อนุญาตให้คุณรวมสไตล์ชีตที่สร้างขึ้นใหม่ในเอกสาร อาร์กิวเมนต์ชื่อระบุชื่อของสไตล์ชีต และสื่อระบุรายการอุปกรณ์แสดงผลที่คั่นด้วยเครื่องหมายจุลภาค
วิธีการ createDocument ไวยากรณ์ : วัตถุ.createDocument(namespaceURI, QualifiedName, doctype) อาร์กิวเมนต์ : namespaceURI, นิพจน์ QualifiedName ของประเภท doctype นิพจน์ประเภท DocumentType ผลลัพธ์ : ออบเจ็กต์ใหม่ ข้อยกเว้น : INVALID_CHARACTER_ERR, NAMESPACE_ERR, WRONG_DOCUMENT_ERR การสนับสนุน : ไม่รองรับ ไม่รองรับ.เมธอด createDocument จะสร้างวัตถุใหม่และส่งกลับตัวชี้ไปที่วัตถุนั้น ได้รับการออกแบบมาเพื่อสร้างเอกสาร XML และอาจไม่รองรับเอกสาร HTML อาร์กิวเมนต์ namespaceURI ระบุ URI เนมสเปซขององค์ประกอบรากของเอกสาร QualifiedName ชื่อที่ผ่านการรับรอง และประเภทเอกสารประเภทของเอกสารที่ถูกสร้างขึ้น (อาจเป็นค่าว่างได้)
วิธีการ createDocumentType ไวยากรณ์ : วัตถุ.createDocumentType(qualifiedName, publicId, systemId) อาร์กิวเมนต์ : QualifiedName, publicId, นิพจน์ประเภท systemId ผลลัพธ์ : โหนด DocumentType ใหม่ การสนับสนุนข้อยกเว้น : ไม่รองรับ ไม่รองรับ.เมธอด createDocumentType จะสร้างโหนด DocumentType ว่างและส่งกลับตัวชี้ไปที่โหนดนั้น มีไว้สำหรับเอกสาร XML และอาจไม่รองรับเอกสาร HTML อาร์กิวเมนต์ QualifiedName ระบุชื่อที่ผ่านการรับรองของประเภทเอกสารที่จะสร้าง publicId คือตัวระบุสาธารณะของส่วนภายนอก และ systemId คือตัวระบุระบบของส่วนภายนอก
มีวิธีการคุณลักษณะ ไวยากรณ์ : วัตถุ.hasFeature(feature, version) อาร์กิวเมนต์ : คุณลักษณะ, นิพจน์ประเภทเวอร์ชัน ผลลัพธ์ : ข้อยกเว้นบูลีน : ไม่มี การสนับสนุนเมธอด hasFeature จะคืนค่าเป็นจริงหากการใช้งาน DOM รองรับคุณสมบัติที่ระบุ และคืนค่าเป็นเท็จ หากไม่เป็นเช่นนั้น ชื่อคุณสมบัติ (ไม่ว่าในกรณีใด) ถูกระบุโดยอาร์กิวเมนต์คุณลักษณะ ต้องเป็นไปตามระเบียบการตั้งชื่อ XML อาร์กิวเมนต์เวอร์ชันระบุชื่อเวอร์ชันของคุณสมบัติที่กำลังตรวจสอบ หากไม่ได้ระบุ จริงจะถูกส่งกลับหากคุณสมบัตินี้ได้รับการสนับสนุนอย่างน้อยบางเวอร์ชัน
ใน Gecko ค่าฟีเจอร์อาจเป็นสตริง "XML" และ "HTML" และค่าเวอร์ชันอาจเป็นสตริง "1.0" และ "2.0" ตัวอย่าง:
การแจ้งเตือน(document.implementation.hasFeature("HTML", "1.0")); alert(document.implementation.hasFeature("HTML", "2.0")); alert(document.implementation.hasFeature("HTML", "3.0"));
ข้อความแจ้งเตือนสองรายการแรกจะส่งออกสตริงเป็น true และข้อความแจ้งเตือนที่สามจะส่งออกเป็นเท็จ
ใน Microsoft XMLDOM ค่าคุณลักษณะอาจเป็นสตริง "XML", "DOM" และ "MS-DOM" และค่าเวอร์ชันอาจเป็นสตริง "1.0" ตัวอย่าง:
Var objDoc = ใหม่ ActiveXObject("Microsoft.XMLDOM"); alert(objDoc.implementation.hasFeature("XML", "1.0")); alert(objDoc.implementation.hasFeature("XML", "2.0"));
คำสั่งแจ้งเตือนแรกจะส่งออกสตริงเป็น true และคำสั่งที่สองจะส่งออกเป็นเท็จ
4.2.5. ส่วนของเอกสาร: การสนับสนุนอินเทอร์เฟซ DocumentFragment: สำหรับเอกสาร XML เท่านั้น (XMLDOMDocumentFragment) สอดคล้องกับ DOM 1อินเทอร์เฟซ DocumentFragment เป็นการสืบทอดของอินเทอร์เฟซ Node และสืบทอดคุณสมบัติและวิธีการทั้งหมด ตามชื่อของมัน มันถูกออกแบบมาเพื่อการใช้งานด้วย เศษของเอกสาร(การแยกส่วนของแผนผังเอกสาร การสร้างส่วนเอกสารใหม่ การแทรกส่วนย่อยเป็นลูกของโหนด ฯลฯ) โปรดทราบว่าเมื่อแทรกวัตถุประเภท DocumentFragment ลงในโหนดที่สามารถมีลูกได้ ลูกทั้งหมดของวัตถุนั้นจะถูกแทรก แต่ไม่ใช่ตัววัตถุเอง ตัวอย่างเช่น โปรดดูที่อินเทอร์เฟซของโหนด
4.2.6. เอกสาร: การสนับสนุนอินเทอร์เฟซเอกสาร: รองรับเอกสาร XML (XMLDOMDocument); สำหรับเอกสาร HTML ได้รับการสนับสนุนบางส่วน DOM 1 สมบูรณ์ DOM 2 บางส่วนอินเทอร์เฟซเอกสารสอดคล้องกับเอกสาร XML หรือ HTML เป็นพื้นฐานสำหรับการเข้าถึงเนื้อหาของเอกสารและสร้างส่วนประกอบต่างๆ
โดม 1 | สร้างแอตทริบิวต์ | |
โดม 2 | สร้างแอตทริบิวต์ที่กำหนดเนมสเปซ | |
โดม 1 | สร้างส่วน CDATA | |
โดม 1 | สร้างความคิดเห็น | |
โดม 1 | สร้างส่วนของเอกสารใหม่ | |
โดม 1 | สร้างองค์ประกอบใหม่ | |
โดม 2 | สร้างองค์ประกอบที่มีเนมสเปซที่กำหนด | |
โดม 1 | สร้างการเชื่อมโยงไปยังส่วน | |
โดม 2 | สร้างวัตถุเหตุการณ์ใหม่ | |
โดม 1 | สร้างคำสั่ง | |
โดม 1 | สร้างโหนดข้อความใหม่ | |
โดม 2 | ส่งคืนองค์ประกอบที่มี ID ที่กำหนด | |
โดม 1 | ส่งคืนคอลเลกชันขององค์ประกอบทั้งหมดที่มีแท็กที่กำหนด | |
โดม 2 | ส่งคืนคอลเลกชันขององค์ประกอบทั้งหมดที่มีแท็กที่กำหนด โดยกำหนดเนมสเปซ | |
โดม 2 | นำเข้าโหนดจากเอกสารอื่น |
คุณสมบัติ doctype ส่งกลับประเภทของเอกสารนี้ (ประเภท DocumentType) สำหรับเอกสาร HTML และเอกสาร XML ที่ไม่มีการประกาศประเภทเอกสาร จะส่งคืนค่า null
คุณสมบัติองค์ประกอบเอกสาร ไวยากรณ์ : เอกสาร.documentElement ไม่แน่นอน: ไม่ การสนับสนุน: เป็นไปตามมาตรฐาน ตรงตามมาตรฐานคุณสมบัติ documentElement ส่งคืนองค์ประกอบรากของเอกสารนี้ (ประเภทองค์ประกอบ) สำหรับเอกสาร HTML องค์ประกอบ HTML จะถูกส่งกลับ ตัวอย่าง: ตัวดำเนินการ
การแจ้งเตือน (document.documentElement.tagName);
จะส่งออกสตริง HTML ไปที่หน้าจอ
คุณสมบัติการนำไปปฏิบัติ ไวยากรณ์ : เอกสาร.implementation แก้ไขได้: ไม่ การสนับสนุน: สำหรับเอกสาร XML เท่านั้น สอดคล้องกับ DOM 1คุณสมบัติการใช้งานส่งคืนวัตถุประเภทที่อธิบายการใช้งาน DOM นี้
คุณสมบัติ styleSheets ไวยากรณ์ : เอกสาร.styleSheets แก้ไขได้: ไม่รองรับ: เอกสาร HTML เท่านั้น ตรงตามมาตรฐานคุณสมบัติ styleSheets ส่งคืนอ็อบเจ็กต์ประเภท StyleSheetList ที่สอดคล้องกับรายการสไตล์ชีตภายนอกและภายในสำหรับเอกสาร คุณสมบัตินี้ได้รับการสนับสนุนโดยการใช้งาน DOM ที่รองรับสไตล์ชีตแบบไดนามิกเท่านั้น
วิธีการ createAttribute ไวยากรณ์ : เอกสาร.createAttribute(name) อาร์กิวเมนต์ : นิพจน์ประเภทชื่อ ผลลัพธ์ : วัตถุ Attr ใหม่ ข้อยกเว้น : การสนับสนุน INVALID_CHARACTER_ERR : สำหรับเอกสาร XML เท่านั้น ตรงตามมาตรฐานวิธีการ createAttribute จะสร้างวัตถุใหม่ประเภท Attr และส่งกลับตัวชี้ไปที่มัน อาร์กิวเมนต์ชื่อระบุชื่อของแอตทริบิวต์ที่จะสร้าง วัตถุใหม่มีแอตทริบิวต์nodeNameชื่อและแอตทริบิวต์localName คำนำหน้า และแอตทริบิวต์ namespaceURI ที่เป็น null ต่อจากนั้น แอตทริบิวต์ที่สร้างขึ้นสามารถกำหนดให้กับองค์ประกอบใดๆ ได้โดยใช้เมธอด Element.setAttributeNode
ตัวอย่างการสร้างแอตทริบิวต์สำหรับองค์ประกอบ HTML:
วาร์ myDiv = document.getElementById("idDiv"); var attr = document.createAttribute("อุณหภูมิ"); attr.value = "temporary"; myDiv.setAttributeNode(attr); alert(myDiv.getAttribute("temp"));!}
ตัวดำเนินการแจ้งเตือนจะพิมพ์สตริงชั่วคราว
ตัวอย่างของการสร้างแอตทริบิวต์ใน Microsoft XMLDOM:
Var xmlDoc = ใหม่ ActiveXObject("Microsoft.XMLDOM"); xmlDoc.async = เท็จ; xmlDoc.load("c:\เอกสารของฉัน\books.xml"); var root = xmlDoc.documentElement; var newAttr = xmlDoc.createAttribute("temp"); newAttr.value = "temporary"; root.setAttributeNode(attr); alert(root.getAttribute("temp"));!}
ที่นี่ตัวดำเนินการแจ้งเตือนจะพิมพ์สตริง temporary ด้วย
วิธีการ createAttributeNS ไวยากรณ์ : เอกสาร.createAttributeNS(namespaceURI, QualifiedName) อาร์กิวเมนต์ : namespaceURI, นิพจน์ประเภท QualifiedName ผลลัพธ์ : ข้อยกเว้นวัตถุ Attr ใหม่ : INVALID_CHARACTER_ERR, NAMESPACE_ERR Support : ไม่รองรับ ไม่รองรับ.เมธอด createAttributeNS จะสร้างวัตถุ Attr ใหม่และส่งคืนตัวชี้ไปที่วัตถุนั้น มีไว้สำหรับเอกสาร XML และอาจไม่รองรับเอกสาร HTML อาร์กิวเมนต์ namespaceURI ระบุ URI ของเนมสเปซ และ QualifiedName คือชื่อที่ผ่านการรับรองของแอตทริบิวต์ที่จะสร้างในเนมสเปซนั้น วัตถุที่สร้างขึ้นประเภท Attr มีคุณลักษณะดังต่อไปนี้:
ต่อจากนั้น แอตทริบิวต์ที่สร้างขึ้นสามารถกำหนดให้กับองค์ประกอบใดๆ ได้โดยใช้เมธอด Element.setAttributeNode
วิธีการ createCDATASection ไวยากรณ์ : เอกสาร.createCDATASection(data) อาร์กิวเมนต์ : นิพจน์ชนิดข้อมูล ผลลัพธ์ : วัตถุ CDATASection ใหม่ ข้อยกเว้น : NOT_SUPPORTED_ERR การสนับสนุน : เป็นไปตามมาตรฐาน ตรงตามมาตรฐานวิธีการ createCDATASection สร้างวัตถุ CDATASection ใหม่ และส่งกลับตัวชี้ไป มีไว้สำหรับเอกสาร XML เท่านั้น การพยายามเรียกมันใน HTML DOM จะเกิดข้อยกเว้น NOT_SUPPORTED_ERR อาร์กิวเมนต์ข้อมูลระบุเนื้อหาของเนื้อหาที่ถูกสร้างขึ้น ตัวอย่างของการสร้างส่วน CDATA ใน Microsoft XMLDOM:
Var xmlDoc = ใหม่ ActiveXObject("Microsoft.XMLDOM"); xmlDoc.async = เท็จ; xmlDoc.load("c:\เอกสารของฉัน\books.xml"); var root = xmlDoc.documentElement; var newSection = xmlDoc.createCDATASection("สวัสดีชาวโลก!"); root.appendChild (มาตราใหม่);
วิธีการ createComment ไวยากรณ์ : เอกสาร.createComment(data) อาร์กิวเมนต์ : นิพจน์ชนิดข้อมูล ผลลัพธ์ : ออบเจ็กต์ความคิดเห็นใหม่ ข้อยกเว้น : ไม่มี การสนับสนุน : สำหรับเอกสาร XML เท่านั้น ตรงตามมาตรฐานวิธีการ createComment จะสร้างวัตถุความคิดเห็นใหม่และส่งคืนตัวชี้ไปที่มัน อาร์กิวเมนต์ข้อมูลระบุเนื้อหาของความคิดเห็นที่จะสร้าง ตัวอย่างการสร้างความคิดเห็นใน Gecko:
ราก Var = document.documentElement.firstChild; var comm = document.createComment("นี่คือความคิดเห็น"); root.appendChild(คอม);
วิธีการ createDocumentFragment ไวยากรณ์ : เอกสาร.createDocumentFragment() ผลลัพธ์ : วัตถุใหม่ ข้อยกเว้น : ไม่มี การสนับสนุน : สำหรับเอกสาร XML เท่านั้น ตรงตามมาตรฐานเมธอด createDocumentFragment จะสร้างอ็อบเจ็กต์ว่างชนิดใหม่และส่งกลับตัวชี้กลับไป ตัวอย่างการสร้างส่วนของเอกสารใน Gecko:
องค์ประกอบ = document.documentElement.firstChild; var o = document.createDocumentFragment(); elem.appendChild(o);
วิธีการ createElement ไวยากรณ์ : เอกสาร.createElement(tagName) อาร์กิวเมนต์ : นิพจน์ประเภท tagName ผลลัพธ์ : ข้อยกเว้นของวัตถุองค์ประกอบใหม่ : การสนับสนุน INVALID_CHARACTER_ERR : เป็นไปตามมาตรฐาน (ดูหมายเหตุ 2) ตรงตามมาตรฐานเมธอด createElement จะสร้างออบเจ็กต์ใหม่ประเภท Element และส่งคืนพอยน์เตอร์กลับไป อาร์กิวเมนต์ tagName ระบุแท็กขององค์ประกอบที่ถูกสร้างขึ้น แอ็ตทริบิวต์ nodeName ของอ็อบเจ็กต์ใหม่คือ tagName และแอ็ตทริบิวต์ localName คำนำหน้า และ namespaceURI ของมันคือ null หากออบเจ็กต์มีคุณลักษณะที่มีค่าเริ่มต้น โหนด Attr ที่เกี่ยวข้องจะถูกสร้างขึ้นและแนบกับองค์ประกอบโดยอัตโนมัติ
หมายเหตุ:
ATTRIBUTE_NODE | แอตทริบิวต์ของ OwnerElement เป็น null ระบุเป็น true ลูกทั้งหมดของโหนดเดิมจะถูกคัดลอกซ้ำไปยังโหนด Attr ใหม่ โดยไม่คำนึงถึงค่าลึก |
DOCUMENT_FRAGMENT_NODE | หาก deep เป็นจริง ระบบจะนำเข้าส่วนของเอกสารที่ระบุ มิฉะนั้น โหนดว่างจะถูกสร้างขึ้น |
DOCUMENT_NODE, DOCUMENT_TYPE_NODE | ไม่สามารถนำเข้าได้ |
ELEMENT_NODE | คุณลักษณะทั้งหมดของโหนดดั้งเดิม ยกเว้นที่ระบุโดยค่าเริ่มต้นในเอกสารต้นฉบับ จะถูกคัดลอกไปยังโหนดองค์ประกอบใหม่ จากนั้นแอตทริบิวต์เริ่มต้นที่ยอมรับในเอกสารนี้สำหรับองค์ประกอบที่มีชื่อนั้นจะถูกสร้างขึ้น หาก deep เป็นจริง ทรีย่อยทั้งหมดขององค์ประกอบดั้งเดิมจะถูกนำเข้า |
ENTITY_NODE | โหนด DocumentType ของเอนทิตี |
ENTITY_REFERENCE_NODE | เฉพาะโหนด EntityReference เท่านั้นที่จะถูกคัดลอก โดยไม่คำนึงถึงค่าลึก หากเอกสารของเรามีคำจำกัดความส่วนตามชื่อที่กำหนด เอกสารนั้นก็จะถูกป้อนลงในโหนดใหม่ |
NOTATION_NODE | สามารถนำเข้าโหนดสัญลักษณ์ได้ แต่ใน DOM 2 DocumentType เป็นแบบอ่านอย่างเดียว ดังนั้นการนำเข้าโหนดดังกล่าวจึงไม่สมเหตุสมผล |
PROCESSING_INSTRUCTION_NODE | ค่าของเป้าหมายและแอตทริบิวต์ข้อมูลของโหนดต้นทางจะถูกคัดลอก |
TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE | ค่าของข้อมูลและแอตทริบิวต์ความยาวของโหนดต้นทางจะถูกคัดลอก |
จัดทำโดย: Evgeny Ryzhkov วันที่ตีพิมพ์: 15/11/2010
แผนผังเอกสารคือไดอะแกรมสำหรับสร้างเอกสาร HTML ที่แสดงความสัมพันธ์ระหว่างองค์ประกอบของหน้าต่างๆ ได้แก่ ลำดับและการซ้อนองค์ประกอบ แผนภาพนี้ช่วยนำทางไปยังแท็ก HTML ที่ดูเหมือนจะวุ่นวาย
แผนผังเอกสารช่วยนักพัฒนาเว็บเมื่อเขียนกฎ CSS และสคริปต์ Javascript
หมายเหตุอย่าสับสนแผนผังเอกสารกับ Document Object Model (DOM) DOM เป็นแนวคิดที่ซับซ้อนกว่า (เราจะเขียนเกี่ยวกับเรื่องนี้ในภายหลัง)
เพื่อไม่ให้อธิบายยาวและน่าเบื่อว่าทำไมแผนผังเอกสารจึงถูกเรียกว่าแผนผัง ลองดูตัวอย่าง - ใช้โค้ด HTML ง่ายๆ:
ชื่อหน้า ชื่อหลัก
ย่อหน้าของข้อความ
- วรรค 1
- จุดที่ 2
นี่คือลักษณะที่โค้ด HTML ปรากฏโดยชาวพื้นเมืองที่ไม่ได้รับแจ้งซึ่งคลิกเพื่อดูโค้ดของหน้าโดยไม่ได้ตั้งใจ แต่สายตาที่ผ่านการฝึกอบรมของนักพัฒนาเว็บจะแยกมันออกจากกัน เห็นทุกระดับของการซ้อนและการเชื่อมต่อโครงข่าย มันจะสร้างโครงสร้างลำดับชั้นที่ชัดเจนในรูปแบบของต้นไม้จากความสับสนวุ่นวาย (เพราะแผนภาพคล้ายกับโครงร่างของต้นไม้):
ความสัมพันธ์ในครอบครัวมีการเชื่อมต่อบางอย่างระหว่างองค์ประกอบของแผนผังเอกสาร มาดูพวกเขากันดีกว่า
บรรพบุรุษและลูกหลานจากภาพแผนผังของต้นไม้ และจากโค้ด HTML เอง เห็นได้ชัดว่าองค์ประกอบบางอย่างซ้อนอยู่ในองค์ประกอบอื่น องค์ประกอบที่มีองค์ประกอบอื่นอยู่นั้นเป็นบรรพบุรุษ (บรรพบุรุษ) ของทุกสิ่งที่ฝังอยู่ในนั้น พวกที่ซ้อนอยู่ก็เป็นลูกหลานของมัน (ลูกหลาน)
เพื่อความชัดเจน ให้พิจารณากิ่งก้านหนึ่งของต้นไม้ของเรา:
บรรพบุรุษแต่ละคนสามารถมีผู้สืบทอดได้ไม่จำกัดจำนวน ผู้สืบทอดแต่ละคนจะมีบรรพบุรุษจำนวนหนึ่งขึ้นอยู่กับโครงสร้างของต้นไม้และกิ่งก้านที่จะตั้งอยู่ แต่ไม่ว่าในกรณีใดก็จะมีบรรพบุรุษอย่างน้อยหนึ่งคน
พ่อแม่และลูกสาวParent คือบรรพบุรุษลำดับต้น (บรรพบุรุษระดับที่หนึ่ง) ขององค์ประกอบ ในทางกลับกัน เด็กที่อยู่ใกล้ชิด (เด็กระดับที่ 1) เรียกว่าเด็ก
ผู้ปกครองแต่ละคนสามารถมีลูกสาวได้ไม่จำกัดจำนวน องค์ประกอบลูกจะมีพาเรนต์เพียงตัวเดียวเท่านั้น
องค์ประกอบหลักเรียกอีกอย่างว่าบรรพบุรุษโดยตรง และองค์ประกอบลูกเป็นผู้สืบทอดโดยตรง สิ่งเหล่านี้เหมือนกับชื่อเชิงความหมาย
องค์ประกอบน้องสาวพี่น้องคือกลุ่มขององค์ประกอบตั้งแต่สององค์ประกอบขึ้นไปที่มีผู้ปกครองร่วมกัน องค์ประกอบไม่จำเป็นต้องเป็นประเภทเดียวกัน เพียงแต่ต้องมีองค์ประกอบหลักร่วมกัน
องค์ประกอบที่อยู่ติดกันองค์ประกอบที่อยู่ติดกันคือองค์ประกอบพี่น้องที่อยู่ใน "บริเวณใกล้เคียง"
พี่สาวคนก่อนและน้องสาวคนถัดไปทุกอย่างที่นี่ควรชัดเจนจากชื่อของคำศัพท์เอง พี่น้องก่อนหน้า - องค์ประกอบน้องสาวก่อนหน้าตามโค้ด ใช้สาขาตัวอย่างของเราสำหรับ
- มันจะเป็น
- วรรค 1
- จุดที่ 2
สำหรับ
- และเพราะว่าจะไม่มีความเป็นพี่น้องกันมาก่อน
ในทำนองเดียวกันพี่สาวคนต่อไป (พี่น้องที่ตามมา): สำหรับ -
สำหรับ
—
- , สำหรับ
- - เลขที่.ก่อนหน้าและถัดไป
องค์ประกอบก่อนหน้า (ก่อนหน้า) - องค์ประกอบก่อนหน้าเดียวกันตามรหัส โดยไม่มีข้อจำกัดด้านความสัมพันธ์พี่น้อง สำหรับสาขาของเรา: สำหรับ
- มันจะเป็น
สำหรับ
- , สำหรับ - .
ในบทความนี้ ฉันอยากจะบอกคุณว่าแผนผังเอกสารใน HTML คืออะไร และองค์ประกอบต่างๆ ในนั้นเชื่อมโยงกันอย่างไร
ในเอกสาร html แท็กจำนวนมากจะซ้อนกันอยู่ภายในแท็กอื่นๆ เช่น:
< html> < head> < title>ชื่อตัวอย่าง< body> < div class = ”container”> < h1>บางสิ่งบางอย่างที่สำคัญ< div class = ”left”> < h2>ข้อมูลที่สำคัญน้อยกว่าเล็กน้อย< p>เนื้อหาของหน้า< ul> < li>วรรค 1< li>จุดที่ 2< li>จุดที่ 3
นี่คือลักษณะของโค้ดของเพจ แต่นักพัฒนามองเห็นแตกต่างออกไป ชุดสัญลักษณ์ที่วุ่นวายนี้ต้องขอบคุณความเข้าใจในโครงสร้างของเอกสาร จึงถูกสร้างขึ้นในโครงการที่กำหนดไว้อย่างชัดเจน เขาจึงเห็นว่าส่วนหัวและลำตัวซ้อนอยู่ใน html และ h2 pul ใน div class = “left” และอื่นๆ
แผนผังเอกสารคือการแสดงแผนผังของโค้ดเพจ ซึ่งสะท้อนถึงความสัมพันธ์ระหว่างแท็ก
ในทางกลับกัน ขึ้นอยู่กับลักษณะของการเชื่อมต่อที่รวมองค์ประกอบของหน้าเข้าด้วยกัน พวกเขาจะถูกแบ่งออกเป็นบรรพบุรุษและลูกหลาน พ่อแม่และลูกสาว องค์ประกอบน้องสาว และอื่น ๆ
บรรพบุรุษและลูกหลานดังที่ได้กล่าวไว้ข้างต้น ในโค้ด html องค์ประกอบสามารถรวมองค์ประกอบอื่นๆ ไว้ภายในตัวมันเองได้ ดังนั้นแท็กที่มีแท็กอื่นอยู่ภายในเรียกว่า ancestor และ "อื่นๆ" เหล่านี้เรียกว่าทายาท
จำนวนทายาทของบรรพบุรุษไม่ได้จำกัดด้วยสิ่งใดๆ จำนวนบรรพบุรุษจะขึ้นอยู่กับตำแหน่งขององค์ประกอบภายในโครงสร้างเอกสาร
พ่อแม่และลูกสาวบรรพบุรุษที่มีระดับแรกของการทำรังเรียกว่าพ่อแม่ และลูกที่อยู่ในนั้นโดยตรงเรียกว่าลูก
ไม่มีการจำกัดจำนวนองค์ประกอบลูกที่อยู่ในพาเรนต์ แต่ลูกสามารถมีพาเรนต์ได้เพียงคนเดียวเท่านั้น
บางครั้งเรียกว่าพ่อแม่และลูกสาว บรรพบุรุษสายตรงและทายาทสายตรง.
ลองดูตัวอย่างของเราหัวหน้าเป็นผู้ปกครองและบรรพบุรุษของตำแหน่ง และเป็นลูกและลูกของศีรษะ h2, p, ul, li เป็นลูกของ div class=”left” ในขณะที่ li ก็เป็นลูกของ ul และ div class=”left” พร้อมกัน และมีเพียง ul เท่านั้นที่เป็นพาเรนต์ของ li นี่คือความแตกต่างที่สำคัญระหว่างบรรพบุรุษกับพ่อแม่ กับลูกสาวกับลูกหลาน
พี่น้องซึ่งรวมถึงองค์ประกอบลูกที่ใช้พาเรนต์ร่วมกัน
แท็กน้องสาวสนใจเพียงการมีพาเรนต์ร่วมกัน และประเภทองค์ประกอบอาจแตกต่างกันได้ ตัวอย่างเช่น:
h2, p, ul เป็นพี่น้องกันและอยู่ใน parent div class=”left” ในขณะเดียวกัน li ทั้งหมดก็จะเป็นพี่น้องกันภายใต้ parent ul เท่านั้น
ติดกันแท็กที่อยู่เคียงข้างกันในโครงสร้างเอกสารและมีพาเรนต์เดียว
ตามตัวอย่างของเรา h2 อยู่ติดกับ p, ul อยู่ติดกับ p และ p อยู่ติดกับ ul และ h2 ในเวลาเดียวกัน
พี่สาวคนก่อนและคนต่อไปทุกอย่างเรียบง่ายที่นี่: องค์ประกอบน้องสาวถัดไป (พี่น้องที่ตามมา) - ตามโค้ด มาทันทีหลังจากแท็กที่เราสนใจและมีพาเรนต์ร่วมกันด้วย และองค์ประกอบพี่น้องก่อนหน้า (พี่น้องก่อนหน้า) เป็นแท็กที่นำหน้า ของเราและยังมีพ่อแม่เลี้ยงเดี่ยวด้วย
ก่อนหน้าและถัดไปพวกมันคล้ายกันมากกับการเชื่อมต่อที่เราเพิ่งอธิบายไป แต่มีความแตกต่าง - ในกรณีนี้การมีอยู่ของผู้ปกครองร่วมกันไม่สำคัญสำหรับเรา ตัวอย่างเช่น หากไม่มีแท็กน้องสาวก่อนหน้าสำหรับ h2 ดังนั้นแท็กก่อนหน้า (ก่อนหน้า) สำหรับแท็กนั้นจะเป็น div class = “left” โดยแท็กถัดไป (ก่อนหน้า) เป็นรูปภาพเดียวกัน
ลูกคนแรกและลูกสุดท้ายลูกคนแรก (ลูกคนแรก) คือองค์ประกอบลูกที่เป็นคนแรกสำหรับพาเรนต์ ลูกสุดท้าย (ลูกคนสุดท้าย) จึงเป็นแท็กสุดท้ายภายในพาเรนต์
ตัวอย่างเช่น สำหรับ div class=”left” ลูกคนแรกจะเป็น h2 และลูกสุดท้ายจะเป็น ul
องค์ประกอบรากถือเป็นแท็กที่ไม่มีบรรพบุรุษหรือผู้ปกครอง รวมถึง "กิ่งก้าน" ทั้งหมดของแผนผังของเราและเปิดที่จุดเริ่มต้นของเอกสาร (< html>) และปิดที่ส่วนท้ายสุด ( )
สรุปการทำความเข้าใจโครงสร้างของแผนผังองค์ประกอบตลอดจนการเชื่อมต่อที่เกี่ยวข้องทั้งหมดจะไม่เพียงช่วยให้คุณนำทางโค้ดได้อย่างง่ายดายและรวดเร็ว แต่ยังช่วยให้เลือกแท็กที่เราต้องการใน CSS ได้ง่ายขึ้นและแม่นยำยิ่งขึ้น
แผนผังเอกสารคือไดอะแกรมสำหรับสร้างเอกสาร HTML ที่แสดงความสัมพันธ์ระหว่างองค์ประกอบของหน้าต่างๆ ได้แก่ ลำดับและการซ้อนองค์ประกอบ แผนภาพนี้ช่วยนำทางไปยังแท็ก HTML ที่ดูเหมือนจะวุ่นวาย
แผนผังเอกสารช่วยนักพัฒนาเว็บเมื่อเขียนกฎ CSS และสคริปต์ Javascript
หมายเหตุอย่าสับสนแผนผังเอกสารกับ Document Object Model (DOM) DOM เป็นแนวคิดที่ซับซ้อนกว่า (เราจะเขียนเกี่ยวกับเรื่องนี้ในภายหลัง)
เพื่อไม่ให้อธิบายยาวและน่าเบื่อว่าทำไมแผนผังเอกสารจึงถูกเรียกว่าแผนผัง ลองดูตัวอย่าง - ใช้โค้ด HTML ง่ายๆ:
ชื่อหน้า ชื่อหลัก
ย่อหน้าของข้อความ
นี่คือลักษณะที่โค้ด HTML ปรากฏโดยชาวพื้นเมืองที่ไม่ได้รับแจ้งซึ่งคลิกเพื่อดูโค้ดของหน้าโดยไม่ได้ตั้งใจ แต่สายตาที่ผ่านการฝึกอบรมของนักพัฒนาเว็บจะแยกมันออกจากกัน เห็นทุกระดับของการซ้อนและการเชื่อมต่อโครงข่าย มันจะสร้างโครงสร้างลำดับชั้นที่ชัดเจนในรูปแบบของต้นไม้จากความสับสนวุ่นวาย (เพราะแผนภาพคล้ายกับโครงร่างของต้นไม้):
ความสัมพันธ์ในครอบครัวมีการเชื่อมต่อบางอย่างระหว่างองค์ประกอบของแผนผังเอกสาร มาดูพวกเขากันดีกว่า
บรรพบุรุษและลูกหลานจากภาพแผนผังของต้นไม้ และจากโค้ด HTML เอง เห็นได้ชัดว่าองค์ประกอบบางอย่างซ้อนอยู่ในองค์ประกอบอื่น องค์ประกอบที่มีองค์ประกอบอื่นอยู่นั้นเป็นบรรพบุรุษ (บรรพบุรุษ) ของทุกสิ่งที่ฝังอยู่ในนั้น พวกที่ซ้อนอยู่ก็เป็นลูกหลานของมัน (ลูกหลาน)
เพื่อความชัดเจน ให้พิจารณากิ่งก้านหนึ่งของต้นไม้ของเรา:
บรรพบุรุษแต่ละคนสามารถมีผู้สืบทอดได้ไม่จำกัดจำนวน ผู้สืบทอดแต่ละคนจะมีบรรพบุรุษจำนวนหนึ่งขึ้นอยู่กับโครงสร้างของต้นไม้และกิ่งก้านที่จะตั้งอยู่ แต่ไม่ว่าในกรณีใดก็จะมีบรรพบุรุษอย่างน้อยหนึ่งคน
พ่อแม่และลูกสาวParent คือบรรพบุรุษลำดับต้น (บรรพบุรุษระดับที่หนึ่ง) ขององค์ประกอบ ในทางกลับกัน เด็กที่อยู่ใกล้ชิด (เด็กระดับที่ 1) เรียกว่าเด็ก
ผู้ปกครองแต่ละคนสามารถมีลูกสาวได้ไม่จำกัดจำนวน องค์ประกอบลูกจะมีพาเรนต์เพียงตัวเดียวเท่านั้น
องค์ประกอบหลักเรียกอีกอย่างว่าบรรพบุรุษโดยตรง และองค์ประกอบลูกเป็นผู้สืบทอดโดยตรง สิ่งเหล่านี้เหมือนกับชื่อเชิงความหมาย
องค์ประกอบน้องสาวพี่น้องคือกลุ่มขององค์ประกอบตั้งแต่สององค์ประกอบขึ้นไปที่มีผู้ปกครองร่วมกัน องค์ประกอบไม่จำเป็นต้องเป็นประเภทเดียวกัน เพียงแต่ต้องมีองค์ประกอบหลักร่วมกัน
องค์ประกอบที่อยู่ติดกันคือองค์ประกอบพี่น้องที่อยู่ใน "บริเวณใกล้เคียง"
ทุกอย่างที่นี่ควรชัดเจนจากชื่อของคำศัพท์เอง พี่น้องก่อนหน้า - องค์ประกอบน้องสาวก่อนหน้าตามโค้ด ใช้สาขาตัวอย่างของเราสำหรับ
- มันจะเป็น
สำหรับ
- และเพราะว่าจะไม่มีความเป็นพี่น้องกันมาก่อน
ในทำนองเดียวกันพี่สาวคนต่อไป (พี่น้องที่ตามมา): สำหรับ -
สำหรับ
—
- , สำหรับ
- - เลขที่.ก่อนหน้าและถัดไป
องค์ประกอบก่อนหน้า (ก่อนหน้า) - องค์ประกอบก่อนหน้าเดียวกันตามรหัส โดยไม่มีข้อจำกัดด้านความสัมพันธ์พี่น้อง สำหรับสาขาของเรา: สำหรับ
- มันจะเป็น
สำหรับ
- , สำหรับ - .
ในทำนองเดียวกัน องค์ประกอบต่อไปนี้ (ก่อนหน้า) ไม่มีข้อจำกัดแบบพี่น้อง: for -
สำหรับลูกคนแรกและคนสุดท้าย
ลูกคนแรกคือลูกคนแรกของพาเรนต์ในแผนผังเอกสาร และลูกคนสุดท้ายคือลูกคนสุดท้าย
องค์ประกอบรูทคือบรรพบุรุษของบรรพบุรุษทั้งหมด มันเป็น "รูท" ของแผนผังเอกสารของเรา มันเป็นองค์ประกอบเดียวที่ไม่มีพาเรนต์คือ
การทำงานกับโมเดล DOM
วัตถุ Window ทุกอันมีคุณสมบัติเอกสารที่อ้างอิงถึงวัตถุเอกสาร วัตถุเอกสารนี้ไม่ใช่วัตถุแบบสแตนด์อโลน เป็นออบเจ็กต์กลางของ API ที่ครอบคลุมที่เรียกว่า Document Object Model (DOM) ซึ่งกำหนดวิธีการเข้าถึงเนื้อหาเอกสาร
ภาพรวม DOMDocument Object Model (DOM) เป็นอินเทอร์เฟซการเขียนโปรแกรมแอปพลิเคชันพื้นฐานที่ให้ความสามารถในการทำงานกับเนื้อหาของเอกสาร HTML และ XML DOM application programming interface (API) ไม่ได้ซับซ้อนเป็นพิเศษ แต่มีคุณสมบัติทางสถาปัตยกรรมมากมายที่คุณควรทราบ
ขั้นแรก ทำความเข้าใจว่าองค์ประกอบที่ซ้อนกันในเอกสาร HTML หรือ XML จะแสดงเป็นแผนผังของวัตถุ DOM มุมมองแบบต้นไม้ของเอกสาร HTML มีโหนดที่แสดงถึงองค์ประกอบหรือแท็ก เช่น และ
และโหนดที่แสดงบรรทัดข้อความ เอกสาร HTML ยังสามารถประกอบด้วยโหนดที่แสดงถึงความคิดเห็น HTML พิจารณาเอกสาร HTML แบบง่ายต่อไปนี้:
เอกสารตัวอย่าง นี่คือเอกสาร HTML
ตัวอย่าง เรียบง่ายข้อความ.
การแสดง DOM ของเอกสารนี้แสดงในแผนภาพต่อไปนี้:
สำหรับผู้ที่ไม่คุ้นเคยกับโครงสร้างต้นไม้ในการเขียนโปรแกรมคอมพิวเตอร์ จะเป็นประโยชน์ที่จะรู้ว่าคำศัพท์ที่ใช้อธิบายโครงสร้างต้นไม้นั้นยืมมาจากแผนผังลำดับวงศ์ตระกูล โหนดที่อยู่เหนือโหนดนี้เรียกว่า ผู้ปกครองที่เกี่ยวข้องกับโหนดนี้ โหนดที่อยู่ต่ำกว่าโหนดอื่นหนึ่งระดับคือ บริษัท ย่อยที่เกี่ยวข้องกับโหนดนี้ โหนดที่อยู่ระดับเดียวกันและมีพาเรนต์เดียวกันจะถูกเรียก น้องสาว. โหนดที่อยู่ต่ำกว่าโหนดอื่นจำนวนเท่าใดก็ได้จะเป็นลูกของมัน โหนดหลัก ปู่ย่าตายาย และโหนดอื่นๆ ที่อยู่เหนือโหนดที่กำหนดคือบรรพบุรุษของมัน
แต่ละสี่เหลี่ยมในแผนภาพนี้คือโหนดเอกสาร ซึ่งแสดงโดยออบเจ็กต์โหนด โปรดทราบว่ารูปนี้แสดงโหนดที่แตกต่างกันสามประเภท รากของแผนผังคือโหนดเอกสาร ซึ่งแสดงถึงเอกสารทั้งหมด โหนดที่แสดงองค์ประกอบ HTML คือโหนดประเภท Element และโหนดที่แสดงข้อความคือโหนดประเภท Text Document, Element และ Text เป็นคลาสย่อยของคลาส Node Document และ Element เป็นสองคลาสที่สำคัญที่สุดใน DOM
ประเภทโหนดและประเภทย่อยจะสร้างลำดับชั้นของประเภทที่แสดงในแผนภาพด้านล่าง สังเกตความแตกต่างอย่างเป็นทางการระหว่างประเภททั่วไป Document และ Element และประเภท HTMLDocument และ HTMLElement ประเภทเอกสารแสดงถึงเอกสาร HTML และ XML และคลาสองค์ประกอบแสดงถึงองค์ประกอบของเอกสารนั้น คลาสย่อย HTMLDocument และ HTMLElement เป็นตัวแทนเฉพาะเอกสาร HTML และองค์ประกอบของมัน:
อีกสิ่งหนึ่งที่ควรทราบในแผนภาพนี้คือ มีประเภทย่อยจำนวนมากของคลาส HTMLElement ที่แสดงประเภทเฉพาะขององค์ประกอบ HTML แต่ละรายการกำหนดคุณสมบัติ JavaScript ที่สะท้อนถึงแอตทริบิวต์ HTML ขององค์ประกอบเฉพาะหรือกลุ่มขององค์ประกอบ คลาสเฉพาะเหล่านี้บางคลาสจะกำหนดคุณสมบัติหรือเมธอดเพิ่มเติมที่ไม่สะท้อนถึงไวยากรณ์ภาษามาร์กอัป HTML
การเลือกองค์ประกอบเอกสารการทำงานของโปรแกรมไคลเอนต์ส่วนใหญ่ในภาษา JavaScript นั้นเกี่ยวข้องกับการยักย้ายองค์ประกอบของเอกสาร ณ รันไทม์ โปรแกรมเหล่านี้สามารถใช้เอกสารตัวแปรโกลบอล ซึ่งอ้างอิงถึงอ็อบเจ็กต์ Document อย่างไรก็ตาม เพื่อดำเนินการจัดการใด ๆ กับองค์ประกอบของเอกสาร โปรแกรมจะต้องได้รับหรือเลือกวัตถุองค์ประกอบที่อ้างถึงองค์ประกอบของเอกสารเหล่านั้น DOM กำหนดหลายวิธีในการเลือกองค์ประกอบ คุณสามารถเลือกองค์ประกอบหรือองค์ประกอบของเอกสาร:
ตามค่าของแอตทริบิวต์ id;
ตามค่าของแอตทริบิวต์ชื่อ
ตามชื่อแท็ก
โดยคลาส CSS หรือชื่อคลาส
โดยการจับคู่ตัวเลือก CSS ที่เฉพาะเจาะจง
เทคนิคการสุ่มตัวอย่างองค์ประกอบทั้งหมดนี้อธิบายไว้ในส่วนย่อยต่อไปนี้
การเลือกองค์ประกอบตามค่าแอตทริบิวต์ idองค์ประกอบ HTML ทั้งหมดมีแอตทริบิวต์รหัส ค่าของแอตทริบิวต์นี้จะต้องไม่ซ้ำกันภายในเอกสาร ไม่มีองค์ประกอบสองรายการในเอกสารเดียวกันจะต้องมีค่าแอตทริบิวต์รหัสเดียวกัน คุณสามารถเลือกองค์ประกอบตามค่าแอตทริบิวต์ ID ที่ไม่ซ้ำกันโดยใช้เมธอด getElementById() ของอ็อบเจ็กต์ Document:
วาร์ Section1 = document.getElementById("section1");
นี่เป็นวิธีที่ง่ายที่สุดและแพร่หลายที่สุดในการเลือกองค์ประกอบ หากสคริปต์ของคุณจำเป็นต้องสามารถจัดการชุดองค์ประกอบเอกสารเฉพาะได้ ให้กำหนดค่าให้กับแอตทริบิวต์ id ขององค์ประกอบเหล่านั้น และใช้ความสามารถในการค้นหาโดยใช้ค่าเหล่านั้น
ใน Internet Explorer เวอร์ชันก่อนหน้า IE8 เมธอด getElementById() จะค้นหาค่าแอตทริบิวต์ id ในลักษณะที่ไม่คำนึงถึงตัวพิมพ์เล็กและใหญ่ และยังส่งคืนองค์ประกอบที่ตรงกับค่าแอตทริบิวต์ของชื่ออีกด้วย
การเลือกองค์ประกอบตามค่าแอตทริบิวต์ชื่อเดิมทีแอตทริบิวต์ชื่อ HTML มีวัตถุประสงค์เพื่อตั้งชื่อองค์ประกอบของแบบฟอร์ม และค่าของแอตทริบิวต์นี้ถูกใช้เมื่อมีการส่งข้อมูลแบบฟอร์มไปยังเซิร์ฟเวอร์ เช่นเดียวกับแอตทริบิวต์ id คุณลักษณะ name จะกำหนดชื่อให้กับองค์ประกอบ อย่างไรก็ตาม ค่าของแอตทริบิวต์ชื่อไม่จำเป็นต้องไม่ซ้ำกัน ซึ่งต่างจาก id ตรงที่องค์ประกอบหลายอย่างสามารถมีชื่อเดียวกันได้ ซึ่งเป็นเรื่องปกติเมื่อใช้ในรูปแบบของปุ่มตัวเลือกและช่องทำเครื่องหมาย นอกจากนี้ แอตทริบิวต์ name จะแตกต่างจากรหัสตรงตรงที่อนุญาตให้ใช้กับองค์ประกอบ HTML บางอย่างเท่านั้น รวมถึงแบบฟอร์ม องค์ประกอบของแบบฟอร์ม และ .
คุณสามารถเลือกองค์ประกอบ HTML ตามค่าของแอตทริบิวต์ชื่อโดยใช้เมธอด getElementsByName() ของวัตถุ Document:
var radiobuttons = document.getElementsByName("favorite_color");
เมธอด getElementsByName() ไม่ได้ถูกกำหนดโดยคลาส Document แต่โดยคลาส HTMLDocument ดังนั้นจึงใช้ได้เฉพาะในเอกสาร HTML และไม่มีในเอกสาร XML มันส่งคืนวัตถุ NodeList ซึ่งทำงานเหมือนอาร์เรย์วัตถุองค์ประกอบแบบอ่านอย่างเดียว
ใน IE เมธอด getElementsByName() ยังส่งคืนองค์ประกอบที่มีค่าแอตทริบิวต์ id ตรงกับค่าที่ระบุ เพื่อให้มั่นใจถึงความเข้ากันได้ข้ามเบราว์เซอร์ คุณต้องระมัดระวังในการเลือกค่าแอตทริบิวต์และอย่าใช้สตริงเดียวกันกับค่าสำหรับแอตทริบิวต์ชื่อและรหัส
เลือกรายการตามประเภทเมธอด getElementsByTagName() ของอ็อบเจ็กต์ Document ช่วยให้คุณสามารถเลือกองค์ประกอบ HTML หรือ XML ทั้งหมดของประเภทที่ระบุ (หรือตามชื่อแท็ก) ตัวอย่างเช่น คุณอาจได้รับออบเจ็กต์ที่มีลักษณะคล้ายอาร์เรย์แบบอ่านอย่างเดียวซึ่งมีออบเจ็กต์ Element ขององค์ประกอบทั้งหมดในเอกสารดังนี้:
ช่วง Var = document.getElementsByTagName("span");
คล้ายกับเมธอด getElementsByName() getElementsByTagName() ส่งคืนอ็อบเจ็กต์ NodeList องค์ประกอบเอกสารจะรวมอยู่ในอาร์เรย์ NodeList ตามลำดับเดียวกับที่ปรากฏในเอกสาร เช่น องค์ประกอบแรก
ในเอกสารคุณสามารถเลือก:
Var firstParagraph = document.getElementsByTagName("p");
ชื่อแท็ก HTML ไม่คำนึงถึงขนาดตัวพิมพ์ และเมื่อใช้ getElementsByTagName() กับเอกสาร HTML ระบบจะทำการเปรียบเทียบแบบไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่กับชื่อแท็ก ตัวอย่างเช่น ตัวแปร spans ที่สร้างขึ้นด้านบนจะรวมองค์ประกอบทั้งหมดที่เขียนเป็น
คุณสามารถรับ NodeList ที่มีองค์ประกอบทั้งหมดของเอกสารได้โดยการส่งอักขระตัวแทน "*" ไปยังเมธอด getElementsByTagName()
นอกจากนี้ คลาส Element ยังกำหนดเมธอด getElementsByTagName() อีกด้วย มันทำหน้าที่เหมือนกับเวอร์ชันคลาส Document ของเมธอด แต่เลือกเฉพาะอิลิเมนต์ที่สืบทอดมาจากอิลิเมนต์ที่ถูกเรียกใช้เมธอด นั่นคือค้นหาองค์ประกอบทั้งหมดภายในองค์ประกอบแรก
คุณสามารถทำได้ดังนี้:
Var firstParagraph = document.getElementsByTagName("p"); var firstParagraphSpans = firstParagraph.getElementsByTagName("ช่วง");
ด้วยเหตุผลทางประวัติศาสตร์ คลาส HTMLDocument จะกำหนดคุณสมบัติพิเศษเพื่อเข้าถึงโหนดบางประเภท คุณสมบัติ ภาพ, แบบฟอร์มและ ลิงค์ตัวอย่างเช่น อ้างถึงวัตถุที่ทำงานเหมือนอาร์เรย์แบบอ่านอย่างเดียวที่มีองค์ประกอบ , และ (แต่เฉพาะแท็กเหล่านั้นเท่านั้น ซึ่งมีแอตทริบิวต์ href) คุณสมบัติเหล่านี้อ้างถึงวัตถุ HTMLCollection ซึ่งคล้ายกับวัตถุ NodeList แต่สามารถจัดทำดัชนีเพิ่มเติมโดยค่าของแอตทริบิวต์ id และชื่อ
วัตถุ HTMLDocument ยังกำหนดคุณสมบัติที่มีความหมายเหมือนกันที่ฝังและปลั๊กอินซึ่งเป็นคอลเลกชันขององค์ประกอบ HTMLCollection คุณสมบัติจุดยึดไม่ได้มาตรฐาน แต่สามารถใช้เพื่อเข้าถึงองค์ประกอบต่างๆ ได้ ซึ่งมีแอตทริบิวต์ name แต่ไม่มีแอตทริบิวต์ href คุณสมบัติสคริปต์ถูกกำหนดโดยมาตรฐาน HTML5 และเป็นคอลเลกชันขององค์ประกอบ HTMLCollection
นอกจากนี้ อ็อบเจ็กต์ HTMLDocument ยังกำหนดคุณสมบัติสองประการ ซึ่งแต่ละคุณสมบัติไม่ได้อ้างอิงถึงคอลเลกชัน แต่เป็นองค์ประกอบเดียว คุณสมบัติ document.body แสดงถึงองค์ประกอบเอกสาร HTML และคุณสมบัติ document.head แสดงถึง . คุณสมบัติเหล่านี้จะถูกกำหนดไว้ในเอกสารเสมอ: แม้ว่าเอกสารต้นฉบับจะไม่มีและองค์ประกอบ เบราว์เซอร์ก็จะสร้างขึ้นโดยปริยาย คุณสมบัติ documentElement ของวัตถุ Document อ้างถึงองค์ประกอบรากของเอกสาร ในเอกสาร HTML จะแสดงถึงไฟล์ .
การเลือกองค์ประกอบตามคลาส CSSค่าของแอตทริบิวต์คลาส HTML คือรายการของตัวระบุตั้งแต่ศูนย์ขึ้นไป โดยคั่นด้วยช่องว่าง ช่วยให้คุณสามารถกำหนดชุดขององค์ประกอบเอกสารที่เกี่ยวข้อง: องค์ประกอบใด ๆ ที่มีตัวระบุเดียวกันในแอตทริบิวต์คลาสจะเป็นส่วนหนึ่งของชุดเดียวกัน คลาสคำถูกสงวนไว้ใน JavaScript ดังนั้น JavaScript ฝั่งไคลเอ็นต์จึงใช้คุณสมบัติ className เพื่อเก็บค่าของแอตทริบิวต์คลาส HTML
โดยทั่วไปแล้วแอตทริบิวต์ class จะใช้ร่วมกับสไตล์ชีตแบบเรียงซ้อน CSS เพื่อใช้สไตล์การเรนเดอร์ทั่วไปกับสมาชิกทั้งหมดของชุด อย่างไรก็ตาม นอกจากนี้ มาตรฐาน HTML5 ยังกำหนดเมธอด getElementsByClassName() ซึ่งช่วยให้คุณสามารถเลือกองค์ประกอบเอกสารหลายรายการโดยอิงตามตัวระบุในแอตทริบิวต์คลาส
เช่นเดียวกับเมธอด getElementsByTagName() เมธอด getElementsByClassName() สามารถเรียกใช้ได้ทั้งบนเอกสาร HTML และองค์ประกอบ HTML และส่งคืนอ็อบเจ็กต์ NodeList แบบสดที่มีลูกหลานทั้งหมดของเอกสารหรือองค์ประกอบที่ตรงกับเกณฑ์การค้นหา
เมธอด getElementsByClassName() รับอาร์กิวเมนต์สตริงเดียว แต่ตัวสตริงเองสามารถมีตัวระบุได้หลายตัว โดยคั่นด้วยช่องว่าง องค์ประกอบทั้งหมดที่มีแอตทริบิวต์คลาสมีตัวระบุที่ระบุทั้งหมดจะถือว่าตรงกัน ลำดับของตัวระบุไม่สำคัญ โปรดทราบว่าทั้งในแอตทริบิวต์ class และอาร์กิวเมนต์ของเมธอด getElementsByClassName() ตัวระบุคลาสจะถูกคั่นด้วยช่องว่างแทนที่จะเป็นลูกน้ำ
ด้านล่างนี้เป็นตัวอย่างบางส่วนของการใช้เมธอด getElementsByClassName():
// ค้นหาองค์ประกอบทั้งหมดที่มีคลาส "warning" var warnings = document.getElementsByClassName("warning"); // ค้นหาลูกหลานทั้งหมดขององค์ประกอบที่มีตัวระบุ "log" // ด้วยคลาส "ข้อผิดพลาด" และ "ร้ายแรง" var log = document.getElementById("log"); var fatal = log.getElementsByClassName("ข้อผิดพลาดร้ายแรง");
การเลือกองค์ประกอบโดยใช้ตัวเลือก CSSCSS Cascading Style Sheets มีโครงสร้างทางวากยสัมพันธ์ที่มีประสิทธิภาพมากซึ่งเรียกว่าตัวเลือก ซึ่งช่วยให้คุณสามารถอธิบายองค์ประกอบหรือชุดขององค์ประกอบในเอกสารได้ นอกเหนือจากการกำหนดมาตรฐานตัวเลือก CSS3 แล้ว มาตรฐาน W3C อื่นที่เรียกว่า Selectors API ยังกำหนดวิธีการ JavaScript สำหรับการดึงองค์ประกอบที่ตรงกับตัวเลือกที่ระบุ
กุญแจสำคัญของ API นี้คือเมธอด querySelectorAll() ของออบเจ็กต์ Document ใช้อาร์กิวเมนต์สตริงเดียวกับตัวเลือก CSS และส่งกลับวัตถุ NodeList ที่แสดงองค์ประกอบเอกสารทั้งหมดที่ตรงกับตัวเลือก
นอกเหนือจากเมธอด querySelectorAll() แล้ว อ็อบเจ็กต์เอกสารยังกำหนดเมธอด querySelector() ซึ่งคล้ายกับเมธอด querySelectorAll() ยกเว้นว่าจะส่งกลับเฉพาะองค์ประกอบแรก (ตามลำดับเอกสาร) ที่ตรงกัน หรือเป็นค่าว่างหากไม่มี องค์ประกอบที่ตรงกัน
ทั้งสองวิธีนี้ยังถูกกำหนดโดยคลาส Elements เมื่อมีการเรียกใช้องค์ประกอบ เอกสารทั้งหมดจะถูกค้นหาการจับคู่สำหรับตัวเลือกที่กำหนด จากนั้นผลลัพธ์จะถูกกรองให้รวมเฉพาะรายการสืบทอดขององค์ประกอบที่ใช้ วิธีการนี้อาจดูเหมือนขัดกับสัญชาตญาณเพราะหมายความว่าสตริงตัวเลือกอาจรวมบรรพบุรุษขององค์ประกอบที่จะจับคู่ด้วย
โครงสร้างเอกสารและการนำทางเอกสารหลังจากเลือกองค์ประกอบเอกสารแล้ว บางครั้งจำเป็นต้องค้นหาส่วนที่เกี่ยวข้องกับโครงสร้างของเอกสาร (หลัก พี่น้อง ลูก) วัตถุ Document ถือได้ว่าเป็นแผนผังของวัตถุ Node ประเภทโหนดจะกำหนดคุณสมบัติที่ช่วยให้คุณสามารถนำทางแผนผังดังกล่าวได้ มีอินเทอร์เฟซแอปพลิเคชันอื่นสำหรับการนำทางเอกสาร เช่น แผนผังวัตถุองค์ประกอบ
เอกสารเป็นแผนผังโหนดอ็อบเจ็กต์เอกสาร อ็อบเจ็กต์องค์ประกอบ และอ็อบเจ็กต์ข้อความที่แสดงถึงส่วนของข้อความในเอกสารล้วนเป็นอ็อบเจ็กต์โหนด คลาส Node กำหนดคุณสมบัติที่สำคัญดังต่อไปนี้:
parentNodeโหนดพาเรนต์ของโหนดนี้ หรือค่าว่างสำหรับโหนดที่ไม่มีพาเรนต์ เช่น เอกสาร
เด็กโหนดวัตถุคล้ายอาร์เรย์ที่อ่านได้ (NodeList) ที่ให้การแสดงโหนดลูก
ลูกคนแรก, ลูกสุดท้ายโหนดลูกแรกและโหนดสุดท้าย หรือเป็นโมฆะหากโหนดที่กำหนดไม่มีโหนดลูก
พี่น้องคนต่อไป, พี่น้องคนก่อนโหนดพี่ชายถัดไปและก่อนหน้า โหนดพี่น้องคือสองโหนดที่มีพาเรนต์เดียวกัน ลำดับที่ปรากฏสอดคล้องกับลำดับในเอกสาร คุณสมบัติเหล่านี้เชื่อมโยงโหนดเข้ากับรายการที่เชื่อมโยงแบบทวีคูณ
ประเภทโหนดประเภทของโหนดนี้ โหนดประเภทเอกสารมีค่าเป็น 9 ในคุณสมบัตินี้ โหนดประเภทองค์ประกอบ - ค่า 1. โหนดข้อความประเภทข้อความ - ค่า 3. โหนดประเภทความคิดเห็น - ค่า 8 และโหนดประเภท DocumentFragment - ค่า 11
โหนดค่าเนื้อหาข้อความของโหนดข้อความและความคิดเห็น
โหนดชื่อชื่อของแท็กองค์ประกอบที่มีอักขระทั้งหมดแปลงเป็นตัวพิมพ์ใหญ่
การใช้คุณสมบัติเหล่านี้ของคลาส Node คุณสามารถอ้างอิงโหนดลูกที่สองของโหนดลูกแรกของออบเจ็กต์ Document ดังที่แสดงด้านล่าง:
Document.childNodes.childNodes == document.firstChild.firstChild.nextSibling
สมมติว่าเอกสารที่เป็นปัญหามีแบบฟอร์มดังต่อไปนี้:
ทดสอบสวัสดีชาวโลก!
จากนั้นโหนดลูกที่สองของโหนดลูกแรกจะเป็นองค์ประกอบ ในคุณสมบัติ nodeType มีค่า 1 และในคุณสมบัติ nodeName มีค่า “BODY”
อย่างไรก็ตาม โปรดทราบว่า API นี้มีความอ่อนไหวอย่างยิ่งต่อการเปลี่ยนแปลงข้อความในเอกสาร ตัวอย่างเช่น หากคุณเพิ่มการป้อนบรรทัดเดียวระหว่างแท็ก และ ในเอกสารนี้ อักขระการป้อนบรรทัดนั้นจะกลายเป็นโหนดย่อยลำดับแรก (โหนดข้อความ) ของโหนดย่อยลำดับแรก และโหนดย่อยลำดับที่สองจะกลายเป็นองค์ประกอบ ไม่ใช่
เอกสารเป็นแผนผังองค์ประกอบเมื่อความสนใจหลักอยู่ในองค์ประกอบของเอกสารแทนที่จะอยู่ในข้อความภายในองค์ประกอบ (และพื้นที่สีขาวระหว่างองค์ประกอบเหล่านั้น) จะสะดวกกว่ามากในการใช้อินเทอร์เฟซแอปพลิเคชันที่ช่วยให้คุณตีความเอกสารเป็นแผนผังของวัตถุองค์ประกอบ โดยไม่สนใจโหนดข้อความและความคิดเห็นที่เป็นส่วนหนึ่งของเอกสารด้วย
ส่วนแรกของอินเทอร์เฟซแอปพลิเคชันนี้คือคุณสมบัติลูกของวัตถุองค์ประกอบ เช่นเดียวกับคุณสมบัติ childNodes ค่าของมันคือวัตถุ NodeList อย่างไรก็ตาม ไม่เหมือนกับคุณสมบัติ childNodes ตรงที่รายการลูกมีเพียงออบเจ็กต์ Element เท่านั้น
โปรดทราบว่าโหนดข้อความและข้อคิดเห็นไม่มีโหนดลูก ซึ่งหมายความว่าคุณสมบัติ Node.parentNode ที่อธิบายไว้ข้างต้นจะไม่ส่งคืนโหนดประเภทข้อความหรือความคิดเห็น ค่าของคุณสมบัติ parentNode ของวัตถุ Element ใด ๆ จะเป็นวัตถุ Element อื่นหรือรากของแผนผังเสมอ - วัตถุ Document หรือ DocumentFragment
ส่วนที่สองของอินเทอร์เฟซแอปพลิเคชันสำหรับการนำทางองค์ประกอบเอกสารคือคุณสมบัติของวัตถุองค์ประกอบ ซึ่งคล้ายกับคุณสมบัติสำหรับการเข้าถึงโหนดลูกและโหนดพี่น้องของวัตถุโหนด:
firstElementChild, LastElementChildคล้ายกับคุณสมบัติ firstChild และ LastChild แต่ส่งคืนองค์ประกอบลูก
nextElementSibling, PreviousElementSiblingคล้ายกับคุณสมบัติ nextSibling และ PreviousSibling แต่ส่งคืนองค์ประกอบพี่น้อง
เด็ก ElementCountจำนวนองค์ประกอบลูก ส่งกลับค่าเดียวกันกับคุณสมบัติ children.length
คุณสมบัติการเข้าถึงองค์ประกอบลูกและพี่น้องเหล่านี้ได้รับมาตรฐานและนำไปใช้ในเบราว์เซอร์ปัจจุบันทั้งหมด ยกเว้น IE