ในแต่ละภาษาการเขียนโปรแกรมตัวแปรมีช่วงที่ถูกต้อง หลังจากเกินช่วงนี้ตัวแปรจะไม่ถูกต้อง นี่คือขอบเขตของตัวแปร จากมุมมองทางคณิตศาสตร์มันเป็นโดเมนของตัวแปรอิสระ
ขอบเขตคือช่วงของตัวแปรที่เข้าถึงได้นั่นคือขอบเขตควบคุมการมองเห็นและวงจรชีวิตของตัวแปรและฟังก์ชั่น ในจาวาสคริปต์วัตถุและฟังก์ชั่นยังเป็นตัวแปรและตัวแปรถูกกำหนดไว้ในร่างกายฟังก์ชั่นโดยพลการซ้อนกันโดยการประกาศฟังก์ชั่นของพวกเขาและร่างกายฟังก์ชั่นโดยพลการซ้อนกัน
1. ขอบเขตคงที่และขอบเขตแบบไดนามิก
ขอบเขตคงที่
หมายความว่าขอบเขตของการประกาศจะถูกกำหนดในเวลาคอมไพล์ตามร่างกายของโปรแกรมหรือที่เรียกว่าขอบเขตคำศัพท์ ภาษาการเขียนโปรแกรมที่ทันสมัยส่วนใหญ่ใช้กฎขอบเขตคงที่และ JavaScript ใช้ขอบเขตนี้
ในภาษาที่ใช้ขอบเขตคงที่กฎขอบเขตซ้อนด้านในสุดนั้นเป็นพื้นฐาน: ตัวระบุที่แนะนำโดยการประกาศจะปรากฏในขอบเขตที่การประกาศตั้งอยู่และในแต่ละขอบเขตที่ซ้อนอยู่ภายในเว้นแต่จะครอบคลุมโดยการประกาศชื่อเดียวกัน
เพื่อค้นหาวัตถุที่อ้างอิงโดยตัวระบุที่กำหนดควรพบในขอบเขตด้านในสุดปัจจุบัน หากพบการประกาศวัตถุที่อ้างอิงโดยตัวระบุสามารถพบได้ มิฉะนั้นเราจะค้นหาในขอบเขตภายนอกโดยตรงและตรวจสอบขอบเขตด้านนอกเพื่อไปด้านนอกจนกว่าเราจะไปถึงระดับการทำรังนอกสุดของโปรแกรมนั่นคือขอบเขตที่การประกาศวัตถุทั่วโลกตั้งอยู่ หากไม่พบการประกาศในทุกระดับโปรแกรมจะมีข้อผิดพลาด ดังนี้:
ฟังก์ชั่น cha () {var name = "xiao;" ฟังก์ชั่น chb () {ฟังก์ชั่น chc () {console.log (ชื่อ); -ก่อนอื่นฟังก์ชั่นค้นหาคำจำกัดความของชื่อจาก CHB () จากนั้นยังคงค้นหาเลเยอร์โดยเลเยอร์ ในที่สุดคำจำกัดความของชื่อจะพบใน Cha () หากไม่พบจะมีการรายงานข้อผิดพลาด
2. ขอบเขตแบบไดนามิก
ในภาษาที่มีขอบเขตแบบไดนามิกวัตถุที่อ้างอิงโดยตัวแปรในโปรแกรมจะถูกกำหนดตามข้อมูลการไหลของโปรแกรมควบคุมของโปรแกรมในขณะที่โปรแกรมทำงาน
2. ขอบเขตของ JavaScript
มีสองขอบเขตใน JavaScript คือขอบเขตทั่วโลกและขอบเขตท้องถิ่น
1. ขอบเขตทั่วโลก
มีคำจำกัดความที่ใดก็ได้ในรหัส แม้ว่าตัวแปรส่วนกลางจะถูกกำหนดไว้ในรหัสของรหัส JS ที่ซ้อนกันในหน้า HTML ตัวแปรยังสามารถเข้าถึงได้ในไฟล์ JS ที่อ้างอิง สิ่งนี้มีแนวโน้มที่จะทำให้เกิดมลพิษต่อตัวแปรทั่วโลก
ตัวแปรในสามกรณีต่อไปนี้จะได้รับการพิจารณาตัวแปรทั่วโลก
(1) ฟังก์ชั่นนอกสุดและตัวแปรด้านนอกสุดมีขอบเขตทั่วโลก
(2) ตัวแปรที่ได้รับมอบหมายโดยตรงโดยไม่มีคำจำกัดความจะถูกประกาศโดยอัตโนมัติว่ามีขอบเขตทั่วโลก
(3) คุณสมบัติของวัตถุหน้าต่างทั้งหมดมีขอบเขตทั่วโลก
2. ขอบเขตท้องถิ่น
โดยทั่วไปขอบเขตของท้องถิ่นสามารถเข้าถึงได้เฉพาะในตัวอย่างรหัสคงที่เช่นตัวแปรภายในฟังก์ชั่น (ขอบเขตฟังก์ชัน)
var name = "xuxiaoping"; function echoname () {var firstName = "xu"; // local scope secondName = "xiao"; // ฟังก์ชันขอบเขตส่วนกลาง echofirstname () {console.log (ชื่อแรก); // xu} console.log (สองชื่อ); ส่งคืน echofirstname;} console.log (ชื่อ); // global scope var f = echoname (); f (); console.log (ชื่อแรก); console.log (ชื่อที่สอง);ผลที่ได้คือ:
xuxiaoping
เสี่ยว
ฟังก์ชั่น Xu // ภายในสามารถเข้าถึงตัวแปรของฟังก์ชันด้านนอก
ไม่สามารถเข้าถึง // ตัวแปรภายในของฟังก์ชั่นไม่สามารถเข้าถึงได้นอกฟังก์ชั่น
เสี่ยว
JavaScript ติดตั้งตัวแปรส่วนกลางกับวัตถุหน้าต่างและกลายเป็นคุณสมบัติของวัตถุหน้าต่าง
3. ขอบเขตฟังก์ชัน
ขอบเขตระดับบล็อก: ชุดคำสั่งใด ๆ ในวงเล็บปีกกาเป็นของบล็อกและตัวแปรทั้งหมดที่กำหนดไว้ในนี้จะมองไม่เห็นนอกบล็อกรหัส ภาษา C-class ส่วนใหญ่มีขอบเขตระดับบล็อก
อย่างไรก็ตามคุณสมบัติที่สำคัญของ JavaScript คือไม่มีขอบเขตระดับบล็อก
ฟังก์ชั่น echoi () {สำหรับ (var i = 0; i <10; i ++) {; // console.log (i); } ถ้า (จริง) {var str = "สวัสดี"; } console.log (i); console.log (str);} echoi ();ผลลัพธ์ผลลัพธ์คือ:
10
สวัสดี
จะเห็นได้ว่านอกคำสั่งสำหรับ (หรือถ้า) ตัวแปรที่ฉันกำหนดไว้ในบล็อกยังคงสามารถเข้าถึงได้ นั่นคือ JavaScript ไม่รองรับขอบเขตระดับบล็อกมันรองรับขอบเขตฟังก์ชันเท่านั้นและตัวแปรที่กำหนดไว้ที่ใดก็ได้ในฟังก์ชั่นสามารถมองเห็นได้ทุกที่ในฟังก์ชันนั้น ในฐานะคนที่เรียนรู้ C และ Java ตั้งแต่ต้นนี่เป็นเรื่องยากที่จะปรับตัว จากการทดสอบของฉันสิ่งเดียวกันนี้เป็นจริงสำหรับ PHP
แน่นอนคุณสามารถใช้คุณสมบัติการปิดของ JavaScript เพื่อจำลองขอบเขตระดับบล็อก
ฟังก์ชั่น echoi () {(ฟังก์ชัน () {สำหรับ (var i = 0; i <10; i ++) {; // console.log (i);}}) (); ถ้า (จริง) {var str = "สวัสดี"; } console.log (i); console.log (str);} echoi ();ผลลัพธ์คือ: ฉันไม่ได้กำหนด
สิ่งนี้แยกนิยามของตัวแปร ใน JS เพื่อป้องกันความขัดแย้งการตั้งชื่อตัวแปรระดับโลกและฟังก์ชั่นทั่วโลกควรหลีกเลี่ยงให้มากที่สุดเท่าที่จะเป็นไปได้ดังนั้นการปิดแบบนี้จึงถูกใช้ในหลาย ๆ ด้าน
4. วัฏจักรชีวิตตัวแปร JavaScript
วงจรชีวิตตัวแปร JavaScript จะเริ่มต้นเมื่อมีการประกาศ
ตัวแปรท้องถิ่นจะถูกทำลายหลังจากดำเนินการฟังก์ชั่น
ตัวแปรทั่วโลกจะถูกทำลายหลังจากปิดหน้า
3. โซ่ขอบเขต JavaScript
ดูเหมือนว่าโซ่มันอาจจะรวมกับรายการที่เชื่อมโยงในโครงสร้างข้อมูล
ใน JavaScript ฟังก์ชั่นเป็นวัตถุ แต่ในความเป็นจริงทุกอย่างใน JavaScript เป็นวัตถุ วัตถุฟังก์ชั่นเช่นเดียวกับวัตถุอื่น ๆ มีคุณสมบัติที่สามารถเข้าถึงได้ผ่านรหัสและชุดของคุณสมบัติภายในที่สามารถเข้าถึงได้สำหรับเอ็นจิ้น JavaScript เท่านั้น หนึ่งในคุณสมบัติภายในคือ [[ขอบเขต]] ซึ่งกำหนดโดยมาตรฐาน ECMA-262 รุ่นที่สาม คุณสมบัติภายในนี้มีการรวบรวมวัตถุในขอบเขตที่สร้างโดยฟังก์ชั่น คอลเลกชันนี้เรียกว่าขอบเขตของฟังก์ชั่นซึ่งกำหนดว่าข้อมูลใดที่สามารถเข้าถึงได้โดยฟังก์ชั่น
เมื่อมีการสร้างฟังก์ชั่นโซ่ขอบเขตของมันจะถูกเติมด้วยวัตถุข้อมูลที่สามารถเข้าถึงได้ในขอบเขตของฟังก์ชัน ตัวอย่างเช่นกำหนดฟังก์ชันเช่นนี้:
ฟังก์ชั่นเพิ่ม (num1, num2) {var sum = num1 + num2; ส่งคืนผลรวม;}เมื่อมีการสร้างฟังก์ชั่นเพิ่มวัตถุทั่วโลกจะถูกเติมลงในโซ่ขอบเขตซึ่งมีตัวแปรทั่วโลกทั้งหมดดังที่แสดงในรูปด้านล่าง (หมายเหตุ: ภาพจะให้ตัวแปรทั้งหมดเท่านั้น):
ขอบเขตของฟังก์ชั่นเพิ่มจะใช้ในระหว่างการดำเนินการ ตัวอย่างเช่นเรียกใช้รหัสต่อไปนี้:
var total = เพิ่ม (5,10);
เมื่อดำเนินการฟังก์ชั่นนี้วัตถุภายในที่เรียกว่า "บริบทการดำเนินการ" จะถูกสร้างขึ้น บริบทรันไทม์กำหนดสภาพแวดล้อมที่ฟังก์ชั่นดำเนินการ แต่ละบริบทรันไทม์มีห่วงโซ่ขอบเขตของตัวเองสำหรับการแยกวิเคราะห์ตัวระบุ เมื่อบริบทรันไทม์ถูกสร้างขึ้นโซ่ขอบเขตของมันจะเริ่มต้นเป็นวัตถุที่มีอยู่ใน [[ขอบเขต]] ของฟังก์ชั่นการรันปัจจุบัน
ค่าเหล่านี้ถูกคัดลอกไปยังห่วงโซ่ขอบเขตของบริบทรันไทม์ตามลำดับที่ปรากฏในฟังก์ชัน พวกเขาช่วยกันสร้างวัตถุใหม่ที่เรียกว่า "วัตถุการเปิดใช้งาน" ซึ่งมีตัวแปรท้องถิ่นทั้งหมดชื่อพารามิเตอร์ชุดพารามิเตอร์และฟังก์ชั่นนี้ จากนั้นวัตถุนี้จะถูกผลักไปที่ปลายด้านหน้าของห่วงโซ่ขอบเขต เมื่อบริบทการทำงานถูกทำลายวัตถุที่ใช้งานจะถูกทำลาย โซ่ขอบเขตใหม่แสดงในรูปด้านล่าง:
ในระหว่างการดำเนินการฟังก์ชั่นทุกครั้งที่พบตัวแปรกระบวนการแยกวิเคราะห์ตัวระบุจะถูกส่งผ่านเพื่อตัดสินใจว่าจะรับและจัดเก็บข้อมูลที่ไหน กระบวนการนี้เริ่มต้นจากหัวของห่วงโซ่ขอบเขตนั่นคือค้นหาตัวระบุชื่อเดียวกันจากวัตถุที่ใช้งานอยู่ หากพบให้ใช้ตัวแปรที่สอดคล้องกับตัวระบุนี้ หากไม่พบให้ค้นหาต่อไปเพื่อค้นหาวัตถุถัดไปในห่วงโซ่ขอบเขต หากไม่พบวัตถุทั้งหมดหลังจากค้นหาตัวระบุจะถูกพิจารณาว่าไม่ได้กำหนด ในระหว่างการดำเนินการของฟังก์ชั่นแต่ละตัวระบุจะต้องผ่านกระบวนการค้นหาดังกล่าว
4. โซ่ขอบเขตและการเพิ่มประสิทธิภาพรหัส
จากโครงสร้างของห่วงโซ่ขอบเขตจะเห็นได้ว่าในขอบเขตขอบเขตของบริบทรันไทม์ยิ่งตัวระบุที่ลึกกว่านั้นจะช้าลงความเร็วในการอ่านและการเขียนจะช้าลง ดังที่แสดงในรูปด้านบนเนื่องจากตัวแปรทั่วโลกมีอยู่เสมอในตอนท้ายของห่วงโซ่ขอบเขตบริบทในช่วงเวลารันไทม์จึงช้าที่สุดในการค้นหาตัวแปรทั่วโลกเมื่อแยกวิเคราะห์ตัวระบุ ดังนั้นเมื่อเขียนโค้ดคุณควรพยายามใช้ตัวแปรทั่วโลกให้น้อยที่สุดและใช้ตัวแปรท้องถิ่นให้มากที่สุด กฎง่ายๆคือ: หากมีการอ้างอิงวัตถุข้ามขอบเขตมากกว่าหนึ่งครั้งให้เก็บไว้ในตัวแปรท้องถิ่นก่อนการใช้งาน ตัวอย่างเช่นรหัสต่อไปนี้:
ฟังก์ชั่น changecolor () {document.getElementById ("btnchange"). onclick = function () {document.getElementById ("targetCanvas"). style.backgroundColor = "red"; -ฟังก์ชั่นนี้หมายถึงเอกสารตัวแปรส่วนกลางสองครั้ง ตัวแปรจะต้องค้นหาผ่านห่วงโซ่ขอบเขตทั้งหมดจนกว่าจะพบได้ในที่สุดในวัตถุทั่วโลก รหัสนี้สามารถเขียนใหม่ได้ดังนี้:
ฟังก์ชั่น changecolor () {var doc = เอกสาร; doc.getElementById ("btnchange"). onclick = function () {doc.getElementById ("TargetCanvas"). style.backgroundColor = "Red"; -รหัสนี้ค่อนข้างง่ายและจะไม่แสดงการปรับปรุงประสิทธิภาพอย่างมากหลังจากการเขียนใหม่ แต่หากมีการเข้าถึงตัวแปรทั่วโลกจำนวนมากในโปรแกรมซ้ำ ๆ ประสิทธิภาพของรหัสหลังจากการเขียนใหม่จะดีขึ้นอย่างมาก
5. ด้วยห่วงโซ่ขอบเขตการเปลี่ยนแปลง
บริบทรันไทม์ที่สอดคล้องกันนั้นไม่ซ้ำกันทุกครั้งที่มีการดำเนินการจำนวนดังนั้นการเรียกใช้ฟังก์ชันเดียวกันหลายครั้งจะนำไปสู่การสร้างบริบทรันไทม์หลายรายการ เมื่อฟังก์ชั่นถูกดำเนินการบริบทการดำเนินการจะถูกทำลาย แต่ละบริบทรันไทม์เกี่ยวข้องกับห่วงโซ่ขอบเขต โดยทั่วไปการพูดในระหว่างการดำเนินการตามบริบทของห่วงโซ่ขอบเขตของมันจะได้รับผลกระทบจากคำสั่งและคำสั่งจับเท่านั้น
คำสั่งด้วยเป็นวิธีที่รวดเร็วในการใช้วัตถุเพื่อหลีกเลี่ยงการเขียนรหัสซ้ำ ตัวอย่างเช่น:
ฟังก์ชั่น initui () {ด้วย (เอกสาร) {var bd = body, links = getElementsByTagname ("a"), i = 0, len = links.length; ในขณะที่ (i <len) {อัปเดต (ลิงก์ [i ++]); } getElementById ("btninit"). onclick = function () {dosomething (); - -ใช้คำสั่งความกว้างที่นี่เพื่อหลีกเลี่ยงการเขียนเอกสารหลายครั้งซึ่งดูมีประสิทธิภาพมากขึ้น แต่จริง ๆ แล้วสร้างปัญหาประสิทธิภาพ
เมื่อรหัสทำงานไปยังคำสั่งด้วยขอบเขตขอบเขตของบริบทรันไทม์จะเปลี่ยนไปชั่วคราว วัตถุที่ไม่แน่นอนใหม่ถูกสร้างขึ้นซึ่งมีคุณสมบัติทั้งหมดของวัตถุที่ระบุโดยพารามิเตอร์ วัตถุนี้จะถูกผลักเข้าไปในหัวของห่วงโซ่ขอบเขตซึ่งหมายความว่าตัวแปรท้องถิ่นทั้งหมดของฟังก์ชั่นอยู่ในวัตถุโซ่ขอบเขตที่สองดังนั้นการเข้าถึงจึงมีราคาแพงกว่า ดังที่แสดงในรูปด้านล่าง:
ดังนั้นควรหลีกเลี่ยงข้อความในโปรแกรม ในตัวอย่างนี้การจัดเก็บเอกสารในตัวแปรท้องถิ่นสามารถปรับปรุงประสิทธิภาพได้
สรุป
1. ขอบเขตของตัวแปรคือที่ขอบเขตของตัวแปรนั้นถูกต้อง
2. ห่วงโซ่ขอบเขตของตัวแปรคือการรวบรวมวัตถุในขอบเขตที่สร้างขึ้น
ข้างต้นเป็นเรื่องเกี่ยวกับบทความนี้ฉันหวังว่ามันจะเป็นประโยชน์สำหรับทุกคนในการเรียนรู้การเขียนโปรแกรม JavaScript