ตัวแปร

การประกาศตัวแปร

ก่อนที่คุณจะสามารถใช้ตัวแปรใน JavaScript ได้ จะต้องประกาศตัวแปรก่อน ตัวแปรถูกประกาศโดยใช้คำสำคัญ varดังต่อไปนี้:

วาร์ฉัน; ผลรวม;

เมื่อใช้คีย์เวิร์ด var เพียงครั้งเดียว คุณสามารถประกาศตัวแปรได้หลายตัว:

การประกาศตัวแปรสามารถใช้ร่วมกับการกำหนดค่าเริ่มต้นได้:

ข้อความ Var = "สวัสดี"; วาร์ i = 0, j = 0, k = 0;

หากไม่มีการระบุค่าเริ่มต้นในคำสั่ง var ตัวแปรจะถูกประกาศ แต่ค่าเริ่มต้นจะยังคงไม่ได้ถูกกำหนดไว้จนกว่าโปรแกรมจะเปลี่ยนแปลง

หากคุณมีประสบการณ์ในการใช้ภาษาการเขียนโปรแกรมกับประเภทข้อมูลคงที่ เช่น C# หรือ Java คุณอาจสังเกตเห็นว่าการประกาศตัวแปรใน JavaScript ขาดการประกาศประเภท ตัวแปรใน JavaScript สามารถเก็บค่าได้ทุกประเภท ตัวอย่างเช่น ใน JavaScript คุณสามารถกำหนดตัวเลขให้กับตัวแปร จากนั้นกำหนดสตริงให้กับตัวแปรเดียวกันได้:

วาร์ i = 10; ฉัน = "สวัสดี";

ด้วยคำสั่ง var คุณสามารถประกาศตัวแปรเดียวกันได้มากกว่าหนึ่งครั้ง หากการประกาศซ้ำมีตัวเริ่มต้น ก็จะทำหน้าที่เหมือนกับคำสั่งการกำหนดทั่วไป

หากคุณพยายามอ่านค่าของตัวแปรที่ไม่ได้ประกาศ JavaScript จะสร้างข้อผิดพลาด ในโหมดเข้มงวดที่จัดทำโดยมาตรฐาน ECMAScript 5 ข้อผิดพลาดก็จะเพิ่มขึ้นเช่นกันเมื่อพยายามกำหนดค่าให้กับตัวแปรที่ไม่ได้ประกาศ อย่างไรก็ตาม ในอดีตและเมื่อไม่ได้ดำเนินการในโหมดเข้มงวด หากคุณกำหนดค่าให้กับตัวแปรที่ไม่ได้ประกาศด้วยคำสั่ง var JavaScript จะสร้างตัวแปรนั้นเป็นคุณสมบัติของอ็อบเจ็กต์โกลบอล และตัวแปรนั้นจะทำหน้าที่เหมือนกับ ตัวแปรที่ประกาศอย่างถูกต้อง ซึ่งหมายความว่าไม่จำเป็นต้องประกาศตัวแปรส่วนกลาง อย่างไรก็ตาม นี่ถือเป็นนิสัยที่ไม่ดีและอาจทำให้เกิดข้อผิดพลาดได้ ดังนั้นควรพยายามประกาศตัวแปรของคุณโดยใช้ var

ขอบเขตตัวแปร

ขอบเขตของตัวแปรเป็นส่วนหนึ่งของโปรแกรมที่ตัวแปรถูกกำหนดไว้ ตัวแปรส่วนกลางมีขอบเขตส่วนกลาง - ถูกกำหนดไว้สำหรับโปรแกรม JavaScript ทั้งหมด ในเวลาเดียวกัน ตัวแปรที่ประกาศภายในฟังก์ชันจะถูกกำหนดไว้เฉพาะในเนื้อความเท่านั้น พวกเขาเรียกว่าท้องถิ่นและมีขอบเขตท้องถิ่น พารามิเตอร์ฟังก์ชันยังถือเป็นตัวแปรภายในเครื่องด้วย ซึ่งกำหนดไว้ภายในเนื้อหาของฟังก์ชันนั้นเท่านั้น

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

ผลลัพธ์ Var = "ทั่วโลก"; ฟังก์ชัน getResult() ( var result = "local"; return result; ); console.log(getResult()); // แสดง "ท้องถิ่น"

เมื่อประกาศตัวแปรด้วยขอบเขตส่วนกลาง คำสั่ง var สามารถละเว้นได้ แต่เมื่อประกาศตัวแปรภายในเครื่อง คุณควรใช้คำสั่ง var เสมอ

บทช่วยสอนสี่ส่วนนี้ครอบคลุมการเขียนโค้ด JavaScript ที่มีคุณภาพซึ่งง่ายต่อการบำรุงรักษาและพัฒนา แม้ว่าคุณจะต้องกลับมาที่โปรเจ็กต์อีกครั้งหลังจากผ่านไปนานก็ตาม

เขียนโค้ดโดยคาดหวังว่าจะต้องได้รับการสนับสนุน

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

• ถึงเวลาศึกษาและทำความเข้าใจปัญหา
• ถึงเวลาทำความเข้าใจโค้ดที่ทำให้เกิดปัญหา

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

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

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

เป็นผลให้จะใช้เวลาหลายชั่วโมงการทำงานในการเขียนโค้ด และการอ่านหลายวัน ดังนั้นการสร้างโค้ดที่บำรุงรักษาได้ง่ายจึงมีความสำคัญต่อความสำเร็จของแอปพลิเคชัน

รหัสที่บำรุงรักษาง่ายมีลักษณะดังต่อไปนี้:

• มันง่ายต่อการอ่าน
• มีโครงสร้างที่ดีและชิ้นส่วนต่างๆ มีความสอดคล้องกัน
• เขาคาดเดาได้
• ดูเหมือนว่าจะเขียนโดยคนคนหนึ่ง
• จัดทำเป็นเอกสาร

การลดการใช้ตัวแปรโกลบอลให้เหลือน้อยที่สุด

JavaScript ใช้ฟังก์ชันเพื่อจัดการบริบท ตัวแปรที่ประกาศภายในฟังก์ชันนั้นอยู่ในเครื่องและไม่สามารถเข้าถึงได้ภายนอกฟังก์ชัน ตัวแปรโกลบอลถูกประกาศไว้ภายนอกฟังก์ชันหรือใช้งานโดยไม่มีการประกาศ

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

วาร์ myglobal = "สวัสดี"; console.log(myglobal); // "สวัสดี" console.log(window.myglobal); // "สวัสดี" console.log(window["myglobal"]); // "สวัสดี" console.log(this.myglobal); // "สวัสดี"

ปัญหาเกี่ยวกับตัวแปรโกลบอล

ปัญหาเกี่ยวกับตัวแปรร่วมคือตัวแปรเหล่านี้จะสามารถใช้ได้ทั่วทั้งโค้ด JavaScript ของแอปพลิเคชันหรือเพจของคุณ พวกมันอยู่ในเนมสเปซส่วนกลาง และมีโอกาสที่จะตั้งชื่อการชนกันเสมอ โดยที่ส่วนที่แตกต่างกันสองส่วนของแอปพลิเคชันจะกำหนดตัวแปรโกลบอลด้วยชื่อเดียวกันแต่เพื่อวัตถุประสงค์ที่แตกต่างกัน

นอกจากนี้หน้าเว็บมักจะมีโค้ดที่เขียนโดยนักพัฒนารายอื่นด้วย ตัวอย่างเช่น:

• ไลบรารี JavaScript อื่น ๆ
• สคริปต์จากพันธมิตรโฆษณา
• รหัสสำหรับการติดตามและการวิเคราะห์ผู้ใช้
• วิดเจ็ต ปุ่ม และปลั๊กอินต่างๆ

สมมติว่าสคริปต์ของบุคคลที่สามตัวใดตัวหนึ่งกำหนดตัวแปรส่วนกลางที่เรียกว่า result เป็นต้น จากนั้นคุณกำหนดตัวแปรโกลบอลอีกตัวหนึ่งในฟังก์ชันของคุณแล้วเรียกมันว่า result ด้วยเหตุนี้ การประกาศตัวแปรผลลัพธ์ครั้งล่าสุดจะแทนที่ตัวแปรแรก และสคริปต์ของบุคคลที่สามอาจหยุดทำงาน

ดังนั้น เพื่อให้รวมโค้ดต่างๆ เข้าด้วยกันในหน้าเดียวได้สำเร็จ สิ่งสำคัญคือต้องใช้ตัวแปรร่วมให้น้อยที่สุดเท่าที่จะเป็นไปได้ ในเรื่องนี้ การใช้คำสั่ง var เมื่อประกาศตัวแปรมีบทบาทสำคัญ

น่าเสียดายที่มันง่ายมากที่จะสร้างตัวแปรส่วนกลางใน JavaScript โดยไม่ได้ตั้งใจเนื่องจากมีคุณสมบัติสองประการ ขั้นแรก คุณสามารถใช้ตัวแปรได้โดยไม่ต้องประกาศมัน ประการที่สอง JavaScript มีคำจำกัดความของ global โดยนัย ซึ่งหมายความว่าตัวแปรที่ไม่ได้ประกาศใดๆ จะกลายเป็นคุณสมบัติของ global object (และจะสามารถเข้าถึงได้ในฐานะตัวแปร global ที่ประกาศอย่างถูกต้อง) ตัวอย่างเช่น:

ผลรวมของฟังก์ชัน(x, y) ( // ไม่ดี: ผลลัพธ์โดยรวมโดยนัย = x + y; ส่งคืนผลลัพธ์; )

ในโค้ดนี้ ตัวแปรผลลัพธ์จะถูกใช้โดยไม่มีการประกาศ รหัสทำงานได้ดี แต่หลังจากเรียกใช้ฟังก์ชันแล้ว คุณจะพบกับตัวแปรผลลัพธ์อื่นในเนมสเปซส่วนกลาง ซึ่งอาจนำไปสู่ปัญหาได้

กฎการย่อขนาดคือการกำหนดตัวแปรโดยใช้คำสั่ง var ด้านล่างนี้เป็นฟังก์ชัน sum() เวอร์ชันปรับปรุง:

ผลรวมของฟังก์ชัน(x, y) ( var result = x + y; return result; )

อีกตัวเลือกที่ไม่ดีสำหรับการสร้าง globals โดยนัยคือการเชื่อมโยงค่าภายในการประกาศ var ในตัวอย่างต่อไปนี้ ตัวแปร a จะเป็นตัวแปรภายในเครื่อง และตัวแปร b จะเป็นตัวแปรร่วม ซึ่งอาจไม่ใช่จุดประสงค์ของผู้สร้างโค้ด:

// แย่ อย่าใช้ฟังก์ชัน foo() ( var a = b = 0; // ... )

หากคุณแปลกใจกับสิ่งที่เกิดขึ้น ก็เป็นเรื่องของการคำนวณจากขวาไปซ้าย นิพจน์ b = 0 จะถูกดำเนินการก่อน ดังนั้นตัวแปร b จะไม่ถูกประกาศ ค่าที่ส่งคืนของนิพจน์จะเป็น 0 และถูกกำหนดให้กับตัวแปรท้องถิ่น a ใหม่ ซึ่งประกาศโดยคำสั่ง var คำจำกัดความของตัวแปรนี้เทียบเท่ากับสัญลักษณ์ต่อไปนี้:

วาร์ ก = (ข = 0);

หากคุณได้ประกาศตัวแปรแล้ว การแสดงแบบลูกโซ่จะทำงานได้ดีและจะไม่สร้างตัวแปรโกลบอลที่ไม่ต้องการ:

ฟังก์ชั่น foo() ( var a, b; a = b = 0; // ตัวแปรทั้งสองเป็นแบบ local )

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

ผลข้างเคียงของการประกาศ var ที่ถูกลืม

มีความแตกต่างเล็กน้อยระหว่างตัวแปรส่วนกลางที่กำหนดไว้อย่างชัดเจนและโดยนัย มันคือความสามารถในการลบตัวแปรโดยใช้ตัวดำเนินการลบ:

• ตัวแปรโกลบอลที่ประกาศโดยการประกาศ var (สร้างในโปรแกรมนอกฟังก์ชัน) ไม่สามารถลบได้
• ตัวแปรส่วนกลางโดยนัยที่สร้างขึ้นโดยไม่มีการประกาศ (ไม่ว่าจะสร้างจากที่ใด) สามารถลบได้

ในทางเทคนิคแล้ว ตัวแปรโกลบอลโดยนัยเป็นคุณสมบัติของออบเจ็กต์โกลบอล ไม่ใช่ตัวแปร คุณสมบัติสามารถลบได้โดยใช้ตัวดำเนินการลบ แต่ตัวแปรไม่สามารถ:

// กำหนดตัวแปรโกลบอลสามตัว var global_var = 1; global_novar = 2; // ไม่ดี (ฟังก์ชั่น () ( global_fromfunc = 3; // ไม่ดี )()); // กำลังพยายามลบลบ global_var; // ลบเท็จ global_novar; // จริงลบ global_fromfunc; // จริง // กำลังตรวจสอบประเภทการลบของ global_var; // ประเภท "หมายเลข" ของ global_novar; // "ไม่ได้กำหนด" ประเภท global_fromfunc; // "ไม่ได้กำหนด"

การเข้าถึงวัตถุระดับโลก

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

Var global = (function () ( return this; )());

ดังนั้นจึงเป็นไปได้เสมอที่จะเข้าถึงอ็อบเจ็กต์โกลบอล เนื่องจากภายในฟังก์ชันที่เรียกว่าเป็นฟังก์ชัน (และไม่ใช่ในฐานะคอนสตรัคเตอร์ที่มีการประกาศใหม่) สิ่งนี้จะชี้ไปที่อ็อบเจ็กต์โกลบอลเสมอ

เทมเพลตการประกาศเดี่ยว var

การใช้การประกาศ var เดี่ยวที่ด้านบนของฟังก์ชันเป็นแนวทางปฏิบัติที่มีประโยชน์มาก วิธีนี้มีข้อดีดังต่อไปนี้:

• จัดให้มีที่เดียวในการประกาศตัวแปรท้องถิ่นทั้งหมดของฟังก์ชัน
• ป้องกันข้อผิดพลาดเชิงตรรกะเมื่อใช้ตัวแปรก่อนที่จะประกาศ
• ช่วยให้ไม่ลืมที่จะประกาศตัวแปรภายในเครื่อง และลดจำนวนตัวแปรส่วนกลางลง

เทมเพลตที่มีการประกาศ var เดียวจะมีลักษณะดังนี้:

ฟังก์ชั่น func() ( var a = 1, b = 2, sum = a + b, myobject = (), i, j; // รหัสฟังก์ชัน... )

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

คุณยังสามารถดำเนินการกับการประกาศตัวแปรได้ เช่น sum = a + b จากโค้ดตัวอย่างก่อนหน้า อีกตัวอย่างการทำงานคือการจัดการ DOM คุณสามารถกำหนดการอ้างอิงไปยังองค์ประกอบ DOM ให้กับตัวแปรท้องถิ่นเมื่อประกาศ:

ฟังก์ชั่น updateElement() ( var el = document.getElementById("result"), style = el.style; // ดำเนินการกับ el และ style... )

การยก: ปัญหาเกี่ยวกับการประกาศ var ที่กระจัดกระจาย

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

// ชื่อของฉันไม่ดี = "ทั่วโลก"; // ฟังก์ชั่นตัวแปรโกลบอล func() ( alert(myname); // "unknown" var myname = "local"; alert(myname); // "local" ) func();

ในตัวอย่างนี้ การโทรครั้งแรกเพื่อ alert() คาดว่าจะสร้างข้อความ "global" และการเรียกครั้งที่สองไปที่ "local" ความคาดหวังที่สมเหตุสมผลเนื่องจากในการเรียกครั้งแรก myname ตัวแปรโลคัลไม่ได้ถูกประกาศ และฟังก์ชันต้องใช้ตัวแปรโกลบอล myname แต่ในความเป็นจริง สิ่งต่างๆ ทำงานแตกต่างออกไป การเรียก alert() ครั้งแรกจะส่งคืน "unknown" เนื่องจาก myname ถือเป็นตัวแปรท้องถิ่นที่ประกาศในฟังก์ชัน (แม้ว่าการประกาศจะมาในภายหลัง) การประกาศตัวแปรทั้งหมดจะถูกยกไปที่ด้านบนของฟังก์ชัน ดังนั้น เพื่อหลีกเลี่ยงข้อผิดพลาดประเภทนี้ คุณต้องประกาศตัวแปรทั้งหมดที่ด้านบนของฟังก์ชัน

ตัวอย่างก่อนหน้านี้จะทำหน้าที่เสมือนว่ามีการใช้งานดังนี้:

ชื่อของฉัน = "ทั่วโลก"; // ฟังก์ชันตัวแปรโกลบอล func() ( var myname; // เช่นเดียวกับ -> var myname = undef; alert(myname); // "unknown" myname = "local"; alert(myname); // " local" ) ฟังก์ชั่น();

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

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

ทั้งหมดนี้ใช้กับความรู้พื้นฐานทางภาษาขั้นพื้นฐานที่สุด หากไม่เข้าใจทั้งหมดนี้ คุณจะไม่สามารถก้าวไปข้างหน้าและพัฒนาทักษะการเขียนโปรแกรม js ของคุณได้ นอกจากนี้แนวคิดหลักจะเป็นประโยชน์กับคุณไม่เพียง แต่ในความเชี่ยวชาญนี้เท่านั้น แต่ยังรวมถึงสาขาไอทีโดยทั่วไปด้วย เอาล่ะ มาเริ่มกันเลย!

ตัวแปรคืออะไร และสร้างขึ้นได้อย่างไร?

ตัวแปรคือองค์ประกอบของภาษาการเขียนโปรแกรมซึ่งจัดสรรพื้นที่หน่วยความจำและเก็บค่าบางอย่างไว้

อาจมีตัวแปรจำนวนมาก และตัวแปรทั้งหมดต้องมีชื่อไม่ซ้ำกัน

ตัวแปรมีสองประเภท: ส่วนกลางและท้องถิ่น ความแตกต่างอยู่ในขอบเขตของตัวแปรที่ต่างกันเท่านั้น ดังนั้นองค์ประกอบระดับโลกจึงมองเห็นได้ตลอดทั้งโค้ด และองค์ประกอบในท้องถิ่นจะมองเห็นได้เฉพาะในพื้นที่ขนาดเล็กที่ได้รับการประกาศเท่านั้น

อย่างไรก็ตาม ลองตั้งแต่วันแรกตั้งแต่โค้ดแรกของคุณ เพื่อเรียกองค์ประกอบต่างๆ ด้วยชื่อที่สมเหตุสมผลและเข้าใจได้ เพราะต่อมาเมื่อคุณทำงานกับโปรแกรมหนักๆ หลังจากผ่านไประยะหนึ่ง คุณจะจำไม่ได้ว่าอะไร เช่น "aa1" หรือ "perem3" หมายถึงอะไร

และไม่มีอะไรชัดเจนจากชื่ออย่างแน่นอน! นี่ก็ไม่ได้แย่ขนาดนั้น ท้ายที่สุดแล้ว การเข้าใจงานเขียนของคุณเองก็ไม่ใช่เรื่องยาก คุณจะทำอย่างไรหากคุณได้รับมอบหมายให้ทำงานให้เสร็จสิ้นในโปรแกรมอื่นที่คุณไม่เคยได้ยินมาก่อน? ด้วยชื่อดังกล่าว การวิเคราะห์การใช้งานซอฟต์แวร์จะช่วยประหยัดเวลาที่มีประโยชน์ได้มาก

ฉันได้อ่านสัญลักษณ์แล้ว ตอนนี้เรากลับมาที่การประกาศตัวแปรกันดีกว่า

ในการสร้างตัวแปร คุณต้องเขียนคำสำคัญก่อน varแล้วก็ชื่อตัวเอง นี่คือสิ่งที่ดูเหมือน:

var text = “สวัสดีผู้ใช้!”

หลังจากนี้ ข้อความจะถูกเข้าถึงโดยไม่มี “var”:

ข้อความ = “ข้อความใหม่”

ในกรณีนี้ ค่าจะถูกเขียนทับ

เพื่อความเข้าใจที่ดีขึ้น ลองพิจารณาตัวอย่างที่มีการสร้างตัวแปรตัวเดียว เราจะหันไปหาความหมายของมันก่อนและหลังการเขียนใหม่

1 2 3 4

var text = “สวัสดีผู้ใช้!”; การแจ้งเตือน (ข้อความ); // จะพิมพ์ "สวัสดีผู้ใช้!" text= “ข้อความใหม่!”; การแจ้งเตือน (ข้อความ); // จะพิมพ์ "ข้อความใหม่!"

var text = “สวัสดีผู้ใช้!”; การแจ้งเตือน (ข้อความ); // จะพิมพ์ "สวัสดีผู้ใช้!" text= “ข้อความใหม่!”; การแจ้งเตือน (ข้อความ); // จะพิมพ์ "ข้อความใหม่!"

คุณสมบัติของวัตถุทั่วโลก

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

เป็นฟังก์ชันและตัวแปรทั้งหมดที่ได้รับการประกาศไว้ในเนื้อหาหลักของโค้ด เช่น ไม่อยู่ในฟังก์ชันใดๆ ทั้งหมดนี้ใน js จะกลายเป็นคุณสมบัติของ global object โดยอัตโนมัติ ซึ่งในเบราว์เซอร์จะมองเห็นได้อย่างชัดเจนภายใต้คำว่า window ลองดูตัวอย่าง

ราคาวาร์ป = 145; // สร้างตัวแปรโกลบอล

การแจ้งเตือน (window.price); // ตอบ: 145

จนถึงตอนนี้ทุกอย่างเรียบง่าย แต่เตรียมพร้อมสำหรับข้อผิดพลาด บางครั้ง คุณสามารถเขียนทับพารามิเตอร์ที่สำคัญมากได้โดยไม่ทราบข้อมูลเฉพาะของการบันทึกและการเขียนทับค่าตัวแปร ข้อผิดพลาดดังกล่าวค่อนข้างยากต่อการติดตามและไม่พบโดยใช้คอมไพเลอร์ ดังนั้นควรวิเคราะห์เนื้อหาต่อไปนี้อย่างรอบคอบ

ข้อผิดพลาดและขอบเขต

เพื่อให้เข้าใจปัญหาได้ดีขึ้น ก่อนอื่นฉันจะแสดงโปรแกรมขนาดเล็กที่ฉันจะสร้างตัวแปรท้องถิ่นในฟังก์ชัน จากนั้นจึงแสดงนอกขอบเขต - ตัวแปรส่วนกลาง

การทดสอบฟังก์ชัน () ( p = 2; return p; ) การแจ้งเตือน (p); // ไม่ได้กำหนด p = “ข้อความสำคัญ”; การแจ้งเตือน(p); // จะแสดงข้อความสำคัญ test(); // เรียกใช้ฟังก์ชัน alert(p); // จะพิมพ์ 2

ในตอนแรก ในฟังก์ชันทดสอบ ฉันเริ่มต้นตัวแปรท้องถิ่นด้วยค่า 2 จากนั้นจึงสร้างตัวแปรข้อความส่วนกลางที่เก็บข้อมูลสำคัญบางอย่าง

และที่นี่ "บล็อกใต้น้ำ" ก็ปรากฏขึ้น

ประการแรกเนื่องจากฉันใช้การสร้างองค์ประกอบตามกฎของมาตรฐาน JavaScript ที่ล้าสมัยตัวแปร "p" ทั้งหมดจึงถูกสร้างขึ้นในเวลาที่ได้รับมอบหมายเท่านั้น (เมื่อใช้คำสั่ง var ตัวแปรจะถูกสร้างขึ้นทันทีพร้อมค่า ไม่ได้กำหนดไว้ และระหว่างการกำหนดค่าเริ่มต้นผ่านค่า “= » จะถูกเขียนทับ)

ประการที่สอง ในกรณีนี้ ในการกำหนดค่าให้กับองค์ประกอบที่สร้างขึ้นโดยปริยายใน js จะใช้องค์ประกอบที่มีอยู่หรือสร้างตัวแปรโกลบอลใหม่ ดังนั้น ในตัวอย่างข้างต้น หลังจากเรียกใช้ฟังก์ชันทดสอบ ค่าของโกลบอล "p" ก็หายไป

เพื่อหลีกเลี่ยงการขัดข้อง ให้ใช้คีย์เวิร์ด var เสมอ จากนั้นวัตถุทั้งหมดจะถูกประกาศอย่างชัดเจนและวัตถุใหม่จะถูกสร้างขึ้น

นี่คือตัวอย่างที่แก้ไขแล้ว:

การทดสอบฟังก์ชัน () ( var p = 2; alert (p); return p; ) alert(p); // ไม่ได้กำหนด var p = "ข้อความสำคัญ"; การแจ้งเตือน(p); // จะแสดงข้อความสำคัญ test(); // เรียกใช้ฟังก์ชัน ในกรณีนี้จะแสดง 2 การแจ้งเตือน(p); // จะแสดง "ข้อความสำคัญ"

ตอนนี้รหัสทำงานได้อย่างถูกต้อง ดังที่คุณสังเกตเห็น ขอบเขตของ "p" ในพื้นที่นั้นอยู่ภายในฟังก์ชันการทดสอบ และขอบเขตส่วนกลางนั้นอยู่ภายในส่วนที่เหลือของโค้ด

คำไม่กี่คำเกี่ยวกับค่าคงที่

เช่นเดียวกับภาษาการเขียนโปรแกรมอื่นๆ JavaScript มีค่าคงที่ ส่วนใครที่ไม่รู้ว่ามันคืออะไร ผมจะแนบคำจำกัดความมาด้วย

ค่าคงที่คือตัวแปรประเภทหนึ่งที่มีค่าไม่เปลี่ยนแปลง

ตามกฎของไวยากรณ์ใน js ชื่อจะเขียนด้วยตัวพิมพ์เล็ก (ตัวพิมพ์ใหญ่) เสมอ ตัวอย่างเช่น,

var MAIN_COLOR = “#fff”

ไม่มีคุณลักษณะทางเทคนิคในภาษาสคริปต์ที่จะทำให้ค่าคงที่มีค่าคงที่อย่างแท้จริง อันที่จริงมันเป็นตัวแปรธรรมดาที่สามารถเขียนทับได้ อย่างไรก็ตาม ตามกฎแล้ว นักพัฒนาใช้องค์ประกอบเหล่านี้กับตัวพิมพ์ใหญ่ในชื่อเป็นค่าคงที่ และไม่เปลี่ยนความหมายขณะเขียนโค้ด

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

JavaScript มีขอบเขต 3 ขอบเขต ได้แก่ ขอบเขตส่วนกลาง ฟังก์ชัน และขอบเขตบล็อก ขอบเขตตัวแปรเป็นส่วนหนึ่งของซอร์สโค้ดของโปรแกรมซึ่งตัวแปรและฟังก์ชันต่างๆ สามารถมองเห็นและนำไปใช้ได้ ขอบเขตส่วนกลางเรียกอีกอย่างว่าโค้ดระดับบนสุด

ตัวแปรร่วม

ตัวแปรที่ประกาศภายนอกฟังก์ชันหรือบล็อกเรียกว่าโกลบอล ตัวแปรส่วนกลางสามารถใช้ได้ทุกที่ในซอร์สโค้ด:

วาร์นัม = 5; ฟังก์ชั่น foo() ( console.log(num); ) foo(); // 5 console.log(หมายเลข); // 5 ( console.log(num); // 5 )

ตัวแปรท้องถิ่น

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

ฟังก์ชั่น foo() ( var num = 5; console.log(num); ) foo(); // 5 console.log(ประเภทหมายเลข); // ไม่ได้กำหนด

ตัวแปรโลคัลจะมีความสำคัญเหนือกว่าตัวแปรโกลบอลที่มีชื่อเดียวกัน ซึ่งหมายความว่าภายในฟังก์ชัน ตัวแปรโลคัลจะถูกใช้แทนตัวแปรโกลบอล:

Var x = "ทั่วโลก"; // ฟังก์ชันตัวแปรโกลบอล checkscope() ( var x = "local"; // ตัวแปรโลคอลที่มีชื่อเดียวกับโกลบอล one document.write(x); // ใช้ตัวแปรโลคอล ไม่ใช่โกลบอล) เช็คสโคป() ; // => "local" ลอง »

บล็อกตัวแปร

ตัวแปรที่ประกาศภายในบล็อกโดยใช้คีย์เวิร์ดให้เรียกว่าตัวแปรบล็อก ตัวแปรบล็อกสามารถเข้าถึงได้ทุกที่ภายในบล็อกที่ได้รับการประกาศ:

ให้ num = 0; ( ให้ num = 5; console.log(num); // 5 ( ให้ num = 10; console.log(num); // 10 ) console.log(num); // 5 ) console.log(num) ; // 0

ประกาศอีกครั้ง

หากคุณใช้คีย์เวิร์ด var เพื่อประกาศตัวแปรที่มีชื่อเดียวกันอีกครั้ง (ในขอบเขตเดียวกัน) จะไม่มีอะไรเกิดขึ้น:

วาร์ ก = 10; วาร์ ก; console.log(ก); // 10

หากการประกาศใหม่มาพร้อมกับการกำหนดค่าเริ่มต้น คำสั่งดังกล่าวจะทำหน้าที่เหมือนกับการกำหนดค่าใหม่ตามปกติ:

วาร์ ก = 10; วาร์ ก = 5; // เช่นเดียวกับ a = 5; console.log(ก); // 5

หากคุณใช้คีย์เวิร์ด let เพื่อประกาศตัวแปรที่มีชื่อเดียวกันอีกครั้ง (ในขอบเขตเดียวกัน) ข้อผิดพลาดจะเกิดขึ้น:

วาร์ ก = 10; ปล่อยให้; // ข้อผิดพลาด.

ห่วงโซ่ขอบเขต

ลองพิจารณาตัวอย่างต่อไปนี้:

วาร์นัม = 5; ฟังก์ชัน foo() ( var num2 = 10; แถบฟังก์ชัน() ( var num3 = 15; ) )

รหัสนี้มีสามขอบเขต: global, foo() function scope และ bar() function scope ขอบเขตส่วนกลางกำหนดตัวแปร num และฟังก์ชัน foo() ขอบเขตของฟังก์ชัน foo() กำหนดตัวแปร num2 และ function bar() และตัวแปร num จากขอบเขตส่วนกลางก็มีให้ใช้งานเช่นกัน ขอบเขตของฟังก์ชัน bar() มีตัวแปร 1 ตัวคือ num3 ซึ่งสามารถเข้าถึงได้ภายในฟังก์ชัน bar() เท่านั้น ขอบเขตของฟังก์ชัน bar() ยังสามารถเข้าถึงตัวแปรจากอีกสองขอบเขตได้เนื่องจากเป็นผู้ปกครอง ห่วงโซ่ขอบเขตสำหรับตัวอย่างนี้แสดงในรูปด้านล่าง:

ในภาพ พื้นที่การมองเห็นที่แตกต่างกันจะแสดงด้วยสี่เหลี่ยมที่มีสีต่างกัน ขอบเขตภายในในสายโซ่ของขอบเขตสามารถเข้าถึงทุกสิ่งจากขอบเขตภายนอก แต่ขอบเขตภายนอกไม่สามารถเข้าถึงอะไรเลยจากขอบเขตภายใน

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

Var str = "ทั่วโลก"; วาร์นัม = 5; function foo() ( var str = "local"; // การใช้ตัวแปรท้องถิ่น str num = 10; // การใช้ตัวแปรโกลบอล num // alert(x); // ข้อผิดพลาด ตัวแปร x ไม่ได้อยู่ในขอบเขตใดๆ ) foo( ) ; การแจ้งเตือน (str); // การแจ้งเตือน "ทั่วโลก" (หมายเลข); // 10

หากคุณกำหนดค่าให้กับตัวแปรที่ไม่ได้ประกาศในส่วนเนื้อความของฟังก์ชัน เมื่อถึงเวลาที่ฟังก์ชันถูกเรียกใช้ หากไม่มีตัวแปรที่มีชื่อเดียวกันในขอบเขตส่วนกลาง ตัวแปรส่วนกลางใหม่จะถูกสร้างขึ้น:

ฟังก์ชั่น foo() ( num = 2; ) foo(); // สร้างการแจ้งเตือน num ตัวแปรโกลบอลใหม่ (num); // 2

การเพิ่มขึ้นของโฆษณา

ใน JavaScript ตัวแปรที่ประกาศสามารถเข้าถึงได้ทุกที่ที่เกี่ยวข้องกับขอบเขต ซึ่งหมายความว่าตัวแปรจะมองเห็นได้ก่อนที่จะประกาศเป็นโค้ดเสียอีก คุณลักษณะของ JavaScript นี้เรียกอย่างไม่เป็นทางการว่า hoisting: โค้ดโปรแกรมจะทำงานเหมือนกับการประกาศตัวแปรถูกยกขึ้นโดยปริยาย (โดยไม่ต้องเริ่มต้น) ไปที่ด้านบนสุดของขอบเขต

พิจารณาข้อมูลโค้ดต่อไปนี้:

Var str = "ทั่วโลก"; ฟังก์ชั่น foo() ( alert(str); // ไม่ได้กำหนด var str = "local"; alert(str); // "local" ) foo();

เมื่อดูโค้ด คุณจะคิดว่าการแจ้งเตือนครั้งแรกควรพิมพ์สตริง "global" เนื่องจากการประกาศตัวแปรโลคัล str ยังไม่ได้ดำเนินการ อย่างไรก็ตาม จริงๆ แล้วมันจะส่งออกค่า unknown ด้วยการเพิ่มการประกาศ ฟังก์ชันด้านบนจะเทียบเท่ากับการใช้งานด้านล่าง ซึ่งการประกาศตัวแปรจะถูกยกไปที่จุดเริ่มต้นของฟังก์ชัน:

ฟังก์ชั่น foo() ( var str; // การประกาศตัวแปรท้องถิ่นที่จุดเริ่มต้นของฟังก์ชั่น alert(str); // สามารถใช้ได้ แต่ไม่ได้เตรียมใช้งาน str = "local"; // นี่คือการแจ้งเตือนเตรียมใช้งาน ( str); // และนี่คือค่าที่คาดหวัง - "ท้องถิ่น")

เช่นเดียวกับขอบเขตส่วนกลาง ตัวแปรที่ประกาศด้านล่างสามารถเข้าถึงได้ที่ด้านบน:

การแจ้งเตือน(หมายเลข); // ไม่ได้กำหนด var num = 10; การแจ้งเตือน (หมายเลข); // 10

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

สวัสดี = สวัสดี ; //ตั้งค่าตัวแปรโกลบอลและตรวจสอบ
เอกสาร. writeln (->1 + สวัสดี + ทุกคน
- //->1สวัสดีทุกท่านครับ

ถ้า(จริง)
//ถ้า(เท็จ)
{
var hello = สวัสดีดอลลี่ และ ; //นี่ก็เป็นสากลเช่นกัน
โลก = โลก ; //ทั่วโลก
var cont = เราดำเนินการต่อ //global
เอกสาร. writeln(->1.2 + สวัสดี + โลก + ต่อ +
);
//1.2 สวัสดีดอลลี่และโลก เราดำเนินการต่อ
}
เอกสาร. writeln(->2 + สวัสดี + โลก + ต่อ +
);
//->2 สวัสดีดอลลี่และโลก เราดำเนินการต่อ

ถ้าเป็นจริงเราจะได้คำตอบ

->1 สวัสดีครับทุกท่าน
->1.2 สวัสดีดอลลี่และโลก เราดำเนินการต่อ
->2 สวัสดีดอลลี่และโลก เราดำเนินการต่อ

การดำเนินการถูกยกเลิก

ดังนั้นปรากฎว่าการใช้ var ไม่มีผลกระทบต่อขอบเขตทั่วโลก ตัวแปรที่กล่าวถึงในสคริปต์ที่อยู่นอกขั้นตอนจะถือเป็นตัวแปรส่วนกลางแม้ว่าจะอยู่ในวงเล็บ () ก็ตาม ในขณะที่บล็อกและพื้นที่อื่นๆ จะยังคงเป็นแบบโกลบอลแม้อยู่ในลูป

สรุปสั้นๆ

• สำหรับตัวแปรที่ใช้ในโซนการมองเห็นโดยรวม การมีอยู่ของ var นั้นไม่สำคัญ
• บล็อกหลังจากนั้น if while for อย่าสร้างขอบเขตท้องถิ่น (เช่นเดียวกับที่เกิดขึ้นในภาษาอื่น)

ตัวแปรท้องถิ่นคือตัวแปรที่กำหนดไว้ภายในบล็อกปฏิบัติการ (ฟังก์ชัน) และไม่ส่งผลกระทบต่อฟังก์ชันอื่นๆ และสภาพแวดล้อมภายนอก ได้แก่ พื้นที่ส่วนกลาง

เด็กชาย = โจน ;
ทำ = ฆ่าเคนนี่; //ดังนั้นเราจึงมีตัวแปรโกลบอล 2 ตัว
ฟังก์ชั่น doit()
{
//พิมพ์ผ่านไปแล้ว --1 และเราเปลี่ยนข้อมูล เปลี่ยนข้อมูล
var boy = แกรี่ ; //สร้างสถานที่
ทำ = ช่วยแอนนี่ ; //เปลี่ยนโกลบอล
;
เอกสาร. writeln(--2+boy++did+
);
//--2 แกรี่ช่วยแอนนี่
;
// ตอนนี้ภายในฟังก์ชันเราจะตั้งค่าตัวแปรท้องถิ่นและระดับโลก
var good = เขาเป็นเด็กดี
- //สถานที่!
แย่ = เขาชอบผู้หญิงเลว
- //ทั่วโลก
}
;
เอกสาร. writeln(--1+boy++did+
);
//--1 Jhone ฆ่า Kenny
ดอย();
//--2 แกรี่ช่วยแอนนี่
เอกสาร. writeln(--3+boy++d+
);
//--3 จอนช่วยแอนนี่
;
ถ้า(!จริง)
//ถ้า(!เท็จ)
{
เอกสาร. writeln(--4 + ดี);
//การดำเนินการบล็อกนี้จะทำให้เกิดข้อผิดพลาด
//ตอนนี้เราอยู่นอกขอบเขตท้องถิ่นแล้ว
//doit() ฟังก์ชันจึงมอบให้เราผ่านทาง var
//ตัวแปรที่ดีไม่มีอยู่จริง
}
เอกสาร. writeln(--5 + แย่);
//--5 เขาชอบผู้หญิงเลว

ผลลัพธ์:

1 Jhone ฆ่า Kenny
--2 แกรี่ช่วยแอนนี่
--3 เจฮอนช่วยแอนนี่
--5 เขาชอบผู้หญิงเลว

บทสรุป

ตัวแปรท้องถิ่นในจาวาสคริปต์

• var ทำงานภายในฟังก์ชันโดยประกาศตัวแปรท้องถิ่น นี่คืองานหลักของเขา

คำแนะนำและหมายเหตุ

• Javascript แตกต่างจาก C มากตรงที่มีเพียงตัวแปรท้องถิ่น (?) เท่านั้นที่เป็นไปได้ภายในฟังก์ชัน
• การใช้ var ในขอบเขตทั่วโลกหรือไม่นั้นขึ้นอยู่กับประสบการณ์ส่วนตัวของคุณเท่านั้น แต่สำหรับฉันอย่าเกียจคร้านจะดีกว่า ในภาษา Perl เรียกว่า use strict

>>>สำหรับตัวแปรที่ใช้ในโซนการมองเห็นโดยรวม การมีอยู่ของ var นั้นไม่สำคัญ

สำคัญ. ประการแรก ไม่สามารถลบ “vars” ได้ (โดยใช้การลบ) ประการที่สอง การสร้างอินสแตนซ์จะเกิดขึ้นบน "เส้นศูนย์" (ก่อนที่จะเริ่มทำงาน "ทีละบรรทัด") ซึ่งพวกเขาจะได้รับการกำหนดค่าทันทีที่ไม่ได้กำหนด และเฉพาะเมื่อตัวแปรเท่านั้นที่อาจ (หรืออาจไม่) ได้รับค่าใหม่:

วาร์ glb_1 = 1;
ถ้า (เท็จ) (var glb_2 = 2; glb_3 = 3;)

alert(glb_1) // สร้างอินสแตนซ์และรับค่า 1
alert(glb_2) // ระบุและรับค่า 'ไม่ได้กำหนด'
alert(glb_3) // ไม่ใช่ตัวแปรเลย (ไม่มี var) เกิดข้อผิดพลาดขณะเข้าถึง