ชนิดข้อมูล

ค่าใน JavaScript จะเป็นประเภทใดประเภทหนึ่งเสมอ ตัวอย่างเช่น สตริงหรือตัวเลข

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

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

 //ไม่มีข้อผิดพลาด
ให้ข้อความ = "สวัสดี";
ข้อความ = 123456;

ภาษาการเขียนโปรแกรมที่อนุญาตสิ่งต่าง ๆ เช่น JavaScript เรียกว่า "ประเภทข้อมูลแบบไดนามิก" ซึ่งหมายความว่ามีประเภทข้อมูลอยู่ แต่ตัวแปรไม่ได้ผูกไว้กับประเภทข้อมูลใด ๆ

ตัวเลข

 ให้ n = 123;
n = 12.345;

ประเภท ตัวเลข แสดงถึงทั้งจำนวนเต็มและจำนวนจุดลอยตัว

มีการดำเนินการมากมายสำหรับตัวเลข เช่น การคูณ * การหาร / การบวก + การลบ - และอื่นๆ

นอกจากตัวเลขปกติแล้ว ยังมีสิ่งที่เรียกว่า "ค่าตัวเลขพิเศษ" ซึ่งเป็นของประเภทข้อมูลนี้ด้วย: Infinity , -Infinity และ NaN

• Infinity แสดงถึงอินฟินิตี้ทางคณิตศาสตร์ ∞ เป็นค่าพิเศษที่มากกว่าจำนวนใดๆ

  เราสามารถได้ผลลัพธ์จากการหารด้วยศูนย์:

   การแจ้งเตือน( 1 / 0 ); //อินฟินิตี้

  หรือเพียงอ้างอิงโดยตรง:

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

• NaN แสดงถึงข้อผิดพลาดในการคำนวณ เป็นผลมาจากการดำเนินการทางคณิตศาสตร์ที่ไม่ถูกต้องหรือไม่ได้กำหนดไว้ เช่น

   alert( "ไม่ใช่ตัวเลข" / 2 ); // น่าน การแบ่งดังกล่าวผิดพลาด

  NaN มีความเหนียว การดำเนินการทางคณิตศาสตร์เพิ่มเติมใด ๆ บน NaN จะส่งคืน NaN :

   การแจ้งเตือน (น่าน + 1); // แนน
  การแจ้งเตือน (3 * NaN); // แนน
  alert( "ไม่ใช่ตัวเลข" / 2 - 1 ); // แนน

  ดังนั้น หากมี NaN อยู่ที่ไหนสักแห่งในนิพจน์ทางคณิตศาสตร์ มันจะแพร่กระจายไปยังผลลัพธ์ทั้งหมด (มีข้อยกเว้นเพียงข้อเดียวเท่านั้น: NaN ** 0 คือ 1 )

การดำเนินการทางคณิตศาสตร์มีความปลอดภัย

การทำคณิตศาสตร์นั้น "ปลอดภัย" ใน JavaScript เราทำอะไรก็ได้: หารด้วยศูนย์ ถือว่าสตริงที่ไม่ใช่ตัวเลขเป็นตัวเลข ฯลฯ

สคริปต์จะไม่หยุดอยู่กับข้อผิดพลาดร้ายแรง (“ตาย”) ที่แย่ที่สุดเราจะได้ NaN ตามผลลัพธ์

ค่าตัวเลขพิเศษอย่างเป็นทางการอยู่ในประเภท "ตัวเลข" แน่นอนว่าคำนี้ไม่ใช่ตัวเลขในความหมายทั่วไป

เราจะดูเพิ่มเติมเกี่ยวกับการทำงานกับตัวเลขในบทตัวเลข

บิ๊กอินท์

ใน JavaScript ประเภท “number” ไม่สามารถแสดงค่าจำนวนเต็มที่มากกว่า (2 53 -1) (นั่นคือ 9007199254740991 ) หรือน้อยกว่า -(2 53 -1) สำหรับค่าเชิงลบ

เพื่อให้แม่นยำยิ่งขึ้น ประเภท "ตัวเลข" สามารถเก็บจำนวนเต็มที่มีขนาดใหญ่กว่าได้ (มากถึง 1.7976931348623157 * 10 308 ) แต่อยู่นอกช่วงจำนวนเต็มที่ปลอดภัย ±(2 53 -1) จะมีข้อผิดพลาดที่แม่นยำ เนื่องจากตัวเลขบางหลักไม่พอดี ลงในที่เก็บข้อมูลคงที่ 64 บิต ดังนั้นจึงสามารถจัดเก็บค่า "โดยประมาณ" ได้

ตัวอย่างเช่น ตัวเลขสองตัวนี้ (เหนือช่วงปลอดภัย) จะเหมือนกัน:

 console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992

กล่าวคือ จำนวนเต็มคี่ทั้งหมดที่มากกว่า (2 53 -1) ไม่สามารถจัดเก็บไว้ในประเภท "ตัวเลข" ได้เลย

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

เพิ่งเพิ่มประเภท BigInt ให้กับภาษาเพื่อแสดงจำนวนเต็มตามความยาวที่กำหนด

ค่า BigInt ถูกสร้างขึ้นโดยการผนวก n ต่อท้ายจำนวนเต็ม:

 // ตัว "n" ต่อท้ายหมายถึง BigInt
const ใหญ่Int = 1234567890123456789012345678901234567890n;

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

สตริง

สตริงใน JavaScript จะต้องล้อมรอบด้วยเครื่องหมายคำพูด

 ให้ str = "สวัสดี";
ให้ str2 = 'เครื่องหมายคำพูดเดี่ยวก็โอเคเหมือนกัน';
ให้วลี = `สามารถฝังอีก ${str}`;

ใน JavaScript มีเครื่องหมายคำพูดอยู่ 3 ประเภท

1. เครื่องหมายคำพูดคู่: "Hello"

2. คำพูดเดียว: 'Hello'

3. แบคติค: `Hello` `

เครื่องหมายคำพูดคู่และเดี่ยวเป็นเครื่องหมายคำพูด "ธรรมดา" แทบไม่มีความแตกต่างระหว่างพวกมันใน JavaScript

Backticks คือเครื่องหมายคำพูด “ฟังก์ชันเพิ่มเติม” พวกมันอนุญาตให้เราฝังตัวแปรและนิพจน์ลงในสตริงโดยล้อมพวกมันด้วย ${…} ตัวอย่างเช่น:

 ให้ชื่อ = "จอห์น";

//ฝังตัวแปร
alert( `สวัสดี ${name}!` ); // สวัสดีจอห์น!

// ฝังนิพจน์
alert( `ผลลัพธ์คือ ${1 + 2}` ); // ผลลัพธ์คือ 3

นิพจน์ภายใน ${…} ได้รับการประเมิน และผลลัพธ์จะกลายเป็นส่วนหนึ่งของสตริง เราสามารถใส่อะไรก็ได้ลงไป เช่น ตัวแปร เช่น name หรือนิพจน์ทางคณิตศาสตร์ เช่น 1 + 2 หรืออะไรที่ซับซ้อนกว่านี้

โปรดทราบว่าสามารถทำได้ใน backticks เท่านั้น คำพูดอื่นๆ ไม่มีฟังก์ชันการฝังนี้!

 alert( "ผลลัพธ์คือ ${1 + 2}" ); // ผลลัพธ์คือ ${1 + 2} (เครื่องหมายคำพูดคู่ไม่ทำอะไรเลย)

เราจะกล่าวถึงสตริงอย่างละเอียดมากขึ้นในบทที่ สตริง

ไม่มีประเภท อักขระ

ในบางภาษา จะมีประเภท "อักขระ" พิเศษสำหรับอักขระตัวเดียว ตัวอย่างเช่น ในภาษา C และ Java เรียกว่า "char"

ใน JavaScript ไม่มีประเภทดังกล่าว มีประเภทเดียวเท่านั้น: string สตริงอาจประกอบด้วยอักขระศูนย์ (เว้นว่าง) อักขระหนึ่งตัวหรือหลายตัว

บูลีน (ชนิดตรรกะ)

ประเภทบูลีนมีเพียงสองค่าเท่านั้น: true และ false

ประเภทนี้มักใช้เพื่อเก็บค่าใช่/ไม่ใช่: true หมายถึง "ใช่ ถูกต้อง" และ false หมายถึง "ไม่ ไม่ถูกต้อง"

ตัวอย่างเช่น:

 ให้ nameFieldChecked = true; // ใช่ ช่องชื่อถูกเลือกแล้ว
ให้ ageFieldChecked = false; // ไม่ ไม่ได้ตรวจสอบช่องอายุ

ค่าบูลีนยังมาจากผลการเปรียบเทียบ:

 ให้ isGreater = 4 > 1;

การแจ้งเตือน ( isGreater ); // จริง (ผลการเปรียบเทียบคือ "ใช่")

เราจะกล่าวถึงบูลีนให้ลึกซึ้งยิ่งขึ้นในบทตัวดำเนินการเชิงตรรกะ

ค่า "โมฆะ"

ค่า null พิเศษไม่ได้อยู่ในประเภทใดๆ ที่อธิบายไว้ข้างต้น

มันเป็นรูปแบบแยกประเภทของตัวเองซึ่งมีเพียงค่า null :

 ให้อายุ = โมฆะ;

ใน JavaScript null ไม่ใช่ "การอ้างอิงถึงวัตถุที่ไม่มีอยู่" หรือ "ตัวชี้ค่าว่าง" เหมือนในภาษาอื่นๆ บางภาษา

เป็นเพียงค่าพิเศษที่แสดงถึง "ไม่มีอะไร" "ว่างเปล่า" หรือ "ไม่ทราบค่า"

รหัสด้านบนระบุว่าไม่ทราบ age

ค่า "ไม่ได้กำหนด"

ค่าพิเศษ undefined ยังโดดเด่นอีกด้วย มันสร้างประเภทของตัวเองเหมือนกับ null

ความหมายของ undefined คือ "ไม่ได้กำหนดค่า"

หากมีการประกาศตัวแปร แต่ไม่ได้กำหนด ค่าของตัวแปรนั้นจะ undefined :

 ปล่อยให้อายุ;

การแจ้งเตือน(อายุ); // แสดง "ไม่ได้กำหนด"

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

 ให้อายุ = 100;

// เปลี่ยนค่าเป็นไม่ได้กำหนด
อายุ = ไม่ได้กำหนด;

การแจ้งเตือน(อายุ); // "ไม่ได้กำหนด"

…แต่เราไม่แนะนำให้ทำเช่นนั้น โดยปกติแล้ว เราจะใช้ null เพื่อกำหนดค่า “ว่าง” หรือ “ไม่ทราบ” ให้กับตัวแปร ในขณะ undefined จะถูกสงวนไว้เป็นค่าเริ่มต้นสำหรับสิ่งที่ไม่ได้กำหนด

วัตถุและสัญลักษณ์

ประเภท object เป็นแบบพิเศษ

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

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

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

ประเภทของตัวดำเนินการ

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

การเรียก typeof x ส่งคืนสตริงที่มีชื่อประเภท:

 typeof ไม่ได้กำหนด // "ไม่ได้กำหนด"

ประเภท 0 // "หมายเลข"

ประเภท 10n // "bigint"

ประเภทจริง // "บูลีน"

ประเภท "foo" // "string"

ประเภทของสัญลักษณ์("id") // "สัญลักษณ์"

ประเภทของคณิตศาสตร์ // "วัตถุ" (1)

typeof null // "วัตถุ" (2)

ประเภทของการแจ้งเตือน // "ฟังก์ชั่น" (3)

สามบรรทัดสุดท้ายอาจต้องมีคำอธิบายเพิ่มเติม:

1. Math เป็นวัตถุในตัวที่ให้การดำเนินการทางคณิตศาสตร์ เราจะเรียนรู้มันในบทตัวเลข ที่นี่ทำหน้าที่เป็นเพียงตัวอย่างของวัตถุ

2. ผลลัพธ์ของ typeof null คือ "object" นั่นเป็นข้อผิดพลาดที่ได้รับการยอมรับอย่างเป็นทางการใน typeof ซึ่งมาจาก JavaScript ยุคแรก ๆ และเก็บไว้เพื่อความเข้ากันได้ แน่นอน null ไม่ใช่วัตถุ เป็นค่าพิเศษที่มีชนิดแยกออกมาด้วยตัวมันเอง พฤติกรรมของ typeof ผิดที่นี่

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

ไวยากรณ์ typeof(x)

คุณอาจเจอไวยากรณ์อื่น: typeof(x) มันเหมือนกับ typeof x

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

โดยปกติแล้ว วงเล็บดังกล่าวจะมีนิพจน์ทางคณิตศาสตร์ เช่น (2 + 2) แต่ที่นี่มีเพียงอาร์กิวเมนต์เดียวเท่านั้น (x) ในทางวากยสัมพันธ์ พวกเขาอนุญาตให้หลีกเลี่ยงช่องว่างระหว่างตัวดำเนินการ typeof และอาร์กิวเมนต์ของมัน และบางคนก็ชอบมัน

บางคนชอบ typeof(x) แม้ว่าไวยากรณ์ของ typeof x จะพบได้บ่อยกว่ามากก็ตาม

สรุป

ข้อมูลพื้นฐานใน JavaScript มี 8 ประเภท

• ประเภทข้อมูลดั้งเดิมเจ็ดประเภท:

• number สำหรับตัวเลขชนิดใดๆ: จำนวนเต็มหรือจุดลอยตัว จำนวนเต็มจะถูกจำกัดโดย ±(2 53 -1)

• bigint สำหรับจำนวนเต็มความยาวใดก็ได้

• string สำหรับสตริง สตริงอาจมีอักขระตั้งแต่ศูนย์ขึ้นไป ไม่มีประเภทอักขระเดี่ยวแยกกัน

• boolean สำหรับ true / false

• null สำหรับค่าที่ไม่รู้จัก – ประเภทสแตนด์อโลนที่มีค่าเดียว null

• undefined สำหรับค่าที่ไม่ได้กำหนด – ประเภทสแตนด์อโลนที่มีค่าเดียว undefined

• symbol สำหรับตัวระบุที่ไม่ซ้ำ

• และประเภทข้อมูลที่ไม่ใช่แบบดั้งเดิมหนึ่งประเภท:

• object สำหรับโครงสร้างข้อมูลที่ซับซ้อนมากขึ้น

ตัวดำเนินการ typeof ช่วยให้เราเห็นว่าประเภทใดถูกเก็บไว้ในตัวแปร

• โดยปกติจะใช้เป็น typeof x แต่สามารถใช้ typeof(x) ได้เช่นกัน

• ส่งกลับสตริงที่มีชื่อประเภท เช่น "string"

• สำหรับการส่งคืน "object" เป็น null นี่เป็นข้อผิดพลาดในภาษา ซึ่งจริงๆ แล้วไม่ใช่วัตถุ

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

งาน

เครื่องหมายคำพูดแบบสตริง

ความสำคัญ: 5

ผลลัพธ์ของสคริปต์คืออะไร?

 ให้ชื่อ = "อิลยา";

alert( `สวัสดี ${1}` ); -

alert( `สวัสดี ${"name"}` ); -

alert( `สวัสดี ${name}` ); -

สารละลาย

Backticks ฝังนิพจน์ภายใน ${...} ลงในสตริง

 ให้ชื่อ = "อิลยา";

// นิพจน์คือหมายเลข 1
alert( `สวัสดี ${1}` ); // สวัสดี 1

// นิพจน์คือสตริง "ชื่อ"
alert( `สวัสดี ${"name"}` ); //สวัสดีชื่อ

// นิพจน์เป็นตัวแปร ให้ฝังไว้
alert( `สวัสดี ${name}` ); //สวัสดีอิลยา