ตัวแปรคือตำแหน่งหน่วยความจำที่มีชื่อซึ่งคุณสามารถเก็บข้อมูลบางส่วนและดึงข้อมูลออกมาได้
การประกาศตัวแปร (การสร้าง) ทำได้โดยใช้คีย์เวิร์ด var
// ข้อความ - ชื่อตัวแปร var ข้อความ;
เมื่อคุณสร้างตัวแปร คุณสามารถกำหนดค่าให้กับตัวแปรนั้นได้ทันที
การกำหนดค่าให้กับตัวแปรทำได้โดยใช้ตัวดำเนินการ “=”
// เช่น สร้างตัวแปรอีเมลและกำหนดสตริงให้กับมัน " [ป้องกันอีเมล]"อีเมล var = " [ป้องกันอีเมล]"; // ตั้งค่าตัวแปรอีเมลเป็นค่าใหม่ email = " [ป้องกันอีเมล]";
หากต้องการรับค่าของตัวแปร เพียงอ้างอิงชื่อตัวแปร
// ตัวอย่างเช่น ส่งออกค่าของตัวแปรอีเมลไปยังคอนโซลของเบราว์เซอร์: console.log(email);
หากต้องการประกาศตัวแปรมากกว่าหนึ่งตัวแปรโดยใช้คีย์เวิร์ด var เดียว คุณต้องใช้เครื่องหมายจุลภาค
ราคา Var = 78.55 ปริมาณ = 10 ข้อความ;
JavaScript เป็นภาษาที่พิมพ์แบบไดนามิกหรืออ่อนแอ
ซึ่งหมายความว่าเมื่อมีการประกาศตัวแปร ไม่จำเป็นต้องระบุประเภทข้อมูลที่ยอมรับได้ ดังนั้น ขั้นแรกคุณสามารถใส่ค่าของประเภทข้อมูลหนึ่งลงในตัวแปร แล้วตามด้วยอีกประเภทหนึ่งได้
เอาท์พุท Var = "ความสำเร็จ"; // ตัวแปรมีชนิดข้อมูลสตริงเอาต์พุต = 28; // ตัวแปรเดียวกัน แต่เป็นประเภทข้อมูล "ตัวเลข" แล้ว เอาต์พุต = จริง; // ตัวแปรเดียวกันแต่เก็บค่าบูลีนไว้แล้ว
ค่าของตัวแปรสามารถเปลี่ยนแปลงได้ไม่จำกัดจำนวนครั้ง
// สร้างตัวแปรอายุ var age; // อายุตัวแปรถูกกำหนดให้เป็นค่า 67 อายุ = 67; // อายุตัวแปรถูกตั้งค่าเป็น "อายุเกษียณ" age = "อายุเกษียณ"; // อายุตัวแปรตั้งไว้ที่ 55 age = 55;
แนวปฏิบัติที่ดีในการพัฒนาแอปพลิเคชันไคลเอนต์คือการใช้ประเภทข้อมูลเพียงประเภทเดียวในตัวแปรที่กำหนด เช่น อย่าเขียนค่าของข้อมูลประเภทต่างๆ ลงในตัวแปร เพื่อให้เข้าใจว่าควรคาดหวังข้อมูลประเภทใดในตัวแปร เมื่อสร้างตัวแปร ขอแนะนำให้เริ่มต้นด้วยค่าเฉพาะทันที
ชื่อตัวแปรสามารถประกอบด้วยตัวอักษร ตัวเลข และสัญลักษณ์ $ และ _ ในกรณีนี้ อักขระตัวแรกของตัวแปรต้องไม่ใช่ตัวเลข นอกจากนี้ คุณไม่สามารถใช้คำสงวนเป็นชื่อตัวแปรได้
กรณีของตัวอักษรในชื่อตัวแปรมีความสำคัญ ตัวอย่างเช่น โทรศัพท์ที่แปรผันและโทรศัพท์เป็นตัวแปรสองตัวที่แตกต่างกัน
หากไม่ได้ใช้โหมดเข้มงวด คุณสามารถสร้างตัวแปรด้วยค่าเริ่มต้นโดยไม่ต้องใช้คีย์เวิร์ด var
ราคา = 250.00; // สร้างตัวแปรและกำหนดค่าเริ่มต้นด้วยตัวเลข 250.00 เปอร์เซ็นต์ = "20%"; // สร้างตัวแปรและเริ่มต้นด้วยสตริง “20%”
แต่ไม่แนะนำให้สร้างตัวแปรในลักษณะนี้
ประเภทข้อมูลใน JavaScript ชนิดข้อมูลสามารถแบ่งออกเป็นแบบดั้งเดิมและวัตถุ
ตัวแปรที่มีชนิดข้อมูลดั้งเดิมจะเก็บค่าไว้อย่างชัดเจน
มี 5 ประเภทข้อมูลดั้งเดิมใน JavaScript:
- ตัวเลข;
- เชือก;
- ประเภทบูลีน (บูลีน);
- โมฆะ;
- ไม่ได้กำหนด
หากมีการกำหนดค่าให้กับตัวแปรตัวหนึ่งซึ่งมีชนิดข้อมูลพื้นฐาน ตัวแปรนั้นจะได้รับสำเนาของค่านั้นเอง
วาร์ x = 77, y = x; x = 55; ใช่; // 77
ตัวแปรที่มีอ็อบเจ็กต์ไม่ได้เก็บอ็อบเจ็กต์ไว้จริงๆ แต่เป็นการอ้างอิงถึงอ็อบเจ็กต์นั้น
หากตัวแปรตัวหนึ่งได้รับการกำหนดค่าให้กับอีกตัวแปรหนึ่งที่มีออบเจ็กต์ (ลิงก์ไปยังตัวแปรนั้น) ตัวแปรนั้นก็จะได้รับลิงก์ไปยังตัวแปรนั้นด้วย จากการดำเนินการนี้ ตัวแปรทั้งสองนี้จะมีการอ้างอิงไปยังออบเจ็กต์เดียวกัน
// ตัวอย่างที่ 1 (พร้อมประเภทข้อมูล "วัตถุ") var coord1 = (x: 77, y: 100), coord2 = coord1; coord1.x = 55; // ตั้งค่าคุณสมบัติ x ของวัตถุเป็นค่าใหม่ coord2.x; // 55 เพราะว่า coord1 และ coord2 มีการอ้างอิงถึงวัตถุเดียวกัน // ตัวอย่าง 2 (ที่มีชนิดข้อมูลอาร์เรย์) var coord1 = , coord2 = coord1; พิกัด1 = 55; // ตั้งค่าองค์ประกอบด้วยดัชนี 0 เป็นค่าใหม่ coord2; // 55 เพราะว่า coord1 และ coord2 มีการอ้างอิงถึงวัตถุเดียวกัน // ตัวอย่าง 3 (ที่มีประเภทข้อมูล "date") var date1 = new Date(2018,00,01), date2 = date1; date2 = date2.setDate(date2.getDate()+7); // เพิ่มวันที่ 7 วัน date1; // 01/07/2018 เพราะ date1 และ date2 มีการอ้างอิงถึงวัตถุเดียวกัน
ตัวเลขประเภทข้อมูลตัวเลขใน JavaScript เป็นแบบทั่วไป ใช้เพื่อแสดงทั้งจำนวนเต็มและเศษส่วน
ตัวแปร int = 5; // จำนวนเต็ม var float = 5.98; // จำนวนเศษส่วน
รูปแบบการแสดงตัวเลขใน JavaScript เป็นไปตามมาตรฐาน IEEE 754-2008
จำนวนเต็มใน JavaScript สามารถระบุได้ไม่เพียงแต่เป็นทศนิยมเท่านั้น แต่ยังระบุเป็นฐานแปด (0) หรือเลขฐานสิบหก (0x) ได้โดยใช้คำนำหน้าที่ระบุในวงเล็บ:
ตัวแปร int = 010; // 8 int = 055; // 45 int = 0xFF; //255 int = 0xB8; // 184
สามารถเขียนตัวเลขในรูปแบบเลขชี้กำลังได้:
วาร์ นัม = 2e3; // สัญกรณ์เลขชี้กำลังของตัวเลข 2*10^3 (2000) num = 2e-3; // สัญลักษณ์เอ็กซ์โปเนนเชียลของตัวเลข 2*10^-3 (0.002) num = 3.2e3; // 3200 หมายเลข = 1.5e-2; // 0.015
นอกจากตัวเลขแล้ว ชนิดข้อมูลตัวเลขยังมีค่าตัวเลขพิเศษอีกด้วย:
- อนันต์ (บวกอนันต์);
- -อินฟินิตี้ (อินฟินิตี้เชิงลบ);
- น่าน (ไม่ใช่ตัวเลข)
ค่าพิเศษ อินฟินิตี้ หมายถึงจำนวนบวกที่มีขนาดใหญ่มาก เช่น ตัวเลขที่ไม่สามารถแสดงใน JavaScript ได้เนื่องจากมีขนาดใหญ่เกินไป
ความหมายพิเศษ -อินฟินิตี้ หมายถึงจำนวนลบที่มีขนาดใหญ่มาก ในทางกลับกัน เช่น ตัวเลขที่ไม่สามารถแสดงด้วย JavaScript ได้เนื่องจากมีขนาดใหญ่เกินไป
ตัวอย่างของนิพจน์ที่จะส่งคืนค่าตัวเลขพิเศษอันเป็นผลมาจากการคำนวณ:
5/0; // อนันต์ -5/0; // -Infinity Math.pow (10,399); // อนันต์ (10 ยกกำลัง 399) Math.pow(10,399); // -อนันต์ (-10 ยกกำลัง 399)
ค่า NaN จะถูกส่งกลับอันเป็นผลมาจากการดำเนินการทางคณิตศาสตร์ที่ JavaScript ไม่สามารถคำนวณได้
5 - "สวัสดี"; // NaN (ลบบรรทัดออกจากหมายเลข 5) 1,000 / "20px"; // NaN (ตัวเลขหารด้วยสตริง) true * "1rem"; // NaN (ค่าบูลีนจริงคูณด้วยสตริง)
สิ่งที่น่าสนใจมากคือค่าของ NaN ใน JavaScript ไม่เท่ากับสิ่งใดๆ แม้แต่ตัวมันเองด้วย
น่าน == น่าน; // น่านเท็จ === น่าน; //เท็จ
ชนิดข้อมูลบูลีนBoolean เป็นชนิดข้อมูลดั้งเดิมที่มีค่าเพียงสองค่า: จริงและเท็จ
วาร์ ก = จริง; วาร์ ข = เท็จ;
สตริงสตริงเป็นชนิดข้อมูลที่ใช้ใน JavaScript เพื่อแสดงข้อความ
สตริง JavaScript สามารถมีความยาวได้ตั้งแต่ 0 อักขระขึ้นไป
JavaScript จะใช้ Unicode เป็นรูปแบบสตริงเสมอ
การสร้างสตริง (ตัวอักษรสตริง) ทำได้โดยการใส่ข้อความด้วยเครื่องหมายคำพูดเดี่ยวหรือคู่
"จาวาสคริปต์"; "ECMAScript";
ใน JavaScript ไม่มีความแตกต่างระหว่างเครื่องหมายคำพูดเดี่ยวและคู่
แต่ในบางกรณี การใช้เครื่องหมายคำพูดเดี่ยวมากกว่าการใช้เครื่องหมายคำพูดคู่และในทางกลับกันก็สมเหตุสมผล
ตัวอย่างเช่น เมื่อสตริงมีเครื่องหมายคำพูดคู่ จะสะดวกกว่าหากใส่ไว้ในเครื่องหมายคำพูดเดี่ยว วิธีนี้จะขจัดความจำเป็นในการหลีกเลี่ยงเครื่องหมายคำพูดคู่ในนั้น
""ECMAScript""; // ไม่มีการหลบหนี (ใช้เครื่องหมายคำพูดเดี่ยว) "\"ECMAScript\""; //พร้อมกับหลบหนี
สตริงใน JavaScript สามารถมีอักขระพิเศษได้ ตัวอย่างเช่น \n (การป้อนบรรทัด), \t (แท็บ), \r (การขึ้นบรรทัดใหม่) เป็นต้น
"นี่คือประโยค\nและนี่ก็เป็นประโยคด้วย แต่จะเริ่มจากบรรทัดใหม่";
ด้วยสตริง คุณสามารถดำเนินการบวก (ยูเนียน) หรืออีกนัยหนึ่งคือการต่อข้อมูลได้ ตัวดำเนินการ "+" ใช้สำหรับสิ่งนี้ ความหมายของการดำเนินการนี้คือการผนวกบรรทัดที่สองต่อท้ายบรรทัดแรก
"ฉันรัก" + "จาวาสคริปต์"; // ฉันชอบจาวาสคริปต์
ค่าคือ "ไม่ได้กำหนด"undefinition เป็นชนิดข้อมูลดั้งเดิมพิเศษที่มีค่าเดียวเท่ากับ undefinition
ชนิดข้อมูลนี้มีตัวแปรที่ประกาศซึ่งยังไม่ได้กำหนดค่า
วาร์นัม; // ไม่ได้กำหนด
ค่าที่ไม่ได้กำหนดจะถูกส่งกลับเมื่อเข้าถึงคุณสมบัติที่ไม่มีอยู่จริงของวัตถุ
วาร์ obj = (); // วัตถุว่าง obj.prop; // ไม่ได้กำหนด
ค่า "โมฆะ"null เป็นชนิดข้อมูลดั้งเดิมพิเศษที่มีค่าเดียวเท่ากับ null
null เป็นเพียงค่าพิเศษที่มีความหมายว่า "ไม่มีอะไร" หรือ "ค่าที่ไม่รู้จัก" เช่น เห็นได้ชัดว่ามันไม่ได้มีความหมายอะไรเลย
วัตถุวัตถุคือโครงสร้างข้อมูลที่ประกอบด้วยคู่ชื่อ-ค่า
การสร้างวัตถุโดยใช้สัญกรณ์ตามตัวอักษรของวัตถุทำได้ดังนี้:
( name_1: value_1, name_2: value_2, name_3: value_3, ... )
อย่างที่คุณเห็น ชื่อจะถูกแยกออกจากค่าโดยใช้เครื่องหมายทวิภาค และคู่จะถูกแยกออกจากกันโดยใช้เครื่องหมายจุลภาค
ยิ่งไปกว่านั้น หากค่าของคู่นั้นเป็นฟังก์ชัน ก็จะเรียกว่าเมธอดของอ็อบเจ็กต์นี้ คู่อื่นๆ ทั้งหมด เช่น คู่ที่ไม่ได้ใช้ฟังก์ชันเป็นค่าเรียกว่าคุณสมบัติของวัตถุ
กล่าวอีกนัยหนึ่ง วัตถุคือโครงสร้างข้อมูลที่ประกอบด้วยคุณสมบัติและวิธีการ
บุคคล Var = ( ชื่อ: "Vitaly", อายุ: 27, getAge: function () ( return "Age: " + this.age; ) )
การเข้าถึงคุณสมบัติของออบเจ็กต์ทำได้โดยใช้จุดหรือเครื่องหมายวงเล็บเหลี่ยม
// แสดงค่าของคุณสมบัติอายุในคอนโซลของเบราว์เซอร์ // วิธีที่ 1 (ผ่านจุด) console.log(person.age); // วิธีที่ 2 (ใช้วงเล็บ) console.log(person["age"]); // เรียกเมธอด getAge; ค่าที่ส่งคืนจะถูกส่งออกไปยังคอนโซล console.log(person.getAge());
ประเภทของตัวดำเนินการตัวดำเนินการ typeof ใช้เพื่อรับข้อมูลเกี่ยวกับชนิดข้อมูลของนิพจน์ในรูปแบบสตริง
ไวยากรณ์ของตัวดำเนินการ typeof (ตัวเลือกที่ไม่มีวงเล็บ):
ประเภทของการแสดงออก
ประเภทของไวยากรณ์ตัวดำเนินการ (ใช้วงเล็บ):
ประเภทของ(การแสดงออก)
ชื่อวาร์ อายุ = 37 อีเมล = " [ป้องกันอีเมล]", isLicense = true, ดอกเบี้ย: null, LastExperience: ( ระยะเวลา: "มิถุนายน 2554 - มิถุนายน 2561", สถานที่: "ISACA, มอสโก", ตำแหน่ง: "นักออกแบบเว็บไซต์" ), getExperience: function() ( ส่งคืน LastExperience. period + " ("+ LastExperience.position + " - " + LastExperience.place + ")" ; ประเภทของชื่อ; // "หมายเลข" ของความสนใจ; / "วัตถุ" (1) ประเภทของประสบการณ์สุดท้าย; // "วัตถุ" ของ getExperience; / "function" (2) /* (1) - นี่เป็นข้อผิดพลาดที่มีอยู่ในภาษาตั้งแต่การใช้งานครั้งแรก เพื่อรักษาความเข้ากันได้และจะต้องนำมาพิจารณาเมื่อเขียนสคริปต์เป็นข้อมูลดั้งเดิม type ไม่ใช่วัตถุ */ /* (2) - สะดวกมากที่ตัวดำเนินการ typeof แยกฟังก์ชันออกจากกัน แต่ฟังก์ชันใน JavaScipt ก็เป็นฟังก์ชันเช่นกัน ซึ่งสามารถตรวจสอบได้อย่างง่ายดายโดยดำเนินการก่อสร้างต่อไปนี้: */ typeof getExperience.__proto__.__proto__ // "object" (ฟังก์ชันต้นแบบคืออ็อบเจ็กต์)
ค่าคงที่ด้วยการเปิดตัว ECMAScript 6 ทำให้สามารถสร้างค่าคงที่ได้ ทำได้โดยใช้คีย์เวิร์ด const
ค่าสี COLOR_RED = "#ff0000";
ค่าคงที่คือตัวแปรที่มีค่าที่ได้รับการปกป้องจากการเปลี่ยนแปลง เหล่านั้น. เมื่อคุณพยายามเปลี่ยนค่า ข้อผิดพลาดจะเกิดขึ้น
ค่าสี COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Uncaught TypeError: การกำหนดให้กับตัวแปรคงที่
ตัวอย่างเช่น หากค่าคงที่มีวัตถุอยู่ ก็ไม่สามารถเปลี่ยนแปลงได้ หรือเป็นการอ้างอิงถึงวัตถุนั้นแทน แต่คุณสมบัติของวัตถุนี้สามารถเปลี่ยนแปลงได้
Const COLORS = ( สีแดง: "#ff0000", สีเขียว: "#00ff00", สีน้ำเงิน: "" "00ff00" ) COLORS = ["#ff0000", "#00ff00", "#00ff00"]; // Uncaught TypeError: การกำหนดให้กับตัวแปรคงที่ COLORS.green = "#4caf50";
ตัวแปรคือตัวระบุที่ได้รับการกำหนดค่า ตัวแปรสามารถเข้าถึงได้ในโปรแกรม ดังนั้นการทำงานกับค่าที่กำหนดให้กับตัวแปรนั้นตัวแปร JavaScript นั้นไม่มีข้อมูลเกี่ยวกับประเภทของค่าที่จะจัดเก็บไว้ในนั้น ซึ่งหมายความว่าโดยการเขียนสตริงให้กับตัวแปร คุณสามารถเขียนตัวเลขลงไปได้ในภายหลัง การดำเนินการดังกล่าวจะไม่ทำให้เกิดข้อผิดพลาดในโปรแกรม นี่คือเหตุผลว่าทำไมบางครั้ง JavaScript จึงถูกเรียกว่าภาษา "untyped"
ก่อนที่จะใช้ตัวแปรได้ จะต้องประกาศโดยใช้คีย์เวิร์ด var หรือ Let ก่อน หากเรากำลังพูดถึงค่าคงที่ คีย์เวิร์ด const จะถูกใช้ คุณสามารถประกาศตัวแปรและกำหนดค่าให้กับตัวแปรได้โดยไม่ต้องใช้คีย์เวิร์ดเหล่านี้ แต่ไม่แนะนำให้ทำเช่นนั้น
▍คำหลัก var ก่อน ES2015 การใช้คำหลัก var เป็นวิธีเดียวในการประกาศตัวแปรวาร์ ก = 0
หากคุณละเว้น var ในโครงสร้างนี้ ค่าจะถูกกำหนดให้กับตัวแปรที่ไม่ได้ประกาศ ผลลัพธ์ของการดำเนินการนี้ขึ้นอยู่กับโหมดที่โปรแกรมถูกเรียกใช้งาน
ดังนั้นหากเปิดใช้งานโหมดเข้มงวดที่เรียกว่าจะทำให้เกิดข้อผิดพลาด หากไม่ได้เปิดใช้งานโหมดเข้มงวด ตัวแปรจะถูกประกาศโดยปริยายและกำหนดให้กับออบเจ็กต์โกลบอล โดยเฉพาะอย่างยิ่ง นี่หมายความว่าตัวแปรที่ประกาศโดยปริยายในฟังก์ชันในลักษณะนี้จะยังคงอยู่หลังจากฟังก์ชันเสร็จสิ้นแล้ว โดยปกติแล้ว คาดว่าตัวแปรที่ประกาศในฟังก์ชันจะไม่ "เกินขอบเขต" ของตัวแปรเหล่านั้น ดูเหมือนว่านี้:
ฟังก์ชั่น notVar() ( bNotVar = 1 // ดีกว่าที่จะไม่ทำเช่นนี้) notVar() console.log(bNotVar)
1 จะปรากฏในคอนโซล โดยปกติไม่มีใครคาดหวังพฤติกรรมดังกล่าวจากโปรแกรม นิพจน์ bNotVar = 1 ดูไม่เหมือนความพยายามในการประกาศและเริ่มต้นตัวแปร แต่เหมือนกับความพยายามในการเข้าถึงตัวแปรที่อยู่ในขอบเขตภายนอก ฟังก์ชั่น (นี่ค่อนข้างปกติ) เป็นผลให้การประกาศตัวแปรโดยนัยสร้างความสับสนให้กับผู้ที่อ่านโค้ดและอาจนำไปสู่พฤติกรรมของโปรแกรมที่ไม่คาดคิด ต่อไปเราจะพูดถึงทั้งฟังก์ชันและขอบเขต แต่ตอนนี้พยายามใช้คีย์เวิร์ดพิเศษเสมอเมื่อความหมายของนิพจน์คือการประกาศตัวแปร หากในตัวอย่างนี้ เนื้อความของฟังก์ชันถูกเขียนใหม่เป็น var bNotVar = 1 การพยายามเรียกใช้ส่วนของโค้ดด้านบนจะส่งผลให้เกิดข้อความแสดงข้อผิดพลาด (คุณสามารถดูได้ในคอนโซลของเบราว์เซอร์)
ตัวอย่างเช่น อาจมีลักษณะดังนี้: Uncaught ReferenceError: bNotVar is not Defed ความหมายของมันขึ้นอยู่กับความจริงที่ว่าโปรแกรมไม่สามารถทำงานกับตัวแปรที่ไม่มีอยู่จริงได้ เป็นการดีกว่ามากที่จะเห็นข้อความแสดงข้อผิดพลาดเมื่อคุณเริ่มโปรแกรมครั้งแรกมากกว่าการเขียนโค้ดที่ไม่สามารถเข้าใจได้ซึ่งอาจทำงานโดยไม่คาดคิด
เมื่อประกาศตัวแปร หากไม่ได้กำหนดค่าเริ่มต้นหรือกำหนดค่าใดๆ ตัวแปรนั้นจะถูกกำหนดค่าที่ไม่ได้กำหนดโดยอัตโนมัติ
Var a //typeof a === "ไม่ได้กำหนด"
ตัวแปรที่ประกาศด้วยคีย์เวิร์ด var สามารถประกาศได้หลายครั้ง โดยกำหนดค่าใหม่ให้กับตัวแปรเหล่านั้น (แต่อาจทำให้ผู้ที่อ่านโค้ดสับสนได้)
วาร์ ก = 1 วาร์ ก = 2
คุณสามารถประกาศตัวแปรหลายตัวในนิพจน์เดียว:
วาร์ ก = 1, ข = 2
ขอบเขตของตัวแปรคือพื้นที่ของโปรแกรมที่ตัวแปรนี้สามารถเข้าถึงได้ (มองเห็นได้)
ตัวแปรที่เริ่มต้นด้วยคีย์เวิร์ด var ภายนอกฟังก์ชันจะถูกกำหนดให้กับอ็อบเจ็กต์โกลบอล มีขอบเขตทั่วโลกและสามารถเข้าถึงได้จากทุกที่ในโปรแกรม หากมีการประกาศตัวแปรโดยใช้คีย์เวิร์ด var ภายในฟังก์ชัน ตัวแปรนั้นจะมองเห็นได้เฉพาะภายในฟังก์ชันนั้นเท่านั้น โดยเป็นตัวแปรเฉพาะที่สำหรับตัวแปรนั้น
หากฟังก์ชันที่ใช้ var ประกาศตัวแปรที่มีชื่อเหมือนกับตัวแปรในขอบเขตส่วนกลาง ตัวแปรนั้นจะ "แทนที่" ตัวแปรส่วนกลาง นั่นคือเมื่อเข้าถึงตัวแปรดังกล่าวภายในฟังก์ชัน เวอร์ชันในเครื่องจะถูกนำมาใช้
สิ่งสำคัญคือต้องเข้าใจว่าบล็อก (พื้นที่ของโค้ดที่อยู่ในเครื่องหมายปีกกา) ไม่ได้สร้างขอบเขตใหม่ ขอบเขตใหม่จะถูกสร้างขึ้นเมื่อมีการเรียกใช้ฟังก์ชัน คีย์เวิร์ด var มีสิ่งที่เรียกว่าขอบเขตการทำงานมากกว่าขอบเขตบล็อก
หากมีการประกาศตัวแปรในโค้ดฟังก์ชัน โค้ดฟังก์ชันทั้งหมดจะมองเห็นได้ แม้ว่าตัวแปรจะถูกประกาศโดยใช้ var ที่ส่วนท้ายของโค้ดฟังก์ชัน แต่ก็สามารถเข้าถึงได้ที่ตอนต้นของโค้ด เนื่องจาก JavaScript มีกลไกการยกตัวแปร กลไกนี้จะ "ยก" การประกาศตัวแปร แต่ไม่ใช่การดำเนินการเริ่มต้น นี่อาจทำให้เกิดความสับสนได้ ดังนั้นจงสร้างนิสัยในการประกาศตัวแปรที่จุดเริ่มต้นของฟังก์ชัน
▍คำหลัก Let คำหลัก Let เปิดตัวครั้งแรกใน ES2015 และเรียกในรูปแบบง่ายๆ ได้ว่า var เวอร์ชัน "บล็อก" ตัวแปรที่ประกาศด้วยคีย์เวิร์ด let ถูกกำหนดขอบเขตไว้ที่บล็อก คำสั่ง หรือนิพจน์ที่มีการประกาศ และบล็อกที่ซ้อนกันหากคำว่า "ให้" ดูไม่ชัดเจนนัก คุณสามารถจินตนาการถึงการใช้คำว่า "ให้" แทนได้ จากนั้นสำนวน la color = "red" สามารถแปลเป็นภาษาอังกฤษว่า "let the color be red" และเป็นภาษารัสเซียว่า "let the color be red"
เมื่อใช้คีย์เวิร์ด let คุณสามารถหลีกเลี่ยงความคลุมเครือที่มาพร้อมกับคีย์เวิร์ด var ได้ (เช่น คุณจะไม่สามารถประกาศตัวแปรเดิมซ้ำสองครั้งโดยใช้ let ) การใช้ Let นอกฟังก์ชัน เช่น เมื่อเริ่มต้นลูป จะไม่สร้างตัวแปรโกลบอล
ตัวอย่างเช่น รหัสนี้จะสร้างข้อผิดพลาด:
สำหรับ (ให้ i = 0; i< 5; i++) {
console.log(i)
}
console.log(i)
หากเมื่อเริ่มต้นการวนซ้ำ ตัวนับ i ถูกประกาศโดยใช้คีย์เวิร์ด var แล้ว i จะพร้อมใช้งานภายนอกลูปหลังจากที่ทำงานเสร็จแล้ว
ทุกวันนี้ เมื่อพัฒนาโปรแกรม JS ตามมาตรฐานสมัยใหม่ ค่อนข้างเป็นไปได้ที่จะละทิ้ง var โดยสิ้นเชิง และใช้เฉพาะคีย์เวิร์ด let และ const เท่านั้น
▍คำหลัก const ค่าของตัวแปรที่ประกาศโดยใช้คำหลัก var หรือ let สามารถเขียนทับได้ หากใช้ const แทนคีย์เวิร์ดเหล่านี้ ค่าคงที่ที่ประกาศและกำหนดค่าเริ่มต้นด้วยตัวช่วยจะไม่สามารถกำหนดค่าใหม่ได้Const = "ทดสอบ"
ในตัวอย่างนี้ ไม่สามารถกำหนดค่าคงที่ a ใหม่ได้ แต่ควรสังเกตว่าถ้า a ไม่ใช่ค่าดั้งเดิมเช่นตัวเลข แต่เป็นวัตถุ การใช้คีย์เวิร์ด const ไม่ได้ป้องกันวัตถุนี้จากการเปลี่ยนแปลง
เมื่อพวกเขาบอกว่าวัตถุถูกเก็บไว้ในตัวแปร ความหมายจริงๆ ก็คือตัวแปรจะเก็บข้อมูลอ้างอิงไปยังวัตถุนั้น ลิงก์นี้ไม่สามารถเปลี่ยนแปลงได้ แต่สามารถเปลี่ยนออบเจ็กต์ที่ลิงก์นำไปสู่ได้
คีย์เวิร์ด const ไม่ได้ทำให้วัตถุไม่เปลี่ยนรูป เพียงปกป้องการอ้างอิงถึงสิ่งเหล่านั้นที่เขียนในค่าคงที่ที่สอดคล้องกันจากการเปลี่ยนแปลง นี่คือสิ่งที่ดูเหมือน:
Const obj = () console.log(obj.a) obj.a = 1 //works console.log(obj.a) //obj = 5 //ทำให้เกิดข้อผิดพลาด
ในระหว่างการกำหนดค่าเริ่มต้น วัตถุว่างใหม่จะถูกเขียนไปยังค่าคงที่ obj ความพยายามในการเข้าถึงคุณสมบัติ a ซึ่งไม่มีอยู่ ไม่ได้ทำให้เกิดข้อผิดพลาด คอนโซลไม่ได้รับการกำหนด หลังจากนั้น เราจะเพิ่มคุณสมบัติใหม่ให้กับออบเจ็กต์และพยายามเข้าถึงอีกครั้ง คราวนี้มูลค่าของคุณสมบัตินี้คือ 1 หากคุณยกเลิกหมายเหตุบรรทัดสุดท้ายของตัวอย่าง การพยายามรันโค้ดนี้จะส่งผลให้เกิดข้อผิดพลาด
คีย์เวิร์ด const คล้ายกันมากกับ let โดยเฉพาะมันมีขอบเขตบล็อก
ในสภาพปัจจุบันเป็นที่ยอมรับได้มากที่จะใช้คีย์เวิร์ด const เพื่อประกาศเอนทิตีทั้งหมดที่ไม่มีการวางแผนให้เปลี่ยนค่าโดยหันไปใช้ในกรณีพิเศษเท่านั้น ทำไม ประเด็นทั้งหมดก็คือ เป็นการดีที่สุดที่จะพยายามใช้โครงสร้างที่ง่ายที่สุดที่เป็นไปได้ เพื่อไม่ให้โปรแกรมซับซ้อนและหลีกเลี่ยงข้อผิดพลาด
ชนิดข้อมูล JavaScript บางครั้งเรียกว่าภาษา "untyped" แต่ก็ไม่เป็นเช่นนั้น เป็นเรื่องจริงที่คุณสามารถเขียนค่าประเภทต่างๆ ลงในตัวแปรได้ แต่ JavaScript ก็ยังมีประเภทข้อมูลอยู่ โดยเฉพาะอย่างยิ่ง เรากำลังพูดถึงประเภทข้อมูลดั้งเดิมและอ็อบเจ็กต์ในการกำหนดประเภทข้อมูลของค่า คุณสามารถใช้ตัวดำเนินการ typeof ได้ ส่งคืนสตริงที่ระบุประเภทของตัวถูกดำเนินการ
▍ประเภทข้อมูลดั้งเดิม นี่คือรายการประเภทข้อมูลดั้งเดิมของ JavaScript:- ตัวเลข
- เชือก
- บูลีน (ค่าบูลีน)
- null (ค่าพิเศษเป็นโมฆะ)
- ไม่ได้กำหนด (ค่าพิเศษไม่ได้กำหนด)
- สัญลักษณ์ (สัญลักษณ์ที่ใช้ในกรณีพิเศษแนะนำใน ES6)
เรามาพูดถึงประเภทข้อมูลที่ใช้บ่อยที่สุดจากรายการนี้กันดีกว่า
ประเภทตัวเลข ค่าของประเภทตัวเลขใน JavaScript จะแสดงเป็นตัวเลขทศนิยมที่มีความแม่นยำสองเท่าแบบ 64 บิตในโค้ด ตัวอักษรตัวเลขจะแสดงเป็นจำนวนเต็มและเศษส่วนในระบบเลขฐานสิบ คุณสามารถใช้วิธีอื่นในการเขียนตัวเลขได้ ตัวอย่างเช่น หากมีคำนำหน้า 0x ที่จุดเริ่มต้นของตัวอักษรตัวเลข จะถือเป็นตัวเลขที่เขียนในรูปแบบเลขฐานสิบหก ตัวเลขสามารถเขียนในรูปแบบเอ็กซ์โปเนนเชียลได้ (สามารถพบตัวอักษร e ได้ในตัวเลขดังกล่าว)
นี่คือตัวอย่างการเขียนจำนวนเต็ม:
10 5354576767321 0xCC // เลขฐานสิบหก
นี่คือเศษส่วน
3.14 .1234 5.2e4 //5.2 * 10^4
ตัวอักษรตัวเลข (ลักษณะการทำงานนี้เป็นเรื่องปกติสำหรับประเภทดั้งเดิมบางประเภท) เมื่อคุณพยายามเข้าถึงเป็นอ็อบเจ็กต์ จะถูกแปลงโดยอัตโนมัติตลอดระยะเวลาของการดำเนินการเป็นอ็อบเจ็กต์ที่เกี่ยวข้อง ซึ่งเรียกว่า "ตัวห่ออ็อบเจ็กต์" ในกรณีนี้ เรากำลังพูดถึงตัวตัดอ็อบเจ็กต์ Number
ตัวอย่างเช่น นี่คือความพยายามในการเข้าถึงตัวแปร a ซึ่งมีตัวอักษรตัวเลข ซึ่งดูเหมือนเป็นวัตถุในคอนโซล Google Chrome
คำใบ้ตัวตัดอ็อบเจ็กต์ตัวเลข
ตัวอย่างเช่น หากคุณใช้เมธอด toString() ของออบเจ็กต์ประเภท Number ก็จะส่งคืนการแสดงสตริงของตัวเลข คำสั่งที่เกี่ยวข้องมีลักษณะดังนี้ ซึ่งสามารถดำเนินการได้ในคอนโซลของเบราว์เซอร์ (และในโค้ดปกติ) ดังนี้:
A.toString()
สังเกตวงเล็บคู่หลังชื่อวิธีการ หากคุณไม่ระบุ ระบบจะไม่สร้างข้อผิดพลาด แต่แทนที่จะเห็นเอาต์พุตที่คาดไว้ คุณจะเห็นบางสิ่งในคอนโซลที่ไม่คล้ายกับการแสดงสตริงของหมายเลข 5 เลย
อ็อบเจ็กต์ Global Number สามารถใช้เป็น Constructor โดยสร้างตัวเลขใหม่ด้วยความช่วยเหลือ (แต่แทบไม่เคยใช้ในรูปแบบนี้เลย) และยังสามารถใช้เป็นเอนทิตีอิสระได้โดยไม่ต้องสร้างอินสแตนซ์ (นั่นคือ ตัวเลขบางตัว เป็นตัวแทนด้วยความช่วยเหลือ) ตัวอย่างเช่น คุณสมบัติ Number.MAX_VALUE มีค่าตัวเลขสูงสุดที่สามารถแสดงใน JavaScript
ประเภทสตริง ค่าของประเภทสตริงคือลำดับของอักขระ ค่าดังกล่าวระบุเป็นตัวอักษรสตริงที่อยู่ในเครื่องหมายคำพูดเดี่ยวหรือคู่"สายหนึ่ง" "สายอื่น"
ค่าสตริงสามารถแบ่งออกเป็นหลายส่วนได้โดยใช้อักขระแบ็กสแลช
"เอ\สตริง"
บรรทัดอาจมีสิ่งที่เรียกว่า Escape Sequences ซึ่งจะถูกตีความเมื่อบรรทัดถูกส่งออกไปยังคอนโซล ตัวอย่างเช่น ลำดับ \n หมายถึงอักขระขึ้นบรรทัดใหม่ อักขระแบ็กสแลชยังสามารถใช้เพื่อเพิ่มเครื่องหมายคำพูดให้กับสตริงที่อยู่ภายในเครื่องหมายคำพูดเดียวกันได้ การหลีกอักขระเครื่องหมายคำพูดด้วย \ ทำให้ระบบไม่ถือว่าเป็นอักขระพิเศษ
"ฉันเป็นนักพัฒนา"
สามารถต่อสตริงเข้าด้วยกันได้โดยใช้ตัวดำเนินการ +
"เอ" + "สตริง"
ตัวอักษรเทมเพลต ใน ES2015 สิ่งที่เรียกว่าตัวอักษรเทมเพลตหรือสตริงเทมเพลตปรากฏขึ้น เป็นสตริงที่อยู่ใน backquotes (`) และมีคุณสมบัติที่น่าสนใจบางประการ`สตริง`
ตัวอย่างเช่น คุณสามารถแทนที่ค่าบางค่าที่เป็นผลจากการประเมินนิพจน์ JavaScript ให้เป็นค่าตามตัวอักษรของเทมเพลตได้
`สตริงที่มี $(บางสิ่งบางอย่าง)` ``สตริงที่มี $(something+somethingElse)` ` `สตริงที่มี $(obj.something())`
การใช้ backquotes ช่วยให้เขียนตัวอักษรสตริงบนหลายบรรทัดได้ง่ายขึ้น:
`สตริงที่มี $(บางสิ่ง)`
JavaScript ประเภทบูลีนมีคำสงวนคู่หนึ่งที่ใช้เมื่อทำงานกับค่าบูลีน: จริงและเท็จ ตัวดำเนินการเปรียบเทียบ เช่น == , === ,< , >ให้คืนค่าจริงหรือเท็จนิพจน์บูลีนถูกใช้ในคำสั่ง เช่น if และ while เพื่อช่วยควบคุมการไหลของโปรแกรม
ควรสังเกตว่าในกรณีที่คาดหวังค่าจริงหรือเท็จคุณสามารถใช้ค่าอื่นที่ภาษาประเมินโดยอัตโนมัติว่าเป็นจริง (จริง) หรือเท็จ (เท็จ)
โดยเฉพาะอย่างยิ่งค่าต่อไปนี้เป็นค่าเท็จ:
0 -0 NaN ไม่ได้กำหนด null "" // สตริงว่าง
ค่าที่เหลือเป็นจริง
ค่านี้จะถูกส่งกลับโดยอัตโนมัติจากฟังก์ชันที่ไม่ได้ส่งคืนผลลัพธ์อย่างชัดเจนโดยใช้คีย์เวิร์ด return หากฟังก์ชันรับพารามิเตอร์ที่ไม่ได้ระบุเมื่อมีการเรียกใช้ ฟังก์ชันนั้นจะถูกตั้งค่าเป็น undef ด้วย
ในการตรวจสอบค่าของ undef คุณสามารถใช้โครงสร้างต่อไปนี้
ประเภทของตัวแปร === "ไม่ได้กำหนด"
▍วัตถุ ค่าที่ไม่ใช่ค่าพื้นฐานทั้งหมดเป็นประเภทวัตถุ เรากำลังพูดถึงฟังก์ชัน อาร์เรย์ สิ่งที่เราเรียกว่า "วัตถุ" และเอนทิตีอื่นๆ อีกมากมาย ชนิดข้อมูลทั้งหมดนี้ขึ้นอยู่กับประเภทของออบเจ็กต์ และถึงแม้จะแตกต่างกันหลายประการ แต่ก็มีหลายอย่างที่เหมือนกันเช่นกัน นิพจน์ นิพจน์เป็นส่วนของโค้ดที่สามารถประมวลผลและรับค่าที่แน่นอนตามการคำนวณที่ดำเนินการ . นิพจน์ทางคณิตศาสตร์มีหลายประเภท ได้แก่ นิพจน์ทางคณิตศาสตร์ที่ประเมินเป็นตัวเลข1/2 i++ ฉัน -= 2 ฉัน * 2
นิพจน์สตริง ผลลัพธ์ของการประเมินนิพจน์ดังกล่าวคือสตริง"A" + "สตริง" "A" += "สตริง"
นิพจน์หลัก ตัวอักษร ค่าคงที่ และการอ้างอิงถึงตัวระบุจัดอยู่ในหมวดหมู่นี้2 0.02 "บางสิ่ง" จริง เท็จ นี้ //บริบทการดำเนินการ อ้างอิงถึงวัตถุปัจจุบันที่ไม่ได้กำหนด i //โดยที่ i เป็นตัวแปรหรือค่าคงที่
รวมถึงคีย์เวิร์ดและโครงสร้าง JavaScript บางส่วนด้วย
ฟังก์ชันคลาสฟังก์ชัน* //ตัวสร้างผลผลิต //คำสั่งให้หยุดชั่วคราว/ดำเนินการการทำงานของตัวกำเนิดต่อ* //การมอบหมายให้กับตัววนซ้ำหรือฟังก์ชันอะซิงโครนัสตัวสร้างอื่น* //นิพจน์ฟังก์ชันแบบอะซิงโครนัสรออยู่ //การจัดระเบียบที่รอการดำเนินการแบบอะซิงโครนัส ฟังก์ชั่น /รูปแบบ/i //นิพจน์ปกติ ( ) //การจัดกลุ่ม
นิพจน์การเริ่มต้นสำหรับอาร์เรย์และวัตถุ //อาร์เรย์ตัวอักษร () //วัตถุตัวอักษร (a: 1, b: 2) (a: (b: 1)) นิพจน์เชิงตรรกะ นิพจน์เชิงตรรกะใช้ตัวดำเนินการเชิงตรรกะ ผลลัพธ์ของการประเมินคือค่าตรรกะ .เอ && บี อา || ข!ก
นิพจน์การเข้าถึงคุณสมบัติ นิพจน์เหล่านี้ช่วยให้คุณเข้าถึงคุณสมบัติและวิธีการของออบเจ็กต์Object.property // การเรียกคุณสมบัติ (หรือวิธีการ) ของวัตถุ object object["property"]
นิพจน์การสร้างวัตถุ new object() new a(1) new MyRectangle("name", 2, (a: 4)) การประกาศฟังก์ชัน นิพจน์ function() () function(a, b) ( return a * b ) (a, b) => a * b a => a * 2 () => ( return 2 ) การเรียกนิพจน์ นิพจน์ดังกล่าวใช้เพื่อเรียกใช้ฟังก์ชันหรือเมธอดของวัตถุA.x (2) window.resize ()
การทำงานกับวัตถุ เราได้พบวัตถุข้างต้นแล้ว พูดคุยเกี่ยวกับตัวอักษรของวัตถุ การเรียกเมธอดของพวกมัน และการเข้าถึงคุณสมบัติของพวกมัน ที่นี่เราจะพูดถึงออบเจ็กต์โดยละเอียดมากขึ้น โดยเฉพาะอย่างยิ่งเราจะดูกลไกของการสืบทอดต้นแบบและการใช้คีย์เวิร์ดคลาส▍การสืบทอดต้นแบบ JavaScript โดดเด่นท่ามกลางภาษาการเขียนโปรแกรมสมัยใหม่ตรงที่มันรองรับการสืบทอดต้นแบบ . ภาษาเชิงวัตถุส่วนใหญ่ใช้โมเดลการสืบทอดตามคลาสทุกวัตถุ JavaScript มีคุณสมบัติพิเศษ (__proto__) ที่ชี้ไปยังวัตถุอื่นที่เป็นต้นแบบ วัตถุสืบทอดคุณสมบัติและวิธีการของต้นแบบ
สมมติว่าเรามีวัตถุที่สร้างขึ้นโดยใช้วัตถุตามตัวอักษร
รถคอน = ()
หรือเราสร้างวัตถุโดยใช้ตัวสร้างวัตถุ
รถยนต์ Const = วัตถุใหม่ ()
ในกรณีเหล่านี้ ต้นแบบของออบเจ็กต์รถยนต์จะเป็น Object.prototype
หากคุณสร้างอาร์เรย์ที่เป็นวัตถุด้วย ต้นแบบของอาร์เรย์นั้นจะเป็นวัตถุ Array.prototype
รายการ Const = // หรือดังนั้น รายการ const = อาร์เรย์ใหม่ ()
คุณสามารถตรวจสอบได้ดังต่อไปนี้
Car.__proto__ == Object.prototype //true car.__proto__ == new Object().__proto__ //true list.__proto__ == Object.prototype //false list.__proto__ == Array.prototype //true list.__proto__ == อาร์เรย์ใหม่().__proto__ //true
ที่นี่เราใช้คุณสมบัติ __proto__ ซึ่งไม่จำเป็นต้องมีให้สำหรับนักพัฒนา แต่โดยปกติจะสามารถเข้าถึงได้ ควรสังเกตว่าวิธีที่เชื่อถือได้มากขึ้นในการรับต้นแบบของออบเจ็กต์คือการใช้เมธอด getPrototypeOf() ของอ็อบเจ็กต์ Global Object
Object.getPrototypeOf (วัตถุใหม่ ())
คุณสมบัติและวิธีการทั้งหมดของต้นแบบนั้นพร้อมใช้งานสำหรับออบเจ็กต์ที่มีต้นแบบนั้น ตัวอย่างเช่น นี่คือลักษณะของรายการสำหรับอาร์เรย์
คำแนะนำอาร์เรย์
ต้นแบบพื้นฐานสำหรับวัตถุทั้งหมดคือ Object.prototype
Array.prototype.__proto__ == วัตถุ.ต้นแบบ
Object.prototype ไม่มีต้นแบบ
สิ่งที่เราเห็นข้างต้นเป็นตัวอย่างของห่วงโซ่ต้นแบบ
เมื่อคุณพยายามเข้าถึงคุณสมบัติหรือวิธีการของวัตถุ หากวัตถุนั้นไม่มีคุณสมบัติหรือวิธีการดังกล่าว การค้นหาจะดำเนินการในต้นแบบ จากนั้นในต้นแบบของต้นแบบ และต่อๆ ไปจนกว่าจะพบคุณสมบัติที่ต้องการ หรือจนกว่าสายโซ่ของต้นแบบจะไม่สิ้นสุด
นอกเหนือจากการสร้างออบเจ็กต์โดยใช้ตัวดำเนินการใหม่และการใช้ออบเจ็กต์หรือตัวอักษรอาร์เรย์แล้ว คุณสามารถสร้างอินสแตนซ์ของออบเจ็กต์โดยใช้เมธอด Object.create() ได้ อาร์กิวเมนต์แรกที่ส่งผ่านไปยังเมธอดนี้คือออบเจ็กต์ที่จะเป็นแบบอย่างของออบเจ็กต์ที่มันสร้างขึ้น
รถยนต์ Const = Object.create (Object.prototype)
คุณสามารถตรวจสอบว่าวัตถุเป็นส่วนหนึ่งของห่วงโซ่ต้นแบบของวัตถุอื่นหรือไม่โดยใช้เมธอด isPrototypeOf()
รายการ Const = Array.prototype.isPrototypeOf (รายการ)
ฟังก์ชัน Constructor ข้างต้น เราได้สร้างออบเจ็กต์ใหม่โดยใช้ฟังก์ชัน Constructor ที่มีอยู่แล้วในภาษานั้น (คีย์เวิร์ด new จะถูกใช้เมื่อเรียกใช้ฟังก์ชันเหล่านั้น) คุณสามารถสร้างฟังก์ชันดังกล่าวได้ด้วยตัวเอง ลองดูตัวอย่างฟังก์ชั่น Person(name) ( this.name = name ) Person.prototype.hello = function() ( console.log(this.name) ) ให้ person = new Person("Flavio") person.hello() console.log( Person.prototype.isPrototypeOf (บุคคล))
ที่นี่เราสร้างฟังก์ชันคอนสตรัคเตอร์ เมื่อมันถูกเรียก วัตถุใหม่จะถูกสร้างขึ้น โดยชี้ไปที่คีย์เวิร์ดนี้ในเนื้อความของตัวสร้าง เราเพิ่มคุณสมบัติชื่อให้กับวัตถุนี้และเขียนสิ่งที่ถูกส่งผ่านไปยังตัวสร้างลงไป วัตถุนี้จะถูกส่งกลับจากตัวสร้างโดยอัตโนมัติ การใช้ฟังก์ชันคอนสตรัคเตอร์ คุณสามารถสร้างออบเจ็กต์จำนวนมากที่มีคุณสมบัติชื่อซึ่งจะมีสิ่งที่ส่งผ่านไปยังคอนสตรัคเตอร์เมื่อถูกสร้างขึ้น
หลังจากสร้าง Constructor แล้ว เราจะเพิ่มฟังก์ชันให้กับต้นแบบซึ่งจะพิมพ์ค่าของคุณสมบัติ name ของวัตถุที่สร้างขึ้นโดยใช้ฟังก์ชันนี้ไปยังคอนโซล ออบเจ็กต์ทั้งหมดที่สร้างขึ้นโดยใช้ตัวสร้างนี้จะมีต้นแบบเดียวกัน ดังนั้นจึงใช้ฟังก์ชัน hello() เดียวกัน ซึ่งสามารถตรวจสอบได้ง่ายๆ ด้วยการสร้างอ็อบเจ็กต์ประเภท Person อีกอันหนึ่ง และเปรียบเทียบฟังก์ชัน hello() กับฟังก์ชันของอ็อบเจ็กต์ที่มีอยู่ในตัวอย่างอยู่แล้ว (ในกรณีนี้ ชื่อฟังก์ชันจะเขียนโดยไม่มีวงเล็บ)
▍คลาส ในมาตรฐาน ES6 นั้น JavaScript ได้แนะนำแนวคิดของ "คลาส"ก่อนหน้านี้ JavaScript สามารถใช้ได้เฉพาะกลไกการสืบทอดต้นแบบที่อธิบายไว้ข้างต้นเท่านั้น กลไกนี้ดูไม่ปกติสำหรับโปรแกรมเมอร์ที่มาที่ JS จากภาษาอื่น ดังนั้นคลาสจึงปรากฏในภาษาซึ่งโดยพื้นฐานแล้วคือ "น้ำตาลเชิงวากยสัมพันธ์" สำหรับกลไกการสืบทอดต้นแบบ นั่นคือทั้งวัตถุที่สร้างขึ้นในวิธีดั้งเดิมและวัตถุที่สร้างขึ้นโดยใช้คลาสต่างก็มีต้นแบบ
การประกาศชั้นเรียน นี่คือลักษณะการประกาศชั้นเรียนบุคคลในคลาส ( ตัวสร้าง(ชื่อ) ( this.name = name ) สวัสดี() ( กลับ "สวัสดี ฉันชื่อ " + this.name + "." ) )
คลาสมีตัวระบุที่สามารถใช้เพื่อสร้างวัตถุใหม่โดยใช้โครงสร้าง ClassIdentifier() ใหม่
เมื่อสร้างอ็อบเจ็กต์ใหม่ เมธอด Constructor จะถูกเรียกและพารามิเตอร์จะถูกส่งผ่านไป
คุณสามารถประกาศวิธีการในชั้นเรียนได้ ในกรณีของเรา hello() เป็นวิธีการที่สามารถเรียกได้โดยวัตถุทั้งหมดที่สร้างขึ้นตามคลาส นี่คือลักษณะการสร้างวัตถุใหม่โดยใช้คลาส Person
Const flavio = บุคคลใหม่ ("Flavio") flavio.hello()
Class-Based Inheritance Classes สามารถขยายคลาสอื่นๆ ได้ วัตถุที่สร้างจากคลาสดังกล่าวจะสืบทอดทั้งวิธีการของคลาสดั้งเดิมและวิธีการที่ระบุในคลาสขยายหากคลาสที่ขยายคลาสอื่น (คลาสย่อยของคลาสนั้น) มีเมธอดที่มีชื่อเหมือนกับคลาสพาเรนต์ วิธีการนั้นจะมีลำดับความสำคัญมากกว่าคลาสดั้งเดิม
โปรแกรมเมอร์คลาสขยาย Person ( hello() ( return super.hello() + " ฉันเป็นโปรแกรมเมอร์" ) ) const flavio = new Programmer("Flavio") flavio.hello()
การเรียกเมธอด hello() ในตัวอย่างด้านบนจะส่งคืนสตริง Hello, I am Flavio ฉันเป็นโปรแกรมเมอร์
คลาสไม่ได้จัดให้มีตัวแปร (คุณสมบัติ) จะต้องกำหนดค่าคุณสมบัติของอ็อบเจ็กต์ที่สร้างขึ้นโดยใช้คลาสในตัวสร้าง
ภายในชั้นเรียน คุณสามารถเข้าถึงคลาสหลักได้โดยใช้คีย์เวิร์ด super
วิธีการแบบคงที่ วิธีการอธิบายในชั้นเรียนสามารถเรียกได้โดยการเข้าถึงวัตถุที่สร้างจากชั้นเรียน แต่ไม่ใช่โดยการเข้าถึงชั้นเรียนเอง วิธีการแบบคงที่สามารถเรียกได้โดยการเข้าถึงชั้นเรียนโดยตรง วิธีการส่วนตัว JavaScript ไม่มีกลไกในตัวที่ช่วยให้คุณสามารถประกาศวิธีการส่วนตัวได้ ข้อจำกัดนี้สามารถหลีกเลี่ยงได้ เช่น โดยใช้การปิด Getters และ setters คุณสามารถกำหนดวิธีการในคลาสโดยนำหน้าด้วยคีย์เวิร์ด get หรือ set สิ่งนี้ช่วยให้คุณสร้างสิ่งที่เรียกว่า getters และ setters ซึ่งเป็นฟังก์ชันที่ใช้ในการควบคุมการเข้าถึงคุณสมบัติของอ็อบเจ็กต์ที่สร้างขึ้นตามคลาส getter จะถูกเรียกเมื่อคุณพยายามอ่านค่าของคุณสมบัติหลอก และ setter จะถูกเรียกเมื่อคุณพยายามเขียนค่าใหม่ลงไปบุคคลในคลาส ( ตัวสร้าง(ชื่อ) ( this.userName = name ) ชื่อชุด(ค่า) ( this.userName = value ) รับชื่อ() ( return this.userName ) )
สรุป ในเนื้อหานี้ เราได้พูดคุยเกี่ยวกับตัวแปร ชนิดข้อมูล นิพจน์ และการทำงานกับออบเจ็กต์ใน JavaScript หัวข้อของเนื้อหาถัดไปของเราคือฟังก์ชันเรียนผู้อ่าน!
ตัวแปรคือตำแหน่งหน่วยความจำที่มีชื่อซึ่งคุณสามารถเก็บข้อมูลบางส่วนและดึงข้อมูลออกมาได้
การประกาศตัวแปร (การสร้าง) ทำได้โดยใช้คีย์เวิร์ด var
// ข้อความ - ชื่อตัวแปร var ข้อความ;
เมื่อคุณสร้างตัวแปร คุณสามารถกำหนดค่าให้กับตัวแปรนั้นได้ทันที
การกำหนดค่าให้กับตัวแปรทำได้โดยใช้ตัวดำเนินการ “=”
// เช่น สร้างตัวแปรอีเมลและกำหนดสตริงให้กับมัน " [ป้องกันอีเมล]"อีเมล var = " [ป้องกันอีเมล]"; // ตั้งค่าตัวแปรอีเมลเป็นค่าใหม่ email = " [ป้องกันอีเมล]";
หากต้องการรับค่าของตัวแปร เพียงอ้างอิงชื่อตัวแปร
// ตัวอย่างเช่น ส่งออกค่าของตัวแปรอีเมลไปยังคอนโซลของเบราว์เซอร์: console.log(email);
หากต้องการประกาศตัวแปรมากกว่าหนึ่งตัวแปรโดยใช้คีย์เวิร์ด var เดียว คุณต้องใช้เครื่องหมายจุลภาค
ราคา Var = 78.55 ปริมาณ = 10 ข้อความ;
JavaScript เป็นภาษาที่พิมพ์แบบไดนามิกหรืออ่อนแอ
ซึ่งหมายความว่าเมื่อมีการประกาศตัวแปร ไม่จำเป็นต้องระบุประเภทข้อมูลที่ยอมรับได้ ดังนั้น ขั้นแรกคุณสามารถใส่ค่าของประเภทข้อมูลหนึ่งลงในตัวแปร แล้วตามด้วยอีกประเภทหนึ่งได้
เอาท์พุท Var = "ความสำเร็จ"; // ตัวแปรมีชนิดข้อมูลสตริงเอาต์พุต = 28; // ตัวแปรเดียวกัน แต่เป็นประเภทข้อมูล "ตัวเลข" แล้ว เอาต์พุต = จริง; // ตัวแปรเดียวกันแต่เก็บค่าบูลีนไว้แล้ว
ค่าของตัวแปรสามารถเปลี่ยนแปลงได้ไม่จำกัดจำนวนครั้ง
// สร้างตัวแปรอายุ var age; // อายุตัวแปรถูกกำหนดให้เป็นค่า 67 อายุ = 67; // อายุตัวแปรถูกตั้งค่าเป็น "อายุเกษียณ" age = "อายุเกษียณ"; // อายุตัวแปรตั้งไว้ที่ 55 age = 55;
แนวปฏิบัติที่ดีในการพัฒนาแอปพลิเคชันไคลเอนต์คือการใช้ประเภทข้อมูลเพียงประเภทเดียวในตัวแปรที่กำหนด เช่น อย่าเขียนค่าของข้อมูลประเภทต่างๆ ลงในตัวแปร เพื่อให้เข้าใจว่าควรคาดหวังข้อมูลประเภทใดในตัวแปร เมื่อสร้างตัวแปร ขอแนะนำให้เริ่มต้นด้วยค่าเฉพาะทันที
ชื่อตัวแปรสามารถประกอบด้วยตัวอักษร ตัวเลข และสัญลักษณ์ $ และ _ ในกรณีนี้ อักขระตัวแรกของตัวแปรต้องไม่ใช่ตัวเลข นอกจากนี้ คุณไม่สามารถใช้คำสงวนเป็นชื่อตัวแปรได้
กรณีของตัวอักษรในชื่อตัวแปรมีความสำคัญ ตัวอย่างเช่น โทรศัพท์ที่แปรผันและโทรศัพท์เป็นตัวแปรสองตัวที่แตกต่างกัน
หากไม่ได้ใช้โหมดเข้มงวด คุณสามารถสร้างตัวแปรด้วยค่าเริ่มต้นโดยไม่ต้องใช้คีย์เวิร์ด var
ราคา = 250.00; // สร้างตัวแปรและกำหนดค่าเริ่มต้นด้วยตัวเลข 250.00 เปอร์เซ็นต์ = "20%"; // สร้างตัวแปรและเริ่มต้นด้วยสตริง “20%”
แต่ไม่แนะนำให้สร้างตัวแปรในลักษณะนี้
ประเภทข้อมูลใน JavaScript ชนิดข้อมูลสามารถแบ่งออกเป็นแบบดั้งเดิมและวัตถุ
ตัวแปรที่มีชนิดข้อมูลดั้งเดิมจะเก็บค่าไว้อย่างชัดเจน
มี 5 ประเภทข้อมูลดั้งเดิมใน JavaScript:
- ตัวเลข;
- เชือก;
- ประเภทบูลีน (บูลีน);
- โมฆะ;
- ไม่ได้กำหนด
หากมีการกำหนดค่าให้กับตัวแปรตัวหนึ่งซึ่งมีชนิดข้อมูลพื้นฐาน ตัวแปรนั้นจะได้รับสำเนาของค่านั้นเอง
วาร์ x = 77, y = x; x = 55; ใช่; // 77
ตัวแปรที่มีอ็อบเจ็กต์ไม่ได้เก็บอ็อบเจ็กต์ไว้จริงๆ แต่เป็นการอ้างอิงถึงอ็อบเจ็กต์นั้น
หากตัวแปรตัวหนึ่งได้รับการกำหนดค่าให้กับอีกตัวแปรหนึ่งที่มีออบเจ็กต์ (ลิงก์ไปยังตัวแปรนั้น) ตัวแปรนั้นก็จะได้รับลิงก์ไปยังตัวแปรนั้นด้วย จากการดำเนินการนี้ ตัวแปรทั้งสองนี้จะมีการอ้างอิงไปยังออบเจ็กต์เดียวกัน
// ตัวอย่างที่ 1 (พร้อมประเภทข้อมูล "วัตถุ") var coord1 = (x: 77, y: 100), coord2 = coord1; coord1.x = 55; // ตั้งค่าคุณสมบัติ x ของวัตถุเป็นค่าใหม่ coord2.x; // 55 เพราะว่า coord1 และ coord2 มีการอ้างอิงถึงวัตถุเดียวกัน // ตัวอย่าง 2 (ที่มีชนิดข้อมูลอาร์เรย์) var coord1 = , coord2 = coord1; พิกัด1 = 55; // ตั้งค่าองค์ประกอบด้วยดัชนี 0 เป็นค่าใหม่ coord2; // 55 เพราะว่า coord1 และ coord2 มีการอ้างอิงถึงวัตถุเดียวกัน // ตัวอย่าง 3 (ที่มีประเภทข้อมูล "date") var date1 = new Date(2018,00,01), date2 = date1; date2 = date2.setDate(date2.getDate()+7); // เพิ่มวันที่ 7 วัน date1; // 01/07/2018 เพราะ date1 และ date2 มีการอ้างอิงถึงวัตถุเดียวกัน
ตัวเลขประเภทข้อมูลตัวเลขใน JavaScript เป็นแบบทั่วไป ใช้เพื่อแสดงทั้งจำนวนเต็มและเศษส่วน
ตัวแปร int = 5; // จำนวนเต็ม var float = 5.98; // จำนวนเศษส่วน
รูปแบบการแสดงตัวเลขใน JavaScript เป็นไปตามมาตรฐาน IEEE 754-2008
จำนวนเต็มใน JavaScript สามารถระบุได้ไม่เพียงแต่เป็นทศนิยมเท่านั้น แต่ยังระบุเป็นฐานแปด (0) หรือเลขฐานสิบหก (0x) ได้โดยใช้คำนำหน้าที่ระบุในวงเล็บ:
ตัวแปร int = 010; // 8 int = 055; // 45 int = 0xFF; //255 int = 0xB8; // 184
สามารถเขียนตัวเลขในรูปแบบเลขชี้กำลังได้:
วาร์ นัม = 2e3; // สัญกรณ์เลขชี้กำลังของตัวเลข 2*10^3 (2000) num = 2e-3; // สัญลักษณ์เอ็กซ์โปเนนเชียลของตัวเลข 2*10^-3 (0.002) num = 3.2e3; // 3200 หมายเลข = 1.5e-2; // 0.015
นอกจากตัวเลขแล้ว ชนิดข้อมูลตัวเลขยังมีค่าตัวเลขพิเศษอีกด้วย:
- อนันต์ (บวกอนันต์);
- -อินฟินิตี้ (อินฟินิตี้เชิงลบ);
- น่าน (ไม่ใช่ตัวเลข)
ค่าพิเศษ อินฟินิตี้ หมายถึงจำนวนบวกที่มีขนาดใหญ่มาก เช่น ตัวเลขที่ไม่สามารถแสดงใน JavaScript ได้เนื่องจากมีขนาดใหญ่เกินไป
ความหมายพิเศษ -อินฟินิตี้ หมายถึงจำนวนลบที่มีขนาดใหญ่มาก ในทางกลับกัน เช่น ตัวเลขที่ไม่สามารถแสดงด้วย JavaScript ได้เนื่องจากมีขนาดใหญ่เกินไป
ตัวอย่างของนิพจน์ที่จะส่งคืนค่าตัวเลขพิเศษอันเป็นผลมาจากการคำนวณ:
5/0; // อนันต์ -5/0; // -Infinity Math.pow (10,399); // อนันต์ (10 ยกกำลัง 399) Math.pow(10,399); // -อนันต์ (-10 ยกกำลัง 399)
ค่า NaN จะถูกส่งกลับอันเป็นผลมาจากการดำเนินการทางคณิตศาสตร์ที่ JavaScript ไม่สามารถคำนวณได้
5 - "สวัสดี"; // NaN (ลบบรรทัดออกจากหมายเลข 5) 1,000 / "20px"; // NaN (ตัวเลขหารด้วยสตริง) true * "1rem"; // NaN (ค่าบูลีนจริงคูณด้วยสตริง)
สิ่งที่น่าสนใจมากคือค่าของ NaN ใน JavaScript ไม่เท่ากับสิ่งใดๆ แม้แต่ตัวมันเองด้วย
น่าน == น่าน; // น่านเท็จ === น่าน; //เท็จ
ชนิดข้อมูลบูลีนBoolean เป็นชนิดข้อมูลดั้งเดิมที่มีค่าเพียงสองค่า: จริงและเท็จ
วาร์ ก = จริง; วาร์ ข = เท็จ;
สตริงสตริงเป็นชนิดข้อมูลที่ใช้ใน JavaScript เพื่อแสดงข้อความ
สตริง JavaScript สามารถมีความยาวได้ตั้งแต่ 0 อักขระขึ้นไป
JavaScript จะใช้ Unicode เป็นรูปแบบสตริงเสมอ
การสร้างสตริง (ตัวอักษรสตริง) ทำได้โดยการใส่ข้อความด้วยเครื่องหมายคำพูดเดี่ยวหรือคู่
"จาวาสคริปต์"; "ECMAScript";
ใน JavaScript ไม่มีความแตกต่างระหว่างเครื่องหมายคำพูดเดี่ยวและคู่
แต่ในบางกรณี การใช้เครื่องหมายคำพูดเดี่ยวมากกว่าการใช้เครื่องหมายคำพูดคู่และในทางกลับกันก็สมเหตุสมผล
ตัวอย่างเช่น เมื่อสตริงมีเครื่องหมายคำพูดคู่ จะสะดวกกว่าหากใส่ไว้ในเครื่องหมายคำพูดเดี่ยว วิธีนี้จะขจัดความจำเป็นในการหลีกเลี่ยงเครื่องหมายคำพูดคู่ในนั้น
""ECMAScript""; // ไม่มีการหลบหนี (ใช้เครื่องหมายคำพูดเดี่ยว) "\"ECMAScript\""; //พร้อมกับหลบหนี
สตริงใน JavaScript สามารถมีอักขระพิเศษได้ ตัวอย่างเช่น \n (การป้อนบรรทัด), \t (แท็บ), \r (การขึ้นบรรทัดใหม่) เป็นต้น
"นี่คือประโยค\nและนี่ก็เป็นประโยคด้วย แต่จะเริ่มจากบรรทัดใหม่";
ด้วยสตริง คุณสามารถดำเนินการบวก (ยูเนียน) หรืออีกนัยหนึ่งคือการต่อข้อมูลได้ ตัวดำเนินการ "+" ใช้สำหรับสิ่งนี้ ความหมายของการดำเนินการนี้คือการผนวกบรรทัดที่สองต่อท้ายบรรทัดแรก
"ฉันรัก" + "จาวาสคริปต์"; // ฉันชอบจาวาสคริปต์
ค่าคือ "ไม่ได้กำหนด"undefinition เป็นชนิดข้อมูลดั้งเดิมพิเศษที่มีค่าเดียวเท่ากับ undefinition
ชนิดข้อมูลนี้มีตัวแปรที่ประกาศซึ่งยังไม่ได้กำหนดค่า
วาร์นัม; // ไม่ได้กำหนด
ค่าที่ไม่ได้กำหนดจะถูกส่งกลับเมื่อเข้าถึงคุณสมบัติที่ไม่มีอยู่จริงของวัตถุ
วาร์ obj = (); // วัตถุว่าง obj.prop; // ไม่ได้กำหนด
ค่า "โมฆะ"null เป็นชนิดข้อมูลดั้งเดิมพิเศษที่มีค่าเดียวเท่ากับ null
null เป็นเพียงค่าพิเศษที่มีความหมายว่า "ไม่มีอะไร" หรือ "ค่าที่ไม่รู้จัก" เช่น เห็นได้ชัดว่ามันไม่ได้มีความหมายอะไรเลย
วัตถุวัตถุคือโครงสร้างข้อมูลที่ประกอบด้วยคู่ชื่อ-ค่า
การสร้างวัตถุโดยใช้สัญกรณ์ตามตัวอักษรของวัตถุทำได้ดังนี้:
( name_1: value_1, name_2: value_2, name_3: value_3, ... )
อย่างที่คุณเห็น ชื่อจะถูกแยกออกจากค่าโดยใช้เครื่องหมายทวิภาค และคู่จะถูกแยกออกจากกันโดยใช้เครื่องหมายจุลภาค
ยิ่งไปกว่านั้น หากค่าของคู่นั้นเป็นฟังก์ชัน ก็จะเรียกว่าเมธอดของอ็อบเจ็กต์นี้ คู่อื่นๆ ทั้งหมด เช่น คู่ที่ไม่ได้ใช้ฟังก์ชันเป็นค่าเรียกว่าคุณสมบัติของวัตถุ
กล่าวอีกนัยหนึ่ง วัตถุคือโครงสร้างข้อมูลที่ประกอบด้วยคุณสมบัติและวิธีการ
บุคคล Var = ( ชื่อ: "Vitaly", อายุ: 27, getAge: function () ( return "Age: " + this.age; ) )
การเข้าถึงคุณสมบัติของออบเจ็กต์ทำได้โดยใช้จุดหรือเครื่องหมายวงเล็บเหลี่ยม
// แสดงค่าของคุณสมบัติอายุในคอนโซลของเบราว์เซอร์ // วิธีที่ 1 (ผ่านจุด) console.log(person.age); // วิธีที่ 2 (ใช้วงเล็บ) console.log(person["age"]); // เรียกเมธอด getAge; ค่าที่ส่งคืนจะถูกส่งออกไปยังคอนโซล console.log(person.getAge());
ประเภทของตัวดำเนินการตัวดำเนินการ typeof ใช้เพื่อรับข้อมูลเกี่ยวกับชนิดข้อมูลของนิพจน์ในรูปแบบสตริง
ไวยากรณ์ของตัวดำเนินการ typeof (ตัวเลือกที่ไม่มีวงเล็บ):
ประเภทของการแสดงออก
ประเภทของไวยากรณ์ตัวดำเนินการ (ใช้วงเล็บ):
ประเภทของ(การแสดงออก)
ชื่อวาร์ อายุ = 37 อีเมล = " [ป้องกันอีเมล]", isLicense = true, ดอกเบี้ย: null, LastExperience: ( ระยะเวลา: "มิถุนายน 2554 - มิถุนายน 2561", สถานที่: "ISACA, มอสโก", ตำแหน่ง: "นักออกแบบเว็บไซต์" ), getExperience: function() ( ส่งคืน LastExperience. period + " ("+ LastExperience.position + " - " + LastExperience.place + ")" ; ประเภทของชื่อ; // "หมายเลข" ของความสนใจ; / "วัตถุ" (1) ประเภทของประสบการณ์สุดท้าย; // "วัตถุ" ของ getExperience; / "function" (2) /* (1) - นี่เป็นข้อผิดพลาดที่มีอยู่ในภาษาตั้งแต่การใช้งานครั้งแรก เพื่อรักษาความเข้ากันได้และจะต้องนำมาพิจารณาเมื่อเขียนสคริปต์เป็นข้อมูลดั้งเดิม type ไม่ใช่วัตถุ */ /* (2) - สะดวกมากที่ตัวดำเนินการ typeof แยกฟังก์ชันออกจากกัน แต่ฟังก์ชันใน JavaScipt ก็เป็นฟังก์ชันเช่นกัน ซึ่งสามารถตรวจสอบได้อย่างง่ายดายโดยดำเนินการก่อสร้างต่อไปนี้: */ typeof getExperience.__proto__.__proto__ // "object" (ฟังก์ชันต้นแบบคืออ็อบเจ็กต์)
ค่าคงที่ด้วยการเปิดตัว ECMAScript 6 ทำให้สามารถสร้างค่าคงที่ได้ ทำได้โดยใช้คีย์เวิร์ด const
ค่าสี COLOR_RED = "#ff0000";
ค่าคงที่คือตัวแปรที่มีค่าที่ได้รับการปกป้องจากการเปลี่ยนแปลง เหล่านั้น. เมื่อคุณพยายามเปลี่ยนค่า ข้อผิดพลาดจะเกิดขึ้น
ค่าสี COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Uncaught TypeError: การกำหนดให้กับตัวแปรคงที่
ตัวอย่างเช่น หากค่าคงที่มีวัตถุอยู่ ก็ไม่สามารถเปลี่ยนแปลงได้ หรือเป็นการอ้างอิงถึงวัตถุนั้นแทน แต่คุณสมบัติของวัตถุนี้สามารถเปลี่ยนแปลงได้
Const COLORS = ( สีแดง: "#ff0000", สีเขียว: "#00ff00", สีน้ำเงิน: "" "00ff00" ) COLORS = ["#ff0000", "#00ff00", "#00ff00"]; // Uncaught TypeError: การกำหนดให้กับตัวแปรคงที่ COLORS.green = "#4caf50";
หากคุณเขียนด้วย JS มาเป็นเวลานาน โปรดบอกเราว่าคุณรู้สึกอย่างไรเกี่ยวกับการปรากฏตัวของคีย์เวิร์ด class ในภาษานั้นๆ
ชนิดข้อมูลช่วยสร้างการจำแนกประเภทของข้อมูลในภาษาการเขียนโปรแกรม ตัวอย่างเช่น ตัวเลขและสตริงอักขระเป็นข้อมูลประเภทต่างๆ ที่ JavaScript จะปฏิบัติต่างกัน
นี่เป็นสิ่งสำคัญเนื่องจากข้อมูลแต่ละประเภทสามารถรับค่าเฉพาะและดำเนินการเฉพาะได้ เพื่อให้สามารถดำเนินการกับตัวแปรใน JavaScript ได้ สิ่งสำคัญคือต้องเข้าใจประเภทข้อมูลของตัวแปรแต่ละตัวที่กำหนด
บทช่วยสอนนี้จะแนะนำคุณเกี่ยวกับประเภทข้อมูล JavaScript
หมายเหตุ: ข้อมูลในคู่มือนี้ไม่ได้ครอบคลุมทั้งหมด แต่จะให้ภาพรวมของตัวเลือก JavaScript พื้นฐานการพิมพ์แบบไดนามิก
JavaScript เป็นภาษาแบบไดนามิก ซึ่งหมายความว่าการตรวจสอบชนิดข้อมูลเสร็จสิ้น ณ รันไทม์ ไม่ใช่ในเวลาคอมไพล์
ในภาษาไดนามิก ตัวแปรที่มีชื่อเดียวกันสามารถใช้เพื่อจัดเก็บข้อมูลประเภทต่างๆ ได้
ตัวอย่างเช่น ตัวแปร t ที่กำหนดโดยคีย์เวิร์ด var สามารถจัดเก็บข้อมูลประเภทต่างๆ ได้ มันสามารถเริ่มต้นได้ แต่ไม่ได้กำหนดไว้:
วาร์ เสื้อ = 16; // t คือตัวเลข
var t = "เทเรซา"; // t คือสตริง
var t = จริง; // t คือบูลีน
ตัวแปร t ทั้งหมดมีประเภทข้อมูล JavaScript ที่แตกต่างกัน ใน JavaScript คุณไม่จำเป็นต้องระบุประเภทข้อมูลของตัวแปรอย่างชัดเจนก่อนที่จะใช้งาน
ตัวเลขJavaScript มีข้อมูลประเภทตัวเลขเพียงประเภทเดียว โดยไม่แยกความแตกต่างระหว่างจำนวนเต็มและจำนวนจุดลอยตัว ดังนั้น ตัวเลขใน JavaScript สามารถเขียนโดยมีหรือไม่มีตำแหน่งทศนิยมก็ได้:
วาร์ num1 = 93;
วาร์ num2 = 93.00;
ในตัวอย่างข้างต้น ตัวแปรทั้งสองมีตัวเลข ไม่ว่าจะมีเครื่องหมายจุลภาคอยู่หรือไม่ก็ตาม
สัญกรณ์วิทยาศาสตร์ใน JavaScript ช่วยให้คุณสามารถย่อตัวเลขที่มากหรือน้อยได้:
วาร์ num3 = 987e8; // 98700000000
วาร์ num4 = 987e-8; // 0.00000987
ใน JavaScript ตัวเลขจะถือว่าแม่นยำถึง 15 หลัก หมายความว่าเมื่อถึงหลักที่ 16 แล้ว ตัวเลขจะถูกปัดเศษ:
var num5 = 999999999999999; // ยังคงเป็น 999999999999999
วาร์ num6 = 9999999999999999; // ปัดเศษขึ้นเป็น 10000000000000000
นอกจากนี้ ตัวเลขใน JavaScript ยังมีความหมายเชิงสัญลักษณ์สามประการ:
อนันต์คือค่าตัวเลขที่แสดงถึงจำนวนบวกที่เข้าใกล้อนันต์
อนันต์คือค่าตัวเลขที่แสดงถึงจำนวนลบที่เข้าใกล้อนันต์
NaN – ไม่ใช่ตัวเลข ซึ่งเป็นสถานะพิเศษของจำนวนจุดลอยตัว
ค่าอนันต์และค่าอนันต์จะถูกส่งกลับเมื่อนับจำนวนที่เกินจำนวนสูงสุดที่เป็นไปได้ใน JavaScript นอกจากนี้ยังปรากฏขึ้นเมื่อนับค่าที่ไม่ได้กำหนด เช่น การหารด้วยศูนย์:
var num7 = 5/0; //อินฟินิตี้
วาร์ num8 = -5 / 0; // -อินฟินิตี้
ในทางเทคนิคแล้ว ค่าอนันต์จะถูกส่งกลับหากตัวเลขมากกว่า 1.797693134862315E+308 ซึ่งเป็นขีดจำกัดบนใน JavaScript
ในทำนองเดียวกัน -Infinity จะแสดงเมื่อตัวเลขเกินขีดจำกัดล่าง -1.797693134862316E+308
สามารถใช้หมายเลขอินฟินิตี้แบบวนซ้ำได้:
ในขณะที่ (num9 != อนันต์) (
// โค้ดที่นี่จะดำเนินการผ่าน num9 = Infinity
}
สำหรับตัวเลขที่ไม่ได้กำหนด ระบบจะพิมพ์ NaN หากคุณพยายามดำเนินการทางคณิตศาสตร์กับตัวเลขและค่าที่ไม่ใช่ตัวเลข คุณจะได้ NaN ตัวอย่างเช่น:
var x = 20 / "ฉลาม"; // x จะเป็น NaN
เนื่องจาก 20 ไม่สามารถหารด้วยสตริง Shark ได้ ค่าของ x จึงเป็น NaN
อย่างไรก็ตาม หากสามารถประเมินสตริงเป็นค่าตัวเลขได้ JavaScript จะประเมินนิพจน์ทางคณิตศาสตร์:
var y = 20 / "5"; // y จะเป็น 4
เนื่องจาก JavaScript สามารถถือว่า 5 เป็นค่าตัวเลขได้ 5 จึงทำงานร่วมกับตัวดำเนินการหารทางคณิตศาสตร์ได้
หากตัวแปรตัวหนึ่งในนิพจน์ถูกตั้งค่าเป็น NaN ผลลัพธ์จะเป็น NaN แม้ว่าตัวถูกดำเนินการตัวที่สองจะเป็นตัวเลขก็ตาม
var a = น่าน;
วาร์ ข = 37;
var c = a + b; // c จะเป็น NaN
ดังนั้นใน JavaScript จะมีประเภทข้อมูลตัวเลขเพียงประเภทเดียวเท่านั้น ใน JavaScript ไม่จำเป็นต้องแยกตัวเลขออกเป็นจำนวนเต็มและตัวเลขทศนิยมเนื่องจาก JavaScript เป็นภาษาไดนามิก
สตริงสตริงคือลำดับของอักขระตั้งแต่หนึ่งตัวขึ้นไป (ตัวอักษร ตัวเลข และสัญลักษณ์อื่นๆ) สตริงแสดงถึงข้อมูลข้อความ
ใน JavaScript สตริงมีทั้งเครื่องหมายคำพูดเดี่ยวและคู่ หากต้องการสร้างสตริง คุณต้องใส่ลำดับอักขระในเครื่องหมายคำพูด:
var singleQuotes = "นี่คือสตริงในเครื่องหมายคำพูดเดี่ยว";
var doubleQuotes = "นี่คือสตริงในเครื่องหมายคำพูดคู่";
คุณสามารถใช้เครื่องหมายคำพูดเดี่ยวหรือคู่ได้ แต่คุณต้องใช้เครื่องหมายคำพูดประเภทเดียวอย่างสม่ำเสมอภายในโค้ดเดียวกัน
โปรแกรม "สวัสดีชาวโลก!" สาธิตวิธีใช้สตริงในการเขียนโปรแกรมคอมพิวเตอร์ โดยพื้นฐานแล้ว ในตัวอย่างนี้ สตริงคือลำดับของอักขระที่ประกอบขึ้นเป็นวลี “Hello, World!” ในการแจ้งเตือน ()
ฟังก์ชั่น helloFunction() (
alert("สวัสดีชาวโลก!");
}
คลิกฉัน
เมื่อรันโค้ดแล้วคลิกปุ่มคลิกฉัน คุณจะเห็นหน้าต่างป๊อปอัปพร้อมข้อความ:
เช่นเดียวกับข้อมูลประเภทอื่นๆ สตริงสามารถจัดเก็บไว้ในตัวแปรได้
var hw = "สวัสดีชาวโลก!";
จากนั้นคุณสามารถแสดงสตริงโดยการเรียกตัวแปร:
...
var hw = "สวัสดีชาวโลก!";
ฟังก์ชั่น helloFunction() (
การแจ้งเตือน(hw);
}
...
สวัสดีชาวโลก!
สตริงอนุญาตให้ส่งข้อมูลไปยังผู้ใช้และกลับไปยังโปรแกรม
ชนิดข้อมูลบูลีนประเภทข้อมูลบูลีน (หรือบูลีน) ประกอบด้วยค่าสองค่า - จริงและเท็จ
ประเภทนี้ใช้เพื่อแสดงค่าความจริงที่เกี่ยวข้องกับตรรกะและอัลกอริทึมในวิทยาการคอมพิวเตอร์
หมายเหตุ: ชนิดข้อมูลนี้ตั้งชื่อตามนักคณิตศาสตร์ George Boole
การดำเนินการทางคณิตศาสตร์หลายอย่างให้ผลลัพธ์ที่สามารถประเมินได้ว่าเป็นจริงหรือเท็จ:
มากกว่า:
- 500 > 100 จริง
- 1 > 5 เท็จ
น้อยกว่า:
- 200 < 400 true
- 4 < 2 false
- 5 = 5 จริง
- 500 = 400 เท็จ
เช่นเดียวกับประเภทอื่นๆ ชนิดข้อมูลบูลีนสามารถจัดเก็บไว้ในตัวแปรได้
var myBool = 5 > 8; // เท็จ
เนื่องจาก 5 ไม่มากกว่า 8 myBool จึงเป็นเท็จ
เมื่อคุณเขียนโค้ดใน JavaScript คุณจะคุ้นเคยกับวิธีการทำงานของข้อมูลบูลีน และฟังก์ชันและการดำเนินการประเมินความจริงต่างๆ ที่สามารถเปลี่ยนโฟลว์ของโปรแกรมได้อย่างไร
อาร์เรย์อาร์เรย์สามารถประกอบด้วยค่าหลายค่าภายในตัวแปรเดียว ซึ่งหมายความว่าคุณสามารถจัดเก็บรายการค่าภายในอาร์เรย์และวนซ้ำได้
แต่ละค่าภายในอาร์เรย์เรียกว่าองค์ประกอบ คุณสามารถเข้าถึงองค์ประกอบของอาร์เรย์โดยใช้ดัชนี
อาร์เรย์ถูกกำหนดโดยวงเล็บเหลี่ยม
อาร์เรย์สตริงมีลักษณะดังนี้:
var fish = ["ฉลาม", "ปลาหมึก", "ปลาการ์ตูน", "ปลาไหล"];
โดยการเรียกตัวแปร fish คุณจะได้ผลลัพธ์:
["ฉลาม", "ปลาหมึก", "ปลาการ์ตูน", "ปลาไหล"]
อาร์เรย์เป็นประเภทข้อมูลที่ยืดหยุ่นมากเนื่องจากไม่แน่นอน: คุณสามารถเพิ่ม ลบ และเปลี่ยนค่าขององค์ประกอบได้
วัตถุออบเจ็กต์ใน JavaScript ประกอบด้วยคู่คีย์:ค่า
ไวยากรณ์ของวัตถุประกอบด้วยคู่คีย์:ค่า วัตถุถูกคั่นด้วยเครื่องหมายปีกกาทั้งสองด้าน (())
คู่ในวัตถุถูกคั่นด้วยช่องว่าง:
var sammy = (ชื่อ:"เก่ง", นามสกุล:"ฉลาม", สี:"น้ำเงิน", ที่ตั้ง:"มหาสมุทร");
วัตถุยังสามารถเขียนได้หลายบรรทัด (โดยเฉพาะอย่างยิ่งสำหรับวัตถุขนาดใหญ่)
วาร์เก่ง = (
ชื่อจริง: "วอลลี่",
นามสกุล: "ฉลาม",
สี: "สีฟ้า",
สถานที่: "มหาสมุทร"
};
ทุกโปรแกรมที่คุณสร้างอาจมีข้อมูลหลายประเภท แต่โดยทั่วไปการดำเนินการจะดำเนินการกับข้อมูลประเภทเดียว คณิตศาสตร์ใช้กับตัวเลข และการแบ่งส่วนใช้กับสตริง
ด้วยการใช้ตัวดำเนินการที่ทำงานกับข้อมูลทุกประเภท (เช่น ตัวดำเนินการ + สามารถเพิ่มตัวเลขหรือดำเนินการต่อสตริง) คุณจะได้รับผลลัพธ์ที่ไม่คาดคิด
หากคุณสร้างตัวแปรสำหรับการต่อข้อมูล JavaScript จะตีความแต่ละองค์ประกอบเป็นสตริง
var o = "มหาสมุทร" + 5 + 3;
โดยการเรียกตัวแปร o คุณจะได้ผลลัพธ์ดังต่อไปนี้:
อย่างไรก็ตาม หากสตริงมีตัวเลขก่อนแล้วตามด้วยสตริง ตัวดำเนินการ + จะดำเนินการบวกแล้วต่อข้อมูล:
var p = 5 + 3 + "มหาสมุทร";
8มหาสมุทร
เนื่องจากผลลัพธ์ไม่สามารถคาดเดาได้ จึงสะดวกกว่าในการดำเนินการและวิธีการในประเภทข้อมูลเดียว อย่างไรก็ตาม JavaScript จะไม่ส่งคืนข้อผิดพลาดเมื่อผสมประเภทข้อมูล เช่นเดียวกับภาษาโปรแกรมอื่น ๆ
บทสรุปตอนนี้คุณคุ้นเคยกับประเภทข้อมูล JavaScript แล้ว แต่ละประเภทที่แสดงไว้ที่นี่มีความสำคัญเมื่อเขียนโปรแกรม JavaScript
แท็ก:ในบทช่วยสอนนี้ เราจะแนะนำแนวคิดที่สำคัญมาก - ประเภทข้อมูล JavaScript เราขอแนะนำให้คุณใส่ใจกับแนวคิดนี้อย่างใกล้ชิด - หากคุณไม่เข้าใจตั้งแต่แรกเริ่ม คุณมักจะต้องจัดการกับพฤติกรรมแปลกๆ ของโปรแกรมที่คุณสร้างขึ้น
หมายเหตุ: ข้อมูลในคู่มือนี้ไม่ได้ครอบคลุมทั้งหมด แต่จะให้ภาพรวมของตัวเลือก JavaScript พื้นฐานในระหว่างการดำเนินการ โปรแกรมคอมพิวเตอร์จะจัดการค่าต่างๆ ซึ่งแต่ละค่าสามารถประมวลผลได้ในภาษาโปรแกรมและอ้างอิงถึงประเภทข้อมูลเฉพาะ
ใน JavaScript ประเภทข้อมูลสามารถแบ่งออกเป็นสองประเภท: ประเภทธรรมดา (เรียกอีกอย่างว่าดั้งเดิม) และแบบรวม (เรียกอีกอย่างว่าการอ้างอิงหรือวัตถุ)
JavaScript เป็นภาษาการเขียนโปรแกรมที่มีการพิมพ์ไม่รัดกุมหรือไดนามิก ซึ่งช่วยให้สามารถกำหนด แยกวิเคราะห์ และคอมไพล์ประเภทข้อมูลได้ทันทีระหว่างการทำงานของโปรแกรม ซึ่งหมายความว่าคุณไม่จำเป็นต้องกำหนดประเภทของตัวแปรล่วงหน้า ประเภทจะถูกกำหนดโดยอัตโนมัติระหว่างการทำงานของโปรแกรม
ดังนั้นในส่วนต่างๆ ของโปรแกรม ตัวแปรเดียวกันสามารถรับค่าประเภทต่างๆ ได้:
มาตรฐาน ECMAScript® กำหนดประเภทข้อมูลต่อไปนี้:
- ประเภทเรียบง่าย (เรียกอีกอย่างว่าดั้งเดิม):
- บูลีน - สามารถรับค่าที่เป็นไปได้สองค่า บางครั้งเรียกว่าจริงและเท็จ
- null – ค่า null แสดงถึงการอ้างอิงที่ชี้ไปยังวัตถุหรือที่อยู่ที่ไม่มีอยู่จริงหรือไม่ถูกต้อง ซึ่งโดยปกติแล้วจงใจ
- ไม่ได้กำหนด - หมายถึงตัวแปรส่วนกลางที่กำหนดไว้ล่วงหน้าซึ่งเริ่มต้นด้วยค่าที่ไม่ได้กำหนด
- ตัวเลข (ตัวเลขภาษาอังกฤษ) – ชนิดข้อมูลตัวเลขในรูปแบบของตัวเลขทศนิยมทศนิยมแบบความแม่นยำสองเท่า 64 บิต
- สตริง (สตริงภาษาอังกฤษ) – คือลำดับของอักขระที่ใช้แทนข้อความ
- สัญลักษณ์ (eng. Symbol) คือประเภทข้อมูลซึ่งมีอินสแตนซ์เฉพาะและไม่เปลี่ยนรูป (ใหม่ใน ECMAScript 6)
- วัตถุคือชุดของค่าที่มีชื่อ ซึ่งมักเรียกว่าคุณสมบัติของวัตถุ
ก่อนที่เราจะดูข้อมูลแต่ละประเภท เรามาทำความรู้จักกับประเภทของตัวดำเนินการกันก่อน ตัวดำเนินการ typeof ส่งกลับสตริงที่อธิบายชนิดข้อมูลของตัวแปร
มาสาธิตวิธีการทำงานโดยใช้ตัวอย่างต่อไปนี้:
สคริปต์ตัวอย่างประกาศตัวแปร เตรียมใช้งาน (กำหนดค่า) จากนั้นพิมพ์ประเภทของตัวแปรแต่ละตัว
ความแตกต่างระหว่างประเภทข้อมูลดั้งเดิมและประเภทข้อมูลคอมโพสิตเกิดขึ้นเมื่อคัดลอกค่า
เมื่อกำหนดค่าตัวแปรเป็นประเภทธรรมดา ค่านั้นเอง (เช่น ตัวเลข) จะถูกเขียนไปยังตัวแปร เมื่อเรากำหนดตัวแปรประเภทธรรมดาให้กับตัวแปรอื่น มันจะคัดลอกค่า เป็นผลให้แต่ละตัวแปรจะมีค่าของตัวเองและการเปลี่ยนแปลงในตัวแปรตัวใดตัวหนึ่งจะไม่ส่งผลกระทบต่อค่าของตัวแปรอื่นในทางใดทางหนึ่ง:
เมื่อเรากำหนดค่าประเภทคอมโพสิต (อ้างอิง) ให้กับตัวแปร การอ้างอิงถึงค่า (การอ้างอิงถึงออบเจ็กต์) จะถูกเขียนไปยังตัวแปร เมื่อเรากำหนดตัวแปรตัวหนึ่ง (ซึ่งค่ามีการอ้างอิงถึงค่าคอมโพสิต) ให้กับตัวแปรอื่น การอ้างอิงไปยังค่าคอมโพสิตจะถูกคัดลอก ด้วยเหตุนี้ ตัวแปรทั้งสองจึงอ้างอิงถึงค่าผสมเดียวกัน และการเปลี่ยนแปลงค่าของตัวแปรตัวหนึ่งจะส่งผลต่อตัวแปรอีกตัวหนึ่ง:
ประเภทดั้งเดิมชนิดข้อมูลทั้งหมดใน JavaScript ยกเว้นอ็อบเจ็กต์ จะไม่เปลี่ยนรูปหรือไม่เปลี่ยนรูป ซึ่งหมายความว่าไม่สามารถแก้ไขค่าได้ แต่จะเขียนทับด้วยค่าใหม่ที่แตกต่างออกไปเท่านั้น ตัวอย่างเช่น ไม่สามารถปรับเปลี่ยนสตริงทีละอักขระได้ - สามารถเขียนใหม่ได้ทั้งหมดเท่านั้น ค่าประเภทดังกล่าวเรียกว่า "ดั้งเดิม"
ข้อมูลที่ง่ายที่สุดที่โปรแกรมสามารถทำงานได้เรียกว่าข้อมูลตามตัวอักษร ตัวอักษรคือตัวเลขหรือสตริงที่ใช้แทนค่าใน JavaScript ข้อมูลที่ให้อาจแตกต่างกันมาก ดังนั้นค่าจึงมีหลายประเภท ประเภทข้อมูลที่ง่ายที่สุดใน JavaScript เรียกว่าประเภทข้อมูลพื้นฐาน ได้แก่ ตัวเลข สตริง และบูลีน ทั้งหมดจัดอยู่ในประเภท "ดั้งเดิม"
ประเภทบูลีน (ตรรกะ) “บูลีน”ค่าตรรกะหรือบูลีน (หลังชื่อนักประดิษฐ์ - บูลีน) สามารถมีค่าได้เพียงค่าใดค่าหนึ่งจากสองค่า: จริง (จริง) หรือเท็จ (เท็จ) โดยทั่วไปค่าจริงหรือเท็จจะปรากฏในการเปรียบเทียบหรือการดำเนินการเชิงตรรกะ
โปรแกรมต่อไปนี้สร้างตัวแปรบูลีนแล้วทดสอบค่าโดยใช้คำสั่ง if/else:
นิพจน์ใดๆ สามารถใช้เป็นนิพจน์เปรียบเทียบได้ นิพจน์ใดๆ ที่ส่งคืนค่า 0, null, ไม่ได้กำหนด หรือสตริงว่างจะถูกตีความว่าเป็น false นิพจน์ที่ระบุค่าอื่นใดจะถูกตีความว่าเป็น true
หมายเหตุ: เมื่อเขียนค่าบูลีน ค่าเหล่านั้นจะไม่อยู่ในเครื่องหมายคำพูด: var myVar = true;
ในเวลาเดียวกัน การประกาศ var myVar = "true" จะสร้างตัวแปรสตริง
ใน JavaScript ไม่มีความแตกต่างระหว่างจำนวนเต็มและจำนวนจุดลอยตัว โดยพื้นฐานแล้ว JavaScript จะแสดงตัวเลขทั้งหมดเป็นค่าจุดลอยตัว
JavaScript ใช้รูปแบบ 64 บิตที่กำหนดโดยมาตรฐาน IEEE-754 เพื่อแสดงตัวเลข รูปแบบนี้สามารถแสดงตัวเลขในช่วง ±1.7976931348623157 × 10308 ถึง ±5 × 10 -324
ตัวเลขที่พบในโค้ดโปรแกรมโดยตรงเรียกว่าตัวอักษรตัวเลข นอกเหนือจากตัวอักษรจำนวนเต็มทศนิยมแล้ว JavaScript ยังจดจำค่าเลขฐานสิบหกอีกด้วย
ตัวเลขฐานสิบหกสามารถรวมลำดับตัวเลขตั้งแต่ 0 ถึง 9 และตัวอักษรตั้งแต่ a ถึง f ซึ่งต้องขึ้นต้นด้วยลำดับอักขระ "0x"
วาร์ ก = 255; วาร์ ข = 0xFF; // หมายเลข 255 ในรูปแบบเลขฐานสิบหก
นอกจากนี้ JavaScript ยังมีค่าตัวเลขพิเศษ:
- NaN (ไม่ใช่ตัวเลขหรือข้อผิดพลาดในการคำนวณ) เป็นผลจากการดำเนินการทางคณิตศาสตร์ที่ไม่ถูกต้องกับข้อมูลที่ไม่ถูกต้อง เช่น สตริงหรือค่าที่ไม่ได้กำหนด
- อนันต์ (บวกอนันต์) ใช้เมื่อจำนวนบวกมากเกินไปที่จะแสดงใน JavaScript
- -อินฟินิตี้ (อินฟินิตี้ลบ) ใช้เมื่อจำนวนลบมีขนาดใหญ่เกินกว่าจะแสดงใน JavaScript
- ±0 (บวกและลบ 0) JavaScript แยกความแตกต่างระหว่างศูนย์บวกและลบ
ประเภทสตริงเป็นลำดับที่ไม่เปลี่ยนรูปและเรียงลำดับของค่า 16 บิต ซึ่งแต่ละค่าแทนอักขระ Unicode (ตัวอักษร ตัวเลข เครื่องหมายวรรคตอน อักขระพิเศษ และช่องว่าง) บรรทัดสามารถเว้นว่างหรือประกอบด้วยอักขระหนึ่งตัวขึ้นไป สตริงถูกสร้างขึ้นโดยใช้เครื่องหมายคำพูดคู่ (") หรือเดี่ยว (") สตริงที่คั่นด้วยเครื่องหมายคำพูดเดี่ยวคู่หนึ่งสามารถใช้เครื่องหมายคำพูดคู่ได้ และในทางกลับกัน สามารถใช้เครื่องหมายคำพูดคู่ภายในสตริงที่ล้อมรอบด้วยเครื่องหมายคำพูดคู่ได้:
ใน JavaScript ไม่มีความแตกต่างระหว่างเครื่องหมายคำพูดคู่และเครื่องหมายคำพูดเดี่ยว แต่เครื่องหมายคำพูดที่จุดเริ่มต้นและจุดสิ้นสุดของสตริงไม่ควรแตกต่างกัน ตัวอย่างเช่น นิพจน์เช่นนี้จะทำให้เกิดข้อผิดพลาดทางไวยากรณ์:
var firstName = "สูงสุด"; // ข้อผิดพลาดทางไวยากรณ์ - เครื่องหมายคำพูดต่างกัน
หมายเหตุ: JavaScript ไม่มีประเภทข้อมูลอักขระเดี่ยวพิเศษ เช่น char ใน C, C++ และ Java อักขระตัวเดียวจะแสดงด้วยสตริงความยาวหน่วย
ชนิดข้อมูล Null ชนิด Null มีค่าพิเศษค่าเดียวคือ nullคำหลัก null ไม่สามารถใช้เป็นชื่อฟังก์ชันหรือตัวแปรได้ ค่า null คือการอ้างอิงถึงวัตถุ "ว่าง" และมีวัตถุประสงค์พิเศษ - โดยปกติจะใช้เพื่อเริ่มต้นตัวแปรที่จะได้รับการกำหนดค่าในภายหลัง
ตัวดำเนินการ typeof สำหรับค่า Null ส่งคืนสตริง "วัตถุ" ซึ่งบ่งชี้ว่าค่า Null เป็นวัตถุ "ว่าง" พิเศษ
ชนิดข้อมูลที่ไม่ได้กำหนดประเภทที่ไม่ได้กำหนดจะสร้างประเภทของตัวเอง ซึ่งมีค่าพิเศษเพียงค่าเดียว: ไม่ได้กำหนด นี่คือค่าของตัวแปรที่ประกาศโดยใช้ตัวดำเนินการ var แต่ไม่ได้เตรียมใช้งาน:
ค่าที่ไม่ได้กำหนดจะถูกส่งกลับเมื่อเข้าถึงตัวแปรที่ไม่เคยกำหนดค่า คุณสมบัติของวัตถุที่ไม่มีอยู่ หรือองค์ประกอบอาร์เรย์
ควรสังเกตว่าตัวแปรที่มีค่าไม่ได้กำหนดจะแตกต่างจากตัวแปรที่ไม่ได้กำหนดไว้เลย:
ในตัวอย่างนี้ เมธอด alert() จะแสดงค่าของตัวแปรอายุ ซึ่งไม่ได้กำหนดไว้ ในกรณีที่สอง ตัวแปรรถยนต์ที่ไม่ได้ประกาศจะถูกส่งผ่านไปยังเมธอด alert() ซึ่งทำให้เกิดข้อผิดพลาด
ตัวอย่างต่อไปนี้อาจจะค่อนข้างสับสนสำหรับโปรแกรมเมอร์มือใหม่ เนื่องจาก... ตัวดำเนินการ typeof ส่งกลับค่าไม่ได้กำหนดสำหรับทั้งตัวแปรที่ไม่ได้กำหนดค่าเริ่มต้นและตัวแปรที่ไม่ได้ประกาศ:
ในตัวอย่างข้างต้น มีการประกาศอายุของตัวแปร แต่ไม่มีการเขียนลงไป ดังนั้นค่าของตัวแปรจึงเป็นเพียง unนิยาม ไม่ได้ประกาศตัวแปรรถยนต์ - ที่จริงแล้วไม่มีอยู่จริง อย่างไรก็ตาม typeof ส่งคืนสตริงที่ไม่ได้กำหนดในทั้งสองกรณี แน่นอนว่าสิ่งนี้สมเหตุสมผล เนื่องจากเป็นไปไม่ได้ที่จะดำเนินการใดๆ กับตัวแปรใดๆ เหล่านี้ แม้ว่าในทางเทคนิคแล้วจะแตกต่างอย่างสิ้นเชิงก็ตาม
หมายเหตุ: ขอแนะนำให้เตรียมใช้งานตัวแปรที่ประกาศไว้เสมอ ในกรณีนี้ คุณจะทราบว่าตัวดำเนินการ typeof ส่งคืนค่าที่ไม่ได้กำหนดเนื่องจากตัวแปรไม่ได้รับการประกาศ ไม่ใช่เนื่องจากไม่ได้เตรียมใช้งาน
ค่าที่ไม่ได้กำหนดนั้นได้มาจาก null ดังนั้นใน ECMA-262 ตัวดำเนินการ == จะถือว่าค่าเหล่านั้นเท่ากัน:
แม้ว่าค่าว่างและค่าไม่ได้กำหนดจะเกี่ยวข้องกัน แต่ก็มีการใช้ต่างกัน คุณไม่ควรกำหนดค่าที่ไม่ได้กำหนดให้กับตัวแปรอย่างชัดเจน แต่สิ่งนี้ใช้ไม่ได้กับค่าว่าง ในกรณีที่ไม่มีออบเจ็กต์ที่ต้องการ ควรใช้ null แทน สิ่งนี้บ่งชี้ว่ามีการใช้ null เป็นตัวชี้ไปยังวัตถุว่าง และเน้นความแตกต่างจาก undefinition
หากต้องการแยกความแตกต่างระหว่างค่าว่างและไม่ได้กำหนดในโปรแกรม คุณสามารถใช้ตัวดำเนินการข้อมูลประจำตัว === :
ประเภทข้อมูล สัญลักษณ์สัญลักษณ์คือนวัตกรรม JavaScript ตั้งแต่ ECMAScript เวอร์ชัน 6 สัญลักษณ์คือค่าดั้งเดิมที่ไม่ซ้ำใคร ไม่เปลี่ยนรูป ซึ่งใช้ในการสร้างตัวระบุที่ไม่ซ้ำ
ในการสร้างสัญลักษณ์ คุณต้องเรียกใช้ฟังก์ชันสัญลักษณ์:
var mySymbol = สัญลักษณ์();
ในการกำหนดสัญลักษณ์ คุณสามารถใช้ตัวดำเนินการ typeof หากค่าเป็นสัญลักษณ์ สัญลักษณ์สตริงจะถูกส่งกลับ:
ฟังก์ชัน Symbol มีพารามิเตอร์เผื่อเลือก - สตริงที่ทำหน้าที่อธิบายสัญลักษณ์:
ชื่อคุณสมบัติคือสตริง ดังนั้นจึงสามารถพิจารณาอ็อบเจ็กต์เพื่อเชื่อมโยงสตริงกับค่าได้ ข้อมูลเหล่านี้รวมกันเป็นคู่คีย์-ค่า
ใน JavaScript วัตถุสามารถสร้างขึ้นได้โดยใช้หนึ่งในสองไวยากรณ์:
1. var obj = (); // ใช้ object literal 2. var obj = new Object(); // ใช้เมธอดที่เรียกว่า Constructor
การสร้างวัตถุโดยใช้วัตถุตัวอักษรเริ่มต้นด้วยการกำหนดตัวแปรปกติ ทางด้านขวาของคำสั่งนี้เขียนอ็อบเจ็กต์ตามตัวอักษร - นี่คือรายการคู่ที่คั่นด้วยเครื่องหมายจุลภาคและอยู่ในเครื่องหมายปีกกา () "ชื่อ-ค่า"ล้อมรอบด้วยเครื่องหมายปีกกา ชื่อคุณสมบัติและค่าจะถูกคั่นด้วยเครื่องหมายทวิภาค:
var cat = ("ขา": 4, "ชื่อ": "Murzik", "สี": "สีแดง" )
วิธีที่สองในการสร้างวัตถุคือการใช้ตัวสร้าง Object() ในกรณีนี้ จะใช้นิพจน์ Object() ใหม่ก่อน จากนั้นจึงกำหนดคุณสมบัติของออบเจ็กต์ผลลัพธ์และเตรียมใช้งาน:
- การใช้วัตถุตามตัวอักษร
- โดยใช้วิธีที่เรียกว่าคอนสตรัคเตอร์