แนวคิดของการสร้างเนื้อหาแบบไดนามิกบนทรัพยากรบนเว็บได้กลายเป็นบรรทัดฐาน หน้าคงที่และการสร้างไซต์แม่แบบได้เสร็จสิ้นภารกิจของพวกเขาในที่สุด
อย่างไรก็ตามทรัพยากรบนเว็บที่ทันสมัยไม่จำเป็นต้องเป็นชุดของเพจที่สร้างโดยเซิร์ฟเวอร์และอัปเดตโดยเบราว์เซอร์ (JS + AJAX)
แหล่งข้อมูลบนเว็บในขณะที่ผู้เยี่ยมชมมาถึงอาจเป็นส่วนหัวสองสามส่วนสำหรับโปรโตคอลข้อความบางส่วนใน "head" โค้ดสองสามบรรทัดใน "body" ก็แค่นั้นแหละ ส่วนที่เหลือ "คิดถึง»ในระหว่างการทำงานของผู้เยี่ยมชม - นี่คือไซต์ในอุดมคติหรือต้องการที่จะเป็นหนึ่งในนั้น
JavaScript คือ ประสบการณ์ที่ได้รับมาหลายสิบปีมีประวัติการพัฒนาที่สำคัญทีมผู้สร้างและนักพัฒนาที่มีคุณสมบัติทันสมัย ภาษาได้รับการพิจารณาอย่างดีเชื่อถือได้สวยงามและเป็นโอกาสที่แท้จริงสำหรับนักพัฒนาในการเขียนโค้ดที่เหมาะสมและปรับปรุงตัวเอง
ไม่มีแนวคิดของอัลกอริทึมนอกฟังก์ชันที่นี่หลักการ. แน่นอนว่านักพัฒนาสามารถแทรกสคริปต์ที่ใดก็ได้บนหน้าวางโค้ดลงไปและมันจะถูกเรียกใช้งาน แต่อะไรคือจุดในรหัสที่ถูกเรียกใช้เพียงครั้งเดียว: เมื่อโหลด (โอเวอร์โหลด) เพจ? เว้นแต่คุณจะกำหนดค่าเริ่มต้นของตัวแปรที่ไม่มีนัยสำคัญได้
สคริปต์คือตำแหน่งที่อธิบายตัวแปรที่ต้องการและฟังก์ชั่นแทนที่จะเป็นโค้ดที่ดีที่เขียนขึ้นเพื่อประโยชน์ของตัวมันเอง เป็นชุดของฟังก์ชันที่จำเป็นและมีความสำคัญบางที - การเชื่อมต่อโดยตรงซึ่งกันและกัน แต่บ่อยครั้งที่ทุกอย่างแตกต่างกัน ตำแหน่งของคำอธิบายของฟังก์ชันและตำแหน่งของแอปพลิเคชันไม่เหมือนกันเลย
ไม่จำเป็นเลยที่ฟังก์ชันจะเป็นเรียกใช้ฟังก์ชันอื่นโดยตรงซึ่งสามารถทำได้ทางอ้อมผ่านการสร้างรหัสแบบไดนามิก ผู้เยี่ยมชมทำการตัดสินใจภายในกรอบของรหัสนี้และระบบฟังก์ชันที่แตกต่างกันโดยสิ้นเชิงจะถูกเรียกใช้
พลวัตการทำงานไม่เพียง แต่เกี่ยวกับตัวจัดการที่กำหนดให้กับองค์ประกอบของเพจมีไม่มากนักซึ่งเป็นฟังก์ชันที่สร้างองค์ประกอบของหน้าและตัวจัดการทันทียังสามารถเปลี่ยนแปลงได้
การดำเนินการบนเพจจะเกิดขึ้นโดยขึ้นอยู่กับองค์ประกอบและพฤติกรรมของผู้เข้าชม การเคลื่อนไหวของเมาส์ปุ่มแป้นพิมพ์การคลิกเหตุการณ์ขององค์ประกอบและสถานการณ์อื่น ๆ นำไปสู่การเปิดฟังก์ชันที่ต้องการ
เริ่มแรกไม่มีลำดับและไม่มีความเท่าเทียมกัน มีการตอบสนองของทรัพยากรบนเว็บอย่างเพียงพอต่อเหตุการณ์ JavaScript จะเรียกใช้ฟังก์ชันเฉพาะได้เร็วเพียงใดขึ้นอยู่กับปัจจัยทางเทคนิค (คอมพิวเตอร์สายสื่อสาร) และความหมาย (ตรรกะของอัลกอริทึมหัวข้อเรื่องความหมายของปัญหา) หลายประการ
ในความเป็นจริงอาจเป็นที่ถกเถียงกันอยู่ว่าบางสิ่งได้ผลควบคู่กันไปและบางสิ่งบางอย่างจะได้รับการเติมเต็มหลังจากบางสิ่งบางอย่าง แต่ไม่มีความหมายเฉพาะในเรื่องนี้ สิ่งสำคัญคือฟังก์ชัน JavaScript คือความสามารถในการสร้างการตอบสนองที่เพียงพอต่อการกระทำของผู้เยี่ยมชม
นี่คือแนวคิดใหม่ในการพัฒนา: การประมวลผลข้อมูลแบบกระจายในลำไส้ของเบราว์เซอร์เดียว!
ตัวแปร JavaScript ถูกวางไว้ในแท็ก"สคริปต์" และในเนื้อหาของฟังก์ชัน มีการกำหนดฟังก์ชันในลักษณะเดียวกัน ไม่มีประเด็นเฉพาะในการเขียนฟังก์ชันอื่นภายในฟังก์ชัน แต่อาจจำเป็นด้วยเหตุผลหลายประการและเป็นที่ยอมรับ
โดยทั่วไปคำอธิบายฟังก์ชันจะขึ้นต้นด้วยคีย์เวิร์ด "function" ตามด้วยชื่อรายการอาร์กิวเมนต์ในวงเล็บที่คั่นด้วยเครื่องหมายจุลภาคและเนื้อหาของฟังก์ชันในวงเล็บปีกกา
ตัวอย่างนี้อธิบายถึงสองฟังก์ชันที่จัดเตรียมการสื่อสาร AJAX ระหว่างเพจและเซิร์ฟเวอร์ ตัวแปร scXHR ได้อธิบายไว้ข้างต้นดังนั้นจึงมีให้ใช้งานทั้งใน InitXML และภายใน WaitReplySC
ตัวเลือกอะซิงโครนัสถูกนำเสนอที่นี่เมื่อฟังก์ชัน JavaScript ในฟังก์ชันถูกเรียกใช้หลังจากเซิร์ฟเวอร์ตอบสนอง ในขณะเดียวกันเมื่อได้รับการตอบกลับจากเซิร์ฟเวอร์ WaitReplySC จะอ้างถึงแท็กของเพจกรอกข้อมูลที่ได้รับและเรียกใช้ฟังก์ชันอื่น ๆ ที่อาจเริ่มต้นคำขอถัดไปไปยังเซิร์ฟเวอร์ได้
สิ่งสำคัญที่ควรทราบคือ WaitReplySC เป็นฟังก์ชัน แต่อยู่ในสาย scXHR.onreadystatechange = WaitReplySC มันถูกส่งผ่านเป็นพารามิเตอร์นี่เป็นกฎทั่วไปสำหรับการส่งผ่านฟังก์ชันไปยังฟังก์ชันอื่น ๆ เป็นพารามิเตอร์ วงเล็บที่ระบุและส่งผ่านพารามิเตอร์ไปยังพวกเขา - ฟังก์ชันจะดำเนินการทันที เขาให้ แต่ชื่อแล้วไง? การเรียกใช้ฟังก์ชันจะดำเนินการโดยผู้ที่ได้รับชื่อ
ฟังก์ชั่น AJAX ช่วยให้คุณทำ เรียกใช้ฟังก์ชัน JavaScript ผ่านข้อมูลที่ได้รับจากเซิร์ฟเวอร์ ในความเป็นจริงเมื่อส่งคำขอไปยังเซิร์ฟเวอร์สิ่งนี้หรือฟังก์ชั่นนั้นอาจไม่ "รู้" เลยว่ามันอ้างถึงฟังก์ชันใดและมีข้อมูลอะไรบ้าง
ตัวดำเนินการใด ๆ สามารถเขียนได้ในเนื้อความของฟังก์ชันภาษาซึ่งในความเป็นจริงมีไว้สำหรับสิ่งนี้ ภายในฟังก์ชันจะมีตัวแปรที่อธิบายไว้ภายในและภายนอก แต่ไม่ใช่ตัวแปรที่อธิบายไว้ในฟังก์ชันอื่น ๆ
หากคุณต้องการให้ฟังก์ชันกลับมาผลลัพธ์คุณสามารถใช้ตัวดำเนินการส่งคืนของ JavaScript: return ในเนื้อความของฟังก์ชันอาจมีจำนวนเพียงพอ ไม่จำเป็นเลยที่พวกเขาทั้งหมดจะส่งคืนผลลัพธ์ประเภทเดียวกัน
โดยปกติแล้วนักพัฒนาจะให้ความเคารพต่อคุณลักษณะนี้เป็นอย่างมากและตัดสินใจออกจากฟังก์ชันโดยเร็วที่สุดทั้งนี้ขึ้นอยู่กับสถานการณ์
ไม่จำเป็นเลยที่จะต้องเรียกใช้อัลกอริทึมทั้งหมดของฟังก์ชันเมื่อคุณสามารถออกก่อนเวลาได้
อาร์กิวเมนต์จะถูกส่งผ่านไปยังฟังก์ชันเป็นรายการผ่านลูกน้ำอยู่ในวงเล็บและปรากฏหลังชื่อทันที ชื่อตัวแปรถูกใช้เป็นอาร์กิวเมนต์ แต่ยังสามารถส่งผ่านค่าได้โดยตรง ในการส่งผ่านฟังก์ชันไปยังฟังก์ชันใน JavaScript คุณเพียงแค่ระบุชื่อโดยไม่มีวงเล็บ
ตัวแปรอาร์กิวเมนต์มีอยู่ในฟังก์ชัน มีทรัพย์สิน ความยาว. คุณสามารถอ้างถึงอาร์กิวเมนต์ของฟังก์ชันผ่านอาร์กิวเมนต์ [0], อาร์กิวเมนต์ [1], ... จนถึงอาร์กิวเมนต์สุดท้าย [arguments.length-1]
การเปลี่ยนแปลงอาร์กิวเมนต์ของฟังก์ชันอยู่ภายในจริงๆฟังก์ชั่น แต่ไม่ใช่ด้านนอก ในการเปลี่ยนแปลงบางสิ่งภายนอกฟังก์ชันคุณต้องใช้ตัวดำเนินการส่งคืน JavaScript ซึ่งคุณจะส่งค่าที่ต้องการออกไปด้านนอก
หลังจากฟังก์ชั่นเสร็จสิ้นทุกอย่างนั้นเกี่ยวข้องกับการดำเนินการจะถูกทำลาย ในระหว่างการดำเนินการฟังก์ชันสามารถเปลี่ยนตัวแปรภายนอกได้ยกเว้นตัวแปรที่อธิบายไว้ในฟังก์ชันอื่น ๆ รวมถึงตัวแปรภายใน
อาร์กิวเมนต์มีคุณสมบัติ callee ที่มีไว้เพื่อเรียกใช้ฟังก์ชันที่กำลังดำเนินการในช่วงเวลาที่กำหนด หากคุณเรียกตัวเองตัวแปร JavaScript ของฟังก์ชันในฟังก์ชันจะช่วยให้คุณใช้การเรียกซ้ำได้
ข้อกังวลหลักของฟังก์ชั่นคือการให้บริการเหตุการณ์เบราว์เซอร์ ในการทำเช่นนี้เกือบทุกแท็กจะมีความสามารถในการระบุชื่อของเหตุการณ์และฟังก์ชันที่จัดการ สามารถระบุได้หลายเหตุการณ์ แต่จะระบุเพียงหนึ่งฟังก์ชันต่อเหตุการณ์
ฟังก์ชันเดียวสามารถให้บริการหลายองค์ประกอบของหน้าและหลายเหตุการณ์ เมื่อใช้พารามิเตอร์ "this" คุณสามารถส่งข้อมูลไปยังฟังก์ชันที่เรียกใช้
การใช้ฟังก์ชัน JS แบบคลาสสิกคือ -ตัวจัดการเหตุการณ์เกี่ยวกับองค์ประกอบ ในตัวอย่างนี้ฟังก์ชัน scfWecomeGo () หรือ scfWelcomeCancel () จะถูกเรียกในแบบฟอร์มการเข้าสู่ระบบ / ออกจากระบบของผู้เยี่ยมชมและเมื่อเลือกโหมดแล้ว scfMenuItemClick (สิ่งนี้)
ในกรณีหลังนี้พารามิเตอร์ "this" จะถูกส่งผ่านซึ่งช่วยให้คุณค้นพบได้อย่างน่าอัศจรรย์ว่าการโทรมาจากแหล่งใด โดยทั่วไป JavaScript ถูกฝังไว้ใน DOM เป็นอย่างดีและช่วยให้คุณสามารถนำทางผ่านองค์ประกอบต่างๆได้อย่างสะดวกเพื่อรวบรวมข้อมูลที่จำเป็นซึ่งพลวัตของหน้าเว็บนั้นไม่สามารถคาดเดาได้
ฟังก์ชันไม่จำเป็นต้องส่งคืนสตริงอักขระตัวเลขหรือฟังก์ชันอื่น ๆ สามารถส่งคืนองค์ประกอบ HTML แบบเต็มซึ่งจะมีองค์ประกอบตามจำนวนที่ต้องการพร้อมตัวจัดการเหตุการณ์ของตัวเอง
ด้วยการวางองค์ประกอบดังกล่าวในหน้าเว็บนักพัฒนาจะสร้างฟังก์ชันการทำงานใหม่ซึ่งเป็นผลดีในแง่ของการแก้ปัญหาและตอบสนองความสนใจของผู้เยี่ยมชม แต่ค่อนข้างยากในแง่ของการนำไปใช้งาน
ด้วยการเริ่มต้นการพัฒนาที่ใช้งานได้อย่างสมบูรณ์เป็นเรื่องง่ายที่จะสับสนในโค้ดของคุณเองในการเรียกใช้ฟังก์ชันในช่วงเวลาที่มีการสร้างเนื้อหานี้หรือส่วนนั้นของหน้านี้ ก่อนที่จะใช้แนวทางการพัฒนานี้ไม่ต้องเจ็บใจที่จะชั่งน้ำหนักทุกอย่างให้ดี
นักพัฒนาต้องคิดที่ระดับขององค์ประกอบทั้งหมดของหน้าในระดับของเหตุการณ์ทั้งหมดและมีความคิดที่ชัดเจนว่าทุกอย่างเกิดขึ้นจริงได้อย่างไร ถึงจะยาก แต่งานก็คุ้มค่า
ใน JavaScript การเรียกใช้ฟังก์ชันสามารถเป็นได้เลื่อนออกไปจนกว่าจะมีเหตุการณ์บางอย่างและอาจมีฟังก์ชั่นดังกล่าวมากมายและเหตุการณ์มักจะแพร่กระจายและตกอยู่ใน "ขอบเขต" ของตัวจัดการต่างๆ
ในตัวอย่างนี้ก่อนหน้านี้ฟังก์ชันที่ทริกเกอร์การสร้างรายการเมนูการนำทางไฟล์ ระบบจะถือว่าการจัดระเบียบเพจกล่าวคือมีไฟล์เพียงเจ็ดไฟล์ในหน้าต่างเท่านั้นที่สามารถลบและประมวลผลได้ คุณสามารถนำทางได้โดยคลิกที่บรรทัดในไฟล์หรือโดยลูกศรบนแป้นพิมพ์หรือในบล็อกเจ็ดบรรทัด
แต่ละกรณีมีหน้าที่ของตัวเองกล่าวอีกนัยหนึ่งในตัวอย่างง่ายๆเช่นคุณต้องเขียนฟังก์ชันสองสามโหลที่จะตอบสนองต่อเหตุการณ์ต่างๆและฟังก์ชันเหล่านี้บางฟังก์ชันจะจัดการกับตัวเลือกและสถานการณ์ต่างๆที่ไม่ใช่เหตุการณ์เลย
ตัวอย่างเช่นเมื่อลบบรรทัดบรรทัดล่างสุดควรขยับขึ้น. ในการดำเนินการนี้คุณจะต้องทำการเลือกใหม่ซึ่งเป็นเรื่องเล็กน้อยและใช้ทรัพยากรมากหรือเพื่อคำนวณบรรทัดใหม่ใช้ฟังก์ชันอาร์เรย์ในจาวาสคริปต์และบรรลุเป้าหมายอย่างสวยงาม
JavaScript ช่วยให้คุณสามารถแปลงรหัสของคุณเป็นไฟล์สถานะ "ทำงานได้อย่างสมบูรณ์" เป็นเรื่องปกติเมื่ออาร์กิวเมนต์ของฟังก์ชันเป็นฟังก์ชัน อนุญาตให้ใช้ตัวแปรเมื่อฟังก์ชันส่งคืนฟังก์ชัน JavaScript ใช้เวลานี้ค่อนข้างสงบ
นี่เป็นกลไกที่ดี แต่ค่อนข้างซับซ้อนในการนำไปใช้ ในทางเทคนิคแล้วทุกอย่างเป็นไปตามความหมายมีเพียงนักพัฒนาที่ผ่านการรับรองเท่านั้นที่สามารถให้เหตุผลในการถ่ายโอน
เมื่ออยู่ใน JavaScript ฟังก์ชันภายในฟังก์ชัน - ทุกที่ที่คุณไปดำเนินต่อไป แต่เมื่อฟังก์ชันสร้างฟังก์ชันขึ้นมาและอีกฟังก์ชันหนึ่งมันค่อนข้างยากที่จะติดตามตรรกะ ในความเป็นจริงคำถามไม่ได้เกี่ยวกับการใช้คุณสมบัติ แต่เกี่ยวกับการได้ผลลัพธ์ที่ปลอดภัยและถูกต้อง
ข้อกังวลของนักพัฒนานั้นชัดเจนและเรียบง่าย มีปัญหาคุณต้องมีวิธีแก้ไขไม่ใช่ข้อผิดพลาดเช่น "ข้อผิดพลาด JavaScript การดำเนินการไม่ปลอดภัย" หน้าจอว่างเปล่าหรือการหยุดกลไกเบราว์เซอร์ทั้งหมด
ถ้าอาร์กิวเมนต์เป็นฟังก์ชันดังนั้นนักพัฒนาส่งผ่านตัวแปรที่มีคุณสมบัติพิเศษนั่นคือไม่ใช่ตัวเลขไม่ใช่สตริงไม่ใช่วัตถุ แต่การใช้อาร์กิวเมนต์ดังกล่าวสามารถนำไปสู่ความจริงที่ว่าตัวแปรภายนอกจะเปลี่ยนไปและผลลัพธ์ของการเรียกใช้ฟังก์ชันจะเป็น ขึ้นอยู่กับสิ่งที่ถ่ายโอนจะมีการเปลี่ยนแปลงอย่างเพียงพอ
ใช้การดำเนินการของรหัสที่สร้างขึ้นในในขณะที่โค้ดอื่นกำลังทำงานคุณสามารถใช้ "eval" นี่ไม่ใช่วิธีแก้ปัญหาที่ยอดเยี่ยม แต่บ่อยครั้งที่คุณไม่สามารถทำให้โค้ดซับซ้อนขึ้นด้วยฟังก์ชันที่ไม่จำเป็นได้ แต่ จำกัด ตัวเองให้สร้างโค้ด JavaScript ซ้ำ ๆ กันและเพียงแค่ดำเนินการ
ในตัวอย่างนี้เส้นแทรกจะเกิดขึ้นในทำหน้าที่แบ่งข้อมูลบางส่วน หมายเลข div และเนื้อหาข้อมูลแตกต่างกันสำหรับตำแหน่งที่แตกต่างกันดังนั้นวิธีแก้ปัญหาในสถานการณ์นี้จึงรับประกันได้ว่าจะไม่ให้สถานการณ์ "ข้อผิดพลาดของจาวาสคริปต์การดำเนินการไม่ปลอดภัย" แต่จะให้ผลตามที่ต้องการได้อย่างน่าเชื่อถือ
หากมีโอกาสที่จะทำโดยไม่ต้องจีบจะดีกว่าที่จะใช้มัน ตัวเลือกทั้งหมดข้างต้นเป็นสิ่งที่ดี แน่นอนว่าในหลาย ๆ กรณีนี่เป็นทางออกเดียว
ตัวอย่างคลาสสิกของการเรียกซ้ำ: การคำนวณแฟกทอเรียล มันค่อนข้างยากที่จะเขียนอัลกอริทึมที่จะวนซ้ำ แต่มันง่ายมากที่จะก้าวข้ามขีด จำกัด ของค่า แฟกทอเรียลเติบโตเร็วเกินไป
อย่างไรก็ตามทั้งการเรียกซ้ำและฟังก์ชันที่เรียกใช้ฟังก์ชันอื่นที่สามารถทำการโทรกลับที่ถูกต้องถือเป็นบรรทัดฐาน
ตัวอย่างเช่นตารางปกติ อาจจะมีโต๊ะอื่นอยู่ การทำรังไม่สามารถ จำกัด ได้ การเขียนชุดฟังก์ชันแยกต่างหากสำหรับแต่ละตารางเป็นเรื่องหรูหรามากเกินไป
มีตัวอย่างมากมายและทั้งหมดสิ่งเหล่านี้จะเป็นงานจริงและเร่งด่วนไม่ใช่จากสาขาการเขียนโปรแกรมเลย นั่นคือเหตุผลที่ปัญหาอยู่ในความจริงที่ว่ามันเป็นไปไม่ได้ที่จะทำโดยไม่ต้องใช้มากเกินไประบบการทำงานที่สร้างขึ้นหรือการดีบักและการดำเนินการที่เชื่อถือได้ในภายหลังกลายเป็นปัญหาที่ไม่ใช่ของ JavaScript แต่เป็นของนักพัฒนา
