ไฮไลท์ของ Django: เทมเพลตบันทึกเส้น (ตอนที่ 2)

เผยแพร่แล้ว: 2022-03-10
สรุปอย่างรวดเร็ว ↬ การสร้างโค้ดส่วนหน้าใน Django ด้วยการสร้างเทมเพลตและการแสดงผลฝั่งเซิร์ฟเวอร์รวมการควบคุม HTML ที่เขียนด้วยลายมืออย่างละเอียดด้วยโค้ดที่สะอาดและคุณลักษณะที่มีประสิทธิภาพของหน้าเว็บที่สร้างขึ้น เราสำรวจการแบ่งหน้าเว็บที่ซับซ้อนออกเป็นเทมเพลตต่างๆ การเขียนองค์ประกอบเหล่านั้น และการใช้แท็กและตัวกรองเพื่อจัดโครงสร้างใหม่ให้กับหน้า HTML ธรรมดา

แนวทางที่ไม่ยุ่งยากบางอย่างในการสร้างเว็บไซต์ต้องการให้นักพัฒนาเขียน HTML ทุกบรรทัดด้วยมือ ในอีกทางหนึ่ง ผู้สร้างไซต์ที่ไม่มีโค้ดในเชิงพาณิชย์จะสร้าง HTML ทั้งหมดสำหรับผู้ใช้โดยอัตโนมัติ บ่อยครั้งทำให้ไม่สามารถอ่านโค้ดผลลัพธ์ได้ Templating อยู่ตรงกลางของสเปกตรัมนั้น แต่ใกล้เคียงกับ HTML ที่เขียนด้วยมือมากกว่าการสร้างโครงสร้างหน้าในแอปพลิเคชันหน้าเดียวโดยใช้ React หรือไลบรารีที่คล้ายกัน จุดที่น่าสนใจบนความต่อเนื่องนี้มีประโยชน์มากมายของ HTML ด้วยตนเองตั้งแต่เริ่มต้น (โค้ดความหมาย/โค้ดที่อ่านได้ การควบคุมโครงสร้างหน้าอย่างสมบูรณ์ การโหลดหน้าอย่างรวดเร็ว) และเพิ่มการแยกข้อกังวลและความกระชับ ทั้งหมดนี้ทำให้เสียเวลาในการเขียน แก้ไข HTML ด้วยมือ บทความนี้สาธิตการใช้เทมเพลต Django เพื่อเขียนหน้าที่ซับซ้อน

HTML สเปกตรัม (ตัวอย่างขนาดใหญ่)

หัวข้อของวันนี้นำไปใช้นอกกรอบ Django Flask (เว็บเฟรมเวิร์กอื่น) และ Pelican (เครื่องมือสร้างไซต์แบบคงที่) เป็นเพียงสองโปรเจ็กต์ Python อื่นๆ ที่ใช้วิธีการเดียวกันในการสร้างเทมเพลต Jinja2 เป็นเอ็นจิ้นการสร้างเทมเพลตที่ทั้งสามเฟรมเวิร์กใช้ แม้ว่าคุณสามารถใช้เฟรมเวิร์กอื่นได้โดยเปลี่ยนการตั้งค่าโปรเจ็กต์ (พูดอย่างเคร่งครัด Jinja2 เป็นซูเปอร์เซ็ตของเทมเพลต Django) เป็นห้องสมุดอิสระที่คุณสามารถรวมเข้ากับโครงการของคุณเองได้แม้ไม่มีกรอบงาน ดังนั้นเทคนิคจากบทความนี้จึงมีประโยชน์ในวงกว้าง

ส่วนก่อนหน้า ในซีรีส์:

  • จุดเด่นของ Django: โมเดลผู้ใช้และการตรวจสอบสิทธิ์ (ตอนที่ 1)
  • จุดเด่นของ Django: โมเดล ผู้ดูแลระบบ และการควบคุมฐานข้อมูลเชิงสัมพันธ์ (ตอนที่ 3)
  • ไฮไลท์ของ Django: การโต้เถียงเรื่องทรัพย์สินทางปัญญาและไฟล์สื่อ (ตอนที่ 4)
เพิ่มเติมหลังกระโดด! อ่านต่อด้านล่าง↓

การแสดงผลฝั่งเซิร์ฟเวอร์

เทมเพลตเป็นเพียงไฟล์ HTML ที่มีการขยาย HTML ด้วยสัญลักษณ์เพิ่มเติม จำไว้ว่า HTML ย่อมาจากอะไร: H yper T ext M arkup L anguage Jinja2 ซึ่งเป็นภาษาที่ใช้สร้างเทมเพลตของเรา เพิ่มภาษาด้วยสัญลักษณ์มาร์กอัปที่มีความหมายเพิ่มเติม โครงสร้างเพิ่มเติมเหล่านี้จะถูกตีความเมื่อเซิร์ฟเวอร์แสดงเทมเพลตเพื่อให้บริการหน้า HTML ธรรมดาแก่ผู้ใช้ (กล่าวคือ สัญลักษณ์เพิ่มเติมจากภาษาเทมเพลตจะไม่ทำให้เป็นผลลัพธ์สุดท้าย)

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

การตั้งค่า

ตัวอย่างเช่น เราจะใช้หน้าเว็บที่ค่อนข้างซับซ้อน เทมเพลตผู้ดูแลระบบของ Start Bootstrap และเขียน HTML ใหม่เป็นเทมเพลต Jinja2 โปรดทราบว่าไลบรารีที่ได้รับอนุญาตจาก MIT ใช้ระบบเทมเพลตที่แตกต่างกัน (ตาม JavaScript และ Pug) เพื่อสร้างหน้าเว็บที่คุณเห็น แต่แนวทางของพวกมันแตกต่างอย่างมากจากการสร้างเทมเพลตสไตล์ Jinja2 ดังนั้นตัวอย่างนี้จึงเป็นวิศวกรรมย้อนกลับมากกว่าการแปล ของโครงการโอเพ่นซอร์สที่ยอดเยี่ยมของพวกเขา หากต้องการดูหน้าเว็บที่เราจะสร้าง คุณสามารถดูตัวอย่างสดของ Start Bootstrap ได้

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

 pip install django git clone https://github.com/philipkiely/sm_dh_2_dashboard.git cd sm_dh_2_dashboard python manage.py migrate python manage.py createsuperuser python manage.py loaddata employee_fixture.json python manage.py runserver

จากนั้น เปิดเว็บเบราว์เซอร์และไปที่ https://127.0.0.1:8000 คุณควรเห็นหน้าเดียวกันกับหน้าตัวอย่าง ซึ่งตรงกับรูปภาพด้านล่าง

หน้าหลักของแดชบอร์ด (ตัวอย่างขนาดใหญ่)

เนื่องจากบทช่วยสอนนี้เน้นที่ส่วนหน้า แอพ Django พื้นฐานจึงง่ายมาก นี้อาจดูเหมือนการกำหนดค่าจำนวนมากสำหรับการนำเสนอหน้าเว็บเดียวและเป็นธรรม อย่างไรก็ตาม การตั้งค่าจำนวนมากนี้สามารถสนับสนุนแอปพลิเคชันที่แข็งแกร่งกว่าได้มาก

ตอนนี้ เราพร้อมแล้วที่จะดำเนินการเปลี่ยนไฟล์ HTML 668 บรรทัดนี้เป็นไซต์ Django ที่ออกแบบอย่างเหมาะสม

แม่แบบและการสืบทอด

ขั้นตอนแรกในการ refactoring หลายร้อยบรรทัดของ HTML ให้เป็น clean code คือการแยกองค์ประกอบออกเป็นเทมเพลตของตนเอง ซึ่ง Django จะเขียนเป็นหน้าเว็บเดียวในระหว่างขั้นตอนการแสดงผล

ลองดูใน เพจ/เทมเพลต คุณควรเห็นห้าไฟล์:

  • base.html เทมเพลตพื้นฐานที่ทุกหน้าเว็บจะขยายออกไป มันมี <head> พร้อมชื่อเรื่อง การนำเข้า CSS ฯลฯ
  • navbar.html ซึ่งเป็น HTML สำหรับแถบการนำทางด้านบน ซึ่งเป็นส่วนประกอบที่จะรวมไว้เมื่อจำเป็น
  • footer.html รหัสสำหรับส่วนท้ายของหน้า องค์ประกอบอื่นที่จะรวมไว้เมื่อจำเป็น
  • sidebar.html , HTML สำหรับแถบด้านข้าง, องค์ประกอบที่สามที่จะรวมไว้เมื่อจำเป็น
  • index.html รหัสเฉพาะของหน้าหลัก เทมเพลตนี้ขยายเทมเพลตฐานและรวมส่วนประกอบทั้งสาม

Django รวบรวมห้าไฟล์เหล่านี้เช่น Voltron เพื่อแสดงหน้าดัชนี คำหลักที่อนุญาตคือ {% block %} , {% include %} และ {% extend %} ใน base.html :

 {% block content %} {% endblock %}

สองบรรทัดนี้เว้นที่ว่างสำหรับเทมเพลตอื่นๆ ที่ขยาย base.html เพื่อแทรก HTML ของตัวเอง โปรดทราบว่า content เป็นชื่อตัวแปร คุณสามารถมีหลายบล็อกที่มีชื่อต่างกันในเทมเพลต ซึ่งทำให้เทมเพลตย่อยมีความยืดหยุ่น เราเห็นวิธีขยายสิ่งนี้ใน index.html :

 {% extends "base.html" %} {% block content %} <!-- HTML Goes Here --> {% endblock %}

การใช้คำสำคัญที่ extends ด้วยชื่อแม่แบบพื้นฐานทำให้หน้าดัชนีมีโครงสร้าง ทำให้เราไม่ต้องคัดลอกในส่วนหัว (โปรดทราบว่าชื่อไฟล์เป็นพาธสัมพัทธ์ในรูปแบบสตริงที่มีเครื่องหมายอัญประกาศคู่) หน้าดัชนีประกอบด้วยองค์ประกอบทั้งสามที่เหมือนกันกับหน้าส่วนใหญ่บนไซต์ เรานำส่วนประกอบเหล่านั้นมาด้วยแท็ก include ดังต่อไปนี้:

 {% extends "base.html" %} {% block content %} {% include "navbar.html" %} {% include "sidebar.html" %} <!--Index-Specific HTML--> {% include "footer.html" %} <!--More Index-Specific HTML--> {% endblock %}

โดยรวม โครงสร้างนี้มีประโยชน์หลักสามประการในการเขียนหน้าทีละหน้า:

  • รหัส DRY (อย่าทำซ้ำตัวเอง)
    โดยการแยกรหัสทั่วไปออกเป็นไฟล์เฉพาะ เราสามารถเปลี่ยนรหัสได้ในที่เดียวและสะท้อนการเปลี่ยนแปลงเหล่านั้นในทุกหน้า
  • เพิ่มความสามารถในการอ่าน
    แทนที่จะต้องเลื่อนดูไฟล์ขนาดยักษ์ คุณสามารถแยกส่วนประกอบเฉพาะที่คุณสนใจได้
  • แยกความกังวล
    รหัสสำหรับแถบด้านข้าง ต้อง อยู่ในที่เดียว ไม่มีแท็ก script อันธพาลใด ๆ ที่ลอยอยู่ที่ด้านล่างของโค้ดหรือส่วนอื่น ๆ ระหว่างสิ่งที่ควรเป็นส่วนประกอบที่แยกจากกัน การแยกตัวประกอบแต่ละส่วนเป็นแรงผลักดันให้แนวปฏิบัติในการเข้ารหัสที่ดีนี้

แม้ว่าเราจะสามารถบันทึกโค้ดได้หลายบรรทัดโดยใส่ส่วนประกอบเฉพาะในเทมเพลต base.html การแยกองค์ประกอบเหล่านี้มีข้อดีสองประการ อย่างแรกคือเราสามารถฝังพวกมันตรงที่พวกมันอยู่ในบล็อกเดียว (สิ่งนี้เกี่ยวข้องเฉพาะกับ footer.html ซึ่งเข้าไปภายใน div หลักของบล็อก content ) ข้อดีอีกประการหนึ่งคือ หากเราต้องสร้างเพจ เช่น หน้าแสดงข้อผิดพลาด 404 และเราไม่ต้องการแถบด้านข้างหรือส่วนท้าย เราอาจปล่อยหน้าเหล่านั้นออกไป

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

แท็กพื้นฐานสองแท็ก

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

ก่อนที่เราจะไปที่แท็ก ฉันต้องการจดบันทึกเกี่ยวกับไวยากรณ์ แท็ก {% foo %} หมายความว่า "foo" เป็นฟังก์ชันหรือความสามารถอื่นๆ ของระบบเทมเพลต ขณะที่แท็ก {{ bar }} หมายความว่า "แถบ" เป็นตัวแปรที่ส่งผ่านไปยังเทมเพลตเฉพาะ

สำหรับลูป

ใน index.html ที่เหลือ ส่วนที่ใหญ่ที่สุดของโค้ดหลายร้อยบรรทัดคือตาราง แทนที่จะใช้ตารางฮาร์ดโค้ดนี้ เราสามารถสร้างตารางแบบไดนามิกจากฐานข้อมูลได้ เรียกคืน python manage.py loaddata employee_fixture.json จากขั้นตอนการตั้งค่า คำสั่งนั้นใช้ไฟล์ JSON ที่เรียกว่า Django Fixture เพื่อโหลดบันทึกพนักงานทั้งหมด 57 รายการลงในฐานข้อมูลของแอปพลิเคชัน เราใช้มุมมองใน views.py เพื่อส่งข้อมูลนี้ไปยังเทมเพลต:

 from django.shortcuts import render from .models import Employee def index(request): return render(request, "index.html", {"employees": Employee.objects.all()})

อาร์กิวเมนต์ตำแหน่งที่สามเพื่อ render เป็นพจนานุกรมของข้อมูลที่มีให้ในเทมเพลต เราใช้ข้อมูลนี้และ for tag เพื่อสร้างตาราง แม้แต่ในเทมเพลตดั้งเดิมที่ฉันดัดแปลงจากหน้าเว็บนี้ ตารางของพนักงานก็ยังถูกฮาร์ดโค้ดไว้ วิธีการใหม่ของเราจะตัดแถวตารางที่มีการฮาร์ดโค้ดซ้ำๆ กันหลายร้อยบรรทัด index.html ตอนนี้ประกอบด้วย:

 {% for employee in employees %} <trv <td>{{ employee.name }}</td> <td>{{ employee.position }}</td> <td>{{ employee.office }}</td> <td>{{ employee.age }}</td> vtd>{{ employee.start_date }}</td> <td>${{ employee.salary }}</td> </tr> {% endfor %}

ข้อได้เปรียบที่ใหญ่กว่าคือทำให้กระบวนการอัปเดตตารางง่ายขึ้นอย่างมาก แทนที่จะให้นักพัฒนาแก้ไข HTML ด้วยตนเองเพื่อให้สอดคล้องกับการเพิ่มเงินเดือนหรือการจ้างใหม่ จากนั้นจึงผลักดันการเปลี่ยนแปลงนั้นไปสู่การผลิต ผู้ดูแลระบบคนใดก็ได้สามารถใช้แผงผู้ดูแลระบบเพื่อทำการอัปเดตตามเวลาจริงได้ (https://127.0.0.1/admin ใช้ ข้อมูลประจำตัวที่คุณสร้างด้วย python manage.py createsuperuser เพื่อเข้าถึง) นี่คือข้อดีของการใช้ Django กับเอ็นจิ้นการเรนเดอร์นี้ แทนที่จะใช้มันในตัวสร้างไซต์แบบสแตติกหรือวิธีการสร้างเทมเพลตอื่นๆ

ถ้าอย่างอื่น

แท็ก if เป็นแท็กที่ทรงพลังอย่างเหลือเชื่อที่ให้คุณประเมินนิพจน์ภายในเทมเพลตและปรับ HTML ให้เหมาะสม บรรทัดเช่น {% if 1 == 2 %} นั้นใช้ได้จริง หากไม่มีประโยชน์เพียงเล็กน้อย เนื่องจากจะประเมินผลเป็นผลลัพธ์เดียวกันทุกครั้ง โดยที่แท็ก if ส่องแสงคือเมื่อมีการโต้ตอบกับข้อมูลที่ส่งผ่านไปยังเทมเพลตโดยมุมมอง ลองพิจารณาตัวอย่างต่อไปนี้จาก sidebar.html :

 <div class="sb-sidenav-footer"> <div class="small"> Logged in as: </div> {% if user.is_authenticated %} {{ user.username }} {% else %} Start Bootstrap {% endif %} </div>

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

คุณอาจกังวลว่าการเข้าถึงระดับนี้อาจก่อให้เกิดความเสี่ยงด้านความปลอดภัย อย่างไรก็ตาม โปรดจำไว้ว่าเทมเพลตเหล่านี้มีไว้สำหรับเฟรมเวิร์กการแสดงผลฝั่งเซิร์ฟเวอร์ หลังจากสร้างหน้าแล้ว แท็กได้ใช้งานตัวเองและแทนที่ด้วย HTML ล้วนๆ ดังนั้น หากคำสั่ง if นำเสนอข้อมูลไปยังเพจภายใต้เงื่อนไขบางประการ แต่ข้อมูลนั้นไม่ได้ใช้ในอินสแตนซ์ที่กำหนด ข้อมูลนั้นจะไม่ถูกส่งไปยังไคลเอนต์เลย เนื่องจากคำสั่ง if นั้นได้รับการประเมินทางฝั่งเซิร์ฟเวอร์ ซึ่งหมายความว่าเทมเพลตที่สร้างขึ้นอย่างถูกต้องเป็นวิธีการที่ปลอดภัยมากในการเพิ่มข้อมูลที่ละเอียดอ่อนลงในเพจโดยที่ข้อมูลนั้นไม่ออกจากเซิร์ฟเวอร์เว้นแต่จำเป็น ที่กล่าวว่าการใช้ Django templating ไม่ได้ขจัดความจำเป็นในการสื่อสารข้อมูลที่ละเอียดอ่อนในลักษณะที่ปลอดภัยและเข้ารหัส แต่เพียงหมายความว่าการตรวจสอบความปลอดภัยเช่น user.is_authenticated สามารถเกิดขึ้นได้อย่างปลอดภัยใน HTML เนื่องจากได้รับการประมวลผลทางฝั่งเซิร์ฟเวอร์

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

การกรอง

งานส่วนหนึ่งของมุมมองคือการจัดรูปแบบข้อมูลให้เหมาะสมกับเพจ เพื่อให้บรรลุสิ่งนี้ เรามีส่วนขยายที่มีประสิทธิภาพสำหรับแท็ก: ตัวกรอง มีตัวกรองมากมายใน Django เพื่อดำเนินการต่างๆ เช่น การจัดข้อความ จัดรูปแบบวันที่ และการเพิ่มตัวเลข โดยพื้นฐานแล้ว คุณสามารถคิดว่าตัวกรองเป็นฟังก์ชันที่ใช้กับตัวแปรในแท็ก ตัวอย่างเช่น เราต้องการให้ตัวเลขเงินเดือนของเราอ่านว่า “$1,200,000” แทนที่จะเป็น “1200000” เราจะใช้ตัวกรองเพื่อทำงานให้เสร็จใน index.html :

 <td>${{ employee.salary|intcomma }}</td>

อักขระท่อ | เป็นตัวกรองที่ใช้คำสั่ง intcomma กับตัวแปร employee.salary อักขระ “$” ไม่ได้มาจากเทมเพลต สำหรับองค์ประกอบที่ปรากฏขึ้นทุกครั้ง ง่ายกว่าที่จะแปะไว้นอกแท็ก

โปรดทราบว่า intcomma กำหนดให้เราต้องรวม {% load humanize %} ที่ด้านบนสุดของ index.html และ 'django.contrib.humanize', ใน INSTALLED_APPS ใน settings.py สิ่งนี้ทำเพื่อคุณในแอปพลิเคชันตัวอย่างที่ให้มา

บทสรุป

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

หากคุณยังไม่ได้ดำเนินการ ให้ลองดูแอปพลิเคชันตัวอย่างและลองเพิ่มแท็กและตัวกรองของคุณเองโดยใช้รายการทั้งหมด

Django Highlights เป็นซีรีส์ที่นำเสนอแนวคิดที่สำคัญของการพัฒนาเว็บใน Django แต่ละบทความเขียนขึ้นเพื่อเป็นแนวทางแบบสแตนด์อโลนในด้านการพัฒนา Django เพื่อช่วยให้นักพัฒนาส่วนหน้าและนักออกแบบเข้าใจลึกซึ้งยิ่งขึ้นเกี่ยวกับ "อีกครึ่งหนึ่ง" ของฐานโค้ด บทความเหล่านี้ส่วนใหญ่สร้างขึ้นเพื่อช่วยให้คุณเข้าใจทฤษฎีและแบบแผน แต่มีตัวอย่างโค้ดบางส่วนซึ่งเขียนใน Django 3.0

ส่วนก่อนหน้า ในซีรีส์:

  • จุดเด่นของ Django: โมเดลผู้ใช้และการตรวจสอบสิทธิ์ (ตอนที่ 1)
  • จุดเด่นของ Django: โมเดล ผู้ดูแลระบบ และการควบคุมฐานข้อมูลเชิงสัมพันธ์ (ตอนที่ 3)
  • ไฮไลท์ของ Django: การโต้เถียงเรื่องทรัพย์สินทางปัญญาและไฟล์สื่อ (ตอนที่ 4)