Javascript Global Variables - ตัวแปรโลคอลและโกลบอลในจาวาสคริปต์ JavaScript: ขอบเขตของตัวแปร วิธีสร้างตัวแปรจาวาสคริปต์ทั่วโลก

ตัวแปรโกลบอลในจาวาสคริปต์

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

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

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

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

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

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

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

สรุปสั้นๆ

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

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

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

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

วัตถุส่วนกลางเป็นวัตถุปกติที่ถูกสร้างขึ้นโดยอัตโนมัติเมื่อล่ามเริ่มทำงาน

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

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

การแจ้งเตือน (หน้าต่าง === นี้); // จริง

เนื่องจากตัวแปรโกลบอลเป็นคุณสมบัติของอ็อบเจ็กต์โกลบอล เมื่อทำงานกับตัวแปรโกลบอล เรากำลังทำงานกับคุณสมบัติของหน้าต่าง:

วาร์นัม = 10; การแจ้งเตือน (window.num); // 10

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

Window.num = 10; การแจ้งเตือน (หมายเลข); // 10

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

วาร์นัม = 10; การแจ้งเตือน (หมายเลข); // 10 การแจ้งเตือน (window.num); // 10. เช่นเดียวกับ alert(num);

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

วาร์นัม = 10; การแจ้งเตือน (ลบหมายเลข); // false ตัวแปรไม่ถูกลบ

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

หมายเลข = 10; การแจ้งเตือน (ลบหมายเลข); // จริง ลบตัวแปรแล้ว

ตัวแปรทำหน้าที่เป็น "คอนเทนเนอร์" สำหรับจัดเก็บข้อมูล

คุณจำพีชคณิตของโรงเรียนได้ไหม? x=5, y=6, z=x+y

คุณจำได้ไหมว่าตัวอักษร (เช่น x) สามารถใช้เก็บค่าได้ (เช่น 5) และคุณสามารถใช้ข้อมูลด้านบนคำนวณว่าค่าของ z เท่ากับ 11

ตัวอักษรเหล่านี้เรียกว่าตัวแปร และตัวแปรสามารถใช้เพื่อเก็บค่า (x=5) หรือนิพจน์ (z=x+y)

เช่นเดียวกับในพีชคณิต ตัวแปร JavaScript ใช้เพื่อจัดเก็บค่าหรือนิพจน์

ตัวแปรก็อาจมี ชื่อสั้นเช่น x หรือชื่อที่สื่อความหมายมากกว่านี้ เช่น carname

กฎสำหรับชื่อตัวแปร JavaScript:

• ชื่อตัวแปรต้องคำนึงถึงขนาดตัวพิมพ์ (y และ Y เป็นตัวแปรสองตัวที่แตกต่างกัน)
• ชื่อตัวแปรต้องขึ้นต้นด้วยตัวอักษรหรือขีดล่าง

หมายเหตุ: เนื่องจาก JavaScript คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ชื่อตัวแปรจึงคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ด้วย

ค่าของตัวแปรสามารถเปลี่ยนแปลงได้ในขณะที่สคริปต์กำลังทำงาน

การประกาศ (การสร้าง) ตัวแปร JavaScript

การสร้างตัวแปรใน JavaScript มักเรียกกันว่าตัวแปร "การประกาศ"

คุณประกาศตัวแปร JavaScript โดยใช้คำหลัก var:

หลังจากดำเนินการคำสั่งข้างต้นแล้ว ตัวแปร x จะมีค่า 5 และ carname จะมีค่า Mercedes

หมายเหตุ: เมื่อคุณกำหนดค่าข้อความให้กับตัวแปร ให้ใส่ไว้ในเครื่องหมายคำพูด

ตัวแปรท้องถิ่น JavaScript ตัวแปรที่ประกาศอยู่ข้างในฟังก์ชันจาวาสคริปต์

กลายเป็น LOCAL และจะใช้งานได้ภายในฟังก์ชันนี้เท่านั้น

(ตัวแปรมีขอบเขตท้องถิ่น)

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

คุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับฟังก์ชันต่างๆ ในบทเรียน JavaScript ต่อๆ ไป

ตัวแปรทั่วโลกของ JavaScript

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

หากคุณประกาศตัวแปรโดยไม่ใช้ "var" ตัวแปรจะกลายเป็น GLOBAL เสมอ

การกำหนดค่าให้กับตัวแปร JavaScript ที่ไม่ได้ประกาศ

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

ข้อเสนอเหล่านี้:

คุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับโอเปอเรเตอร์ในบทเรียน JavaScript ถัดไป

นี่คือสิ่งที่เราจะจัดการกับในบทเรียนนี้ ตัวแปรทั่วโลก var หากไม่ทำเช่นนี้ ตัวแปรจะปรากฏทุกที่ในโปรแกรม และยิ่งไปกว่านั้นหากเปิดใช้งานโหมดเข้มงวดจะทำให้เกิดข้อผิดพลาด หากต้องการเปิดใช้งานโหมดเข้มงวด เพียงเขียนบรรทัด “use strict” ที่ตอนต้นของสคริปต์ สิ่งนี้จะบอกล่าม JavaScript ให้ปฏิบัติตามมาตรฐาน JavaScript อย่างเคร่งครัด นี่คือตัวอย่างการใช้ตัวแปรโกลบอล

วาร์ ก =6; //ฟังก์ชันตัวแปรโกลบอล double() ( return alert(a*a); //ใช้ตัวแปรโกลบอล ) double();

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

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

วาร์ ก =6;

ฟังก์ชั่น double() ( a = 5; // เปลี่ยนค่าของตัวแปรโกลบอลในฟังก์ชั่น return alert(a*a); ) double(a); //เรียกใช้ฟังก์ชัน document.write(a); //ค่าตัวแปรโกลบอล

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

เมื่อคุณประกาศตัวแปรในฟังก์ชัน ตัวแปรนั้นจะกลายเป็นแบบโลคัลและสามารถเข้าถึงได้จากภายในฟังก์ชันเท่านั้น เป็นที่น่าสังเกตว่าคำสั่ง if/else , for, while, do... While ไม่ส่งผลกระทบต่อขอบเขตของตัวแปร

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

ฟังก์ชั่น double() ( var a =6; return alert(a*a); ) double();

เอกสาร. เขียน(ก); //พยายามเข้าถึงตัวแปรท้องถิ่น

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

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

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

ตัวแปรที่สร้างขึ้นภายนอกฟังก์ชันเป็นแบบโกลบอล

จากฟังก์ชันคุณสามารถเข้าถึงตัวแปรโกลบอลและเปลี่ยนค่าของมันได้

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

ก็ควรที่จะเรียนรู้ (และแยกแยะระหว่างแนวคิดเหล่านี้)มีเพียงสิ่งเดียวเท่านั้นคือตัวแปรเป็นแบบโกลบอลและระดับท้องถิ่น

ตัวแปรโกลบอลคืออะไร?

ลองดูตัวอย่าง...

var global = 21 ; /* สร้างตัวแปรร่วม */
{
function myFun () /* สร้างฟังก์ชันที่แสดงตัวแปร */
}

document.write(ทั่วโลก);

myFun(); /* เรียกใช้ฟังก์ชัน */

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

(ในอาร์เรย์ ฟังก์ชัน ฯลฯ)

ตัวแปรท้องถิ่นคืออะไร?
{

เรามาดูตัวอย่างกันอีกครั้ง...
ฟังก์ชั่น myFun _2 () /* สร้างฟังก์ชั่น */
}

var ท้องถิ่น = 42 ;

เอกสาร. เขียน (ท้องถิ่น);

myFun_2(); /* เรียกใช้ฟังก์ชัน */

ตัวแปรท้องถิ่นคืออะไร?
{

ตัวอย่างนี้แสดงให้เห็นถึงการสร้างตัวแปรท้องถิ่นท้องถิ่น มันเป็นท้องถิ่นเพราะมันถูกสร้างขึ้นภายในฟังก์ชั่น และสามารถใช้ได้เฉพาะภายในเท่านั้น
ฟังก์ชั่น myFun _2 () /* สร้างฟังก์ชั่น */
}

หากเราพยายามแสดงตัวแปรนี้นอกฟังก์ชัน เราจะไม่เห็นสิ่งใดในหน้าต่างเบราว์เซอร์

var ท้องถิ่น = 42 ; /* สร้างตัวแปรท้องถิ่น */ เอกสาร. เขียน (ท้องถิ่น); /* กำลังพยายามแสดงตัวแปร Local ภายนอกฟังก์ชัน */เกี่ยวกับสิ่งเหล่านี้

ตัวอย่างง่ายๆ