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

การประกาศตัวแปร (การสร้าง) ทำได้โดยใช้คีย์เวิร์ด var

// ข้อความ - ชื่อตัวแปร var ข้อความ;

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

การกำหนดค่าให้กับตัวแปรทำได้โดยใช้ตัวดำเนินการ “=”

// เช่น สร้างตัวแปรอีเมลและกำหนดสตริงให้กับมัน " [ป้องกันอีเมล]"อีเมล var = " [ป้องกันอีเมล]"; // ตั้งค่าตัวแปรอีเมลเป็นค่าใหม่ email = " [ป้องกันอีเมล]";

หากต้องการรับค่าของตัวแปร เพียงอ้างอิงชื่อตัวแปร

// ตัวอย่างเช่น ส่งออกค่าของตัวแปรอีเมลไปยังคอนโซลของเบราว์เซอร์: console.log(email);

หากต้องการประกาศตัวแปรมากกว่าหนึ่งตัวแปรโดยใช้คีย์เวิร์ด var เดียว คุณต้องใช้เครื่องหมายจุลภาค

ราคา Var = 78.55 ปริมาณ = 10 ข้อความ;

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

เอาท์พุท Var = "ความสำเร็จ"; // ตัวแปรมีชนิดข้อมูลสตริงเอาต์พุต = 28; // ตัวแปรเดียวกัน แต่เป็นประเภทข้อมูล "ตัวเลข" แล้ว เอาต์พุต = จริง; // ตัวแปรเดียวกันแต่เก็บค่าบูลีนไว้แล้ว

ค่าของตัวแปรสามารถเปลี่ยนแปลงได้ไม่จำกัดจำนวนครั้ง

// สร้างตัวแปรอายุ var age; // อายุตัวแปรถูกกำหนดให้เป็นค่า 67 อายุ = 67; // อายุตัวแปรถูกตั้งค่าเป็น "อายุเกษียณ" age = "อายุเกษียณ"; // อายุตัวแปรตั้งไว้ที่ 55 age = 55;

แนวปฏิบัติที่ดีในการพัฒนาแอปพลิเคชันไคลเอนต์คือการใช้ประเภทข้อมูลเพียงประเภทเดียวในตัวแปรที่กำหนด เช่น อย่าเขียนค่าของข้อมูลประเภทต่างๆ ลงในตัวแปร เพื่อให้เข้าใจว่าควรคาดหวังข้อมูลประเภทใดในตัวแปร เมื่อสร้างตัวแปร ขอแนะนำให้เริ่มต้นด้วยค่าเฉพาะทันที

ชื่อตัวแปรสามารถประกอบด้วยตัวอักษร ตัวเลข และสัญลักษณ์ $ และ _ ในกรณีนี้ อักขระตัวแรกของตัวแปรต้องไม่ใช่ตัวเลข นอกจากนี้ คุณไม่สามารถใช้คำสงวนเป็นชื่อตัวแปรได้

// สร้างตัวแปรสองตัว ตัวแปรแรกชื่อ phone ตัวแปรตัวที่สองคือ meassage โทรศัพท์ var, ข้อความ;

กรณีของตัวอักษรในชื่อตัวแปรมีความสำคัญ ตัวอย่างเช่น โทรศัพท์ที่แปรผันและโทรศัพท์เป็นตัวแปรสองตัวที่แตกต่างกัน

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

วาร์ a = จริง; วาร์ ข = เท็จ;

สตริง

สตริงเป็นประเภทข้อมูลที่ใช้ใน JavaScript เพื่อแสดงข้อความ

สตริง JavaScript สามารถประกอบด้วย 0 หรือ มากกว่าตัวอักษร

JavaScript จะใช้ Unicode เป็นรูปแบบสตริงเสมอ

การสร้างสตริง (ตัวอักษรสตริง) ทำได้โดยการใส่ข้อความไว้ใน single หรือ เครื่องหมายคำพูดคู่.

"จาวาสคริปต์"; "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 + ")"; ); ประเภทของชื่อ; // "ไม่ได้กำหนด" ประเภทของอายุ; // ประเภทของ "หมายเลข" ของ isLicense; // ประเภทของดอกเบี้ย "บูลีน"; / / "object" (1) ประเภทของ LastExperience; // "object" ประเภทของ getExperience; // "function" (2) /* (1) เป็นข้อบกพร่องที่มีอยู่ในภาษาตั้งแต่การใช้งานครั้งแรก ยังไม่มี แก้ไขเพื่อรักษาความเข้ากันได้และจะต้องนำมาพิจารณาเมื่อเขียนสคริปต์ null เป็นประเภทข้อมูลดั้งเดิมไม่ใช่วัตถุ */ /* (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 ได้ สิ่งสำคัญคือต้องเข้าใจประเภทข้อมูลของตัวแปรแต่ละตัวที่กำหนด

บทช่วยสอนนี้จะแนะนำคุณเกี่ยวกับประเภทข้อมูล JavaScript

หมายเหตุ: ข้อมูลในคู่มือนี้ไม่ได้ครอบคลุมทั้งหมด แต่จะให้ภาพรวมของตัวเลือก JavaScript พื้นฐาน

การพิมพ์แบบไดนามิก

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

ในภาษาไดนามิก ตัวแปรที่มีชื่อเดียวกันสามารถใช้เพื่อจัดเก็บได้ ประเภทต่างๆข้อมูล.

ตัวอย่างเช่น ตัวแปร t ที่กำหนดโดยคีย์เวิร์ด var สามารถจัดเก็บข้อมูลประเภทต่างๆ ได้ มันสามารถเริ่มต้นได้ แต่ไม่ได้กำหนดไว้:

วาร์ เสื้อ = 16; // t คือตัวเลข
var t = "เทเรซา"; // t คือสตริง
var t = จริง; // 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 จึงถูกเรียกว่าภาษา "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 จะกำหนดขอบเขตไว้ที่บล็อก คำสั่ง หรือนิพจน์ที่มีการประกาศ และบล็อกที่ซ้อนกัน

หากคำว่า "ให้" ดูไม่ชัดเจนนัก คุณสามารถจินตนาการถึงการใช้คำว่า "ให้" แทนได้ จากนั้นนิพจน์ให้สี = "สีแดง" สามารถแปลเป็นภาษาอังกฤษได้ดังนี้: "ปล่อยให้สีเป็นสีแดง" และเป็นภาษารัสเซียดังนี้: "ปล่อยให้สีเป็นสีแดง"

เมื่อใช้คีย์เวิร์ด 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)

ต่อไปนี้เป็นชื่อของประเภทข้อมูลตามที่ถูกส่งกลับโดยตัวดำเนินการ typeof

เรามาพูดถึงประเภทข้อมูลที่ใช้บ่อยที่สุดจากรายการนี้กันดีกว่า

ประเภทตัวเลข ค่าของประเภทหมายเลขใน 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 "" // สตริงว่าง
ค่าที่เหลือเป็นจริง

JavaScript ประเภท null มีค่าพิเศษ null ซึ่งบ่งชี้ว่าไม่มีค่า ค่าที่คล้ายกันนี้ใช้ในภาษาอื่น ประเภทไม่ได้กำหนด ค่าที่ไม่ได้กำหนดที่เขียนไปยังตัวแปรบางตัวบ่งชี้ว่าตัวแปรนี้ไม่ได้เตรียมใช้งานและไม่มีค่าสำหรับมัน

ค่านี้จะถูกส่งกลับโดยอัตโนมัติจากฟังก์ชันที่ไม่ได้ส่งคืนผลลัพธ์อย่างชัดเจนโดยใช้คีย์เวิร์ด return หากฟังก์ชันรับพารามิเตอร์ที่ไม่ได้ระบุเมื่อมีการเรียกใช้ ฟังก์ชันนั้นจะถูกตั้งค่าเป็น undef ด้วย

ในการตรวจสอบค่าของ undef คุณสามารถใช้โครงสร้างต่อไปนี้

ประเภทของตัวแปร === "ไม่ได้กำหนด"

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

1/2 i++ ฉัน -= 2 ฉัน * 2

นิพจน์สตริง ผลลัพธ์ของการประเมินนิพจน์ดังกล่าวคือสตริง

"A" + "สตริง" "A" += "สตริง"

นิพจน์หลัก ตัวอักษร ค่าคงที่ และการอ้างอิงถึงตัวระบุจัดอยู่ในหมวดหมู่นี้

2 0.02 "บางสิ่ง" จริง เท็จ นี้ //บริบทการดำเนินการ อ้างอิงถึงวัตถุปัจจุบันที่ไม่ได้กำหนด i //โดยที่ i เป็นตัวแปรหรือค่าคงที่
รวมถึงคีย์เวิร์ดและโครงสร้าง JavaScript บางส่วนด้วย

ฟังก์ชันคลาสฟังก์ชัน* //ตัวสร้างผลผลิต //คำสั่งให้หยุดชั่วคราว/เริ่มการทำงานของตัวสร้างต่อ* //การมอบหมายให้กับตัววนซ้ำหรือฟังก์ชันอะซิงโครนัสตัวสร้างอื่น* //นิพจน์ฟังก์ชันแบบอะซิงโครนัสรออยู่ //การจัดระเบียบที่รอการดำเนินการของฟังก์ชันอะซิงโครนัส /รูปแบบ /ฉัน // การแสดงออกปกติ() //การจัดกลุ่ม

นิพจน์การเริ่มต้นสำหรับอาร์เรย์และวัตถุ //อาร์เรย์ตัวอักษร () //วัตถุตัวอักษร (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 มีคุณสมบัติพิเศษ (__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() ทั่วโลก วัตถุ.

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 หัวข้อของเนื้อหาถัดไปของเราคือฟังก์ชัน

เรียนผู้อ่าน! หากคุณเขียนด้วย JS มาเป็นเวลานาน โปรดบอกเราว่าคุณรู้สึกอย่างไรเกี่ยวกับการปรากฏตัวของคีย์เวิร์ด class ในภาษานั้นๆ

ในบทช่วยสอนนี้ เราจะแนะนำแนวคิดที่สำคัญมาก - ประเภทข้อมูล 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 มีพารามิเตอร์เผื่อเลือก - สตริงที่ทำหน้าที่อธิบายสัญลักษณ์:

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

ใน วัตถุจาวาสคริปต์สามารถสร้างได้โดยใช้หนึ่งในสองไวยากรณ์:

1. var obj = (); // ใช้ object literal 2. var obj = new Object(); // ใช้เมธอดที่เรียกว่า Constructor

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

var cat = ( "ขา": 4, "ชื่อ": "Murzik", "สี": "สีแดง" )

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

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

นิพจน์ใดๆ ที่ส่งคืนค่า 0, null, ไม่ได้กำหนด หรือสตริงว่างจะถูกตีความว่าเป็น false

สตริงถูกสร้างขึ้นโดยใช้เครื่องหมายคำพูดคู่ (") หรือเดี่ยว (") สตริงที่คั่นด้วยเครื่องหมายคำพูดเดี่ยวคู่หนึ่งสามารถใช้เครื่องหมายคำพูดคู่ได้ และในทางกลับกัน เครื่องหมายคำพูดเดี่ยวสามารถใช้ในสตริงที่ล้อมรอบด้วยเครื่องหมายคำพูดคู่ได้

ค่า null คือการอ้างอิงถึงวัตถุ "ว่าง" และมีวัตถุประสงค์พิเศษ - โดยปกติจะใช้เพื่อเริ่มต้นตัวแปรที่จะได้รับการกำหนดค่าในภายหลัง

ค่า (ไม่ได้กำหนด) คือตัวแปรที่ประกาศโดยใช้ตัวดำเนินการ var แต่ไม่ได้เตรียมใช้งาน

ใน JavaScript คุณสามารถสร้างออบเจ็กต์ได้ด้วยวิธีใดวิธีหนึ่งจากสองวิธี:

• การใช้วัตถุตามตัวอักษร
• โดยใช้วิธีที่เรียกว่าคอนสตรัคเตอร์

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