จาวาสคริปต์ ตัวแปร (ส่วนกลาง ท้องถิ่น ค่าคงที่) ตัวแปรส่วนกลางและตัวแปรท้องถิ่นของ Javascript - เรียนรู้พื้นฐานของภาษาการเขียนโปรแกรมเว็บ Js ตัวแปรท้องถิ่นและระดับโลก

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

คุณจำพีชคณิตของโรงเรียนได้ไหม? 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 ด้วยคำหลัก

วาร์ :

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

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

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

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

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

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

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

ตัวแปรร่วมจะถูกทำลายเมื่อคุณปิดเพจ

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

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

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

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

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 การค้นหาจะหยุดลง หากไม่พบชื่อในขอบเขตปัจจุบัน การค้นหาจะดำเนินการในขอบเขตถัดไป (ภายนอก) เป็นต้น ดังนั้น ตัวระบุจากขอบเขตที่พบจะถูกนำมาใช้ หากไม่พบบัตรประชาชนในพื้นที่ใดพื้นที่หนึ่ง การมองเห็นจาวาสคริปต์จะสร้างข้อผิดพลาด:

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

อัปเดตครั้งล่าสุด: 04/05/2018

ตัวแปรทั้งหมดใน JavaScript มีขอบเขตเฉพาะที่สามารถทำงานได้

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

วาร์ x = 5; ให้ d = 8; ฟังก์ชัน displaySquare())( var z = x * x; console.log(z); )

ที่นี่ตัวแปร x และ d เป็นตัวแปรร่วม สามารถเข้าถึงได้จากทุกที่ในโปรแกรม

แต่ตัวแปร z ไม่ใช่แบบโกลบอล เนื่องจากมีการกำหนดไว้ภายในฟังก์ชัน

ตัวแปรที่กำหนดภายในฟังก์ชันเป็นแบบท้องถิ่น:

ฟังก์ชัน displaySquare())( var z = 10; console.log(z); ให้ b = 8; console.log(b); )

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

ฟังก์ชัน displaySquare())( var z = 10; console.log(z); ) console.log(z); //ข้อผิดพลาดเนื่องจากไม่ได้กำหนด z

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

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

วาร์ z = 89; ฟังก์ชั่น displaySquare())( var z = 10; console.log(z); // 10 ) displaySquare(); // 10

ในกรณีนี้ ฟังก์ชันจะใช้ตัวแปร z ที่กำหนดไว้ในฟังก์ชันโดยตรง นั่นคือตัวแปรโลคัลจะซ่อนตัวแปรโกลบอล

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

ให้ z = 10; ฟังก์ชั่น displayZ())( ให้ z = 20; ( ให้ z = 30; console.log("Block:", z); ) console.log("Function:", z); ) displayZ(); console.log("ทั่วโลก:", z);

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

และในกรณีนี้เราจะได้ผลลัพธ์คอนโซลดังต่อไปนี้:

บล็อก: 30 ฟังก์ชั่น: 20 Global: 10

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

ฟังก์ชัน displaySquare())( var z = 20; ( var z = 30; // Error! ตัวแปร z ถูกกำหนดไว้แล้ว console.log("Block:", z); ) console.log("Function:", z) ; )

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

ทุกสิ่งที่ใช้กับตัวดำเนินการ let ก็ใช้กับตัวดำเนินการ const ด้วย ซึ่งช่วยให้คุณกำหนดค่าคงที่ได้ บล็อกโค้ดจะกำหนดขอบเขตของค่าคงที่ และค่าคงที่ที่กำหนดไว้ในบล็อกโค้ดที่ซ้อนกันจะซ่อนค่าคงที่ภายนอกที่มีชื่อเดียวกัน:

ค่าคอนสท์ z = 10; ฟังก์ชั่น displayZ())( const z = 20; ( const z = 30; console.log("Block:", z); // 30 ) console.log("Function:", z); // 20 ) displayZ ( ); console.log("ทั่วโลก:", z); // 10

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

แถบฟังก์ชั่น())( foo = "25"; ) บาร์(); console.log(ฟู); // 25

แม้ว่าตัวแปร foo จะไม่ถูกกำหนดไว้ที่ใดก็ได้ภายนอกฟังก์ชัน bar แต่ก็ยังสามารถใช้งานได้ภายนอกฟังก์ชันในบริบทภายนอก

มันจะแตกต่างออกไปถ้าเราไม่เพียงแต่กำหนดค่าให้กับตัวแปร แต่ยังกำหนดไว้ด้วย:

แถบฟังก์ชั่น())( var foo = "25"; ) บาร์(); console.log(ฟู); // ข้อผิดพลาด

การกำหนดตัวแปรร่วมในฟังก์ชันอาจทำให้เกิดข้อผิดพลาดได้ หากต้องการหลีกเลี่ยง ให้ใช้โหมดเข้มงวด:

"ใช้อย่างเข้มงวด"; แถบฟังก์ชั่น())( foo = "25"; ) บาร์(); console.log(ฟู);

ในกรณีนี้ เราจะได้รับข้อผิดพลาด SyntaxError: Unexpected identifier ซึ่งบ่งชี้ว่าไม่ได้กำหนดตัวแปร foo

มีสองวิธีในการตั้งค่าโหมดเข้มงวด:

เพิ่มนิพจน์ "use strict" ที่จุดเริ่มต้นของโค้ด JavaScript จากนั้นโหมดเข้มงวดจะถูกนำไปใช้กับโค้ดทั้งหมด

เพิ่มนิพจน์ "use strict" ที่จุดเริ่มต้นของส่วนเนื้อหาของฟังก์ชัน จากนั้นโหมดเข้มงวดจะถูกนำไปใช้กับฟังก์ชันนี้เท่านั้น

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

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

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

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

สรุปสั้นๆ

• สำหรับตัวแปรที่ใช้ในโซนการมองเห็นโดยรวม การมีอยู่ของ 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
//ตัวแปร good ไม่มีอยู่จริง
}
เอกสาร. writeln(--5 + แย่);
//--5 เขาชอบผู้หญิงเลว

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

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

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

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

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

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

ตัวแปรและค่าคงที่ใน JavaScript การประกาศตัวแปรและการกำหนดค่าให้กับตัวแปรเหล่านั้น ตัวแปรโกลบอลและโลคัล การใช้ค่าคงที่

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

วาร์ เปเรเมนนายา_1 วาร์ เปเรเมนนายา_2

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

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

Peremennaya_1 = 25 Peremennaya_2 = "ข้อความที่กำหนดอยู่ในเครื่องหมายคำพูดตรง"

คุณสามารถกำหนดค่าให้กับตัวแปรได้ทันทีเมื่อมีการประกาศ:

Var Peremennaya_1 = 25 var Peremennaya_2 = "ข้อความที่กำหนดอยู่ในเครื่องหมายคำพูดตรง"

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

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

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

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

วาร์ DRUG_CHELOVEKA = "สุนัข"

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

ใน JavaScript ค่าคงที่สามารถเขียนใหม่เป็นตัวแปรได้ แต่ถ้าคุณทำเช่นนี้ ความหมายของค่าคงที่จะหายไป