ค่าข้อมูล, ตัวแปร, และตัวข้อมูล

by 1 contributor:

This translation is incomplete. Please help translate this article from English.

บทนี้กล่าวถึงค่าข้อมูลที่จาวาสคริปต์รู้จัก และอธิบายส่วนประกอบหลักที่ใช้สร้างนิพจน์จาวาสคริปต์ จากตัวแปร, ค่าคงที่, และตัวข้อมูล

ค่าข้อมูล (Values)

จาวาสคริปต์รู้จักค่าข้อมูลพื้นฐาน 5 ชนิดดังนี้

 
ชนิด ตัวอย่างค่าข้อมูล / หมายเหตุ
ตัวเลข (Numbers) 42, 3.14159
ตรรกะ (Boolean) true / false
สตริง (Strings) "Howdy"
null

คำพิเศษใช้ระบุค่าว่าง; null เป็นค่าข้อมูลพื้นฐาน และเนื่องจากจาวาสคริปต์แยกแยะตัวอักษรใหญ่เล็กได้ ทำให้ null ไม่เหมือน Null, NULL หรือในรูปอื่น

undefined

คุณสมบัติชั้นนอกสุดของสคริปต์ ที่ไม่ได้ถูกกำหนดค่า; undefined ก็เป็นค่าข้อมูลพื้นฐานด้วย

 

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

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

การแปลงชนิดข้อมูล

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

var answer = 42;

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

answer = "Thanks for all the fish...";

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

ในนิพจน์ที่มีทั้งค่าตัวเลขและสตริง กับตัวดำเนินการ + นั้น จาวาสคริปต์จะแปลงค่าตัวเลขให้เป็นสตริง ดังตัวอย่างในคำสั่งต่อไปนี้

x = "The answer is " + 42 // "The answer is 42"
y = 42 + " is the answer" // "42 is the answer"

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

"37" - 7 // 30
"37" + 7 // "377"

การแปลงสตริงเป็นตัวเลข

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

parseInt() and parseFloat()

ดูที่หน้า: parseInt() และ parseFloat()

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

ตัวดำเนินการเดี่ยว

อีกวิธีในการแปลงสตริงให้เป็นตัวเลขคือใช้เครื่องหมาย + เพิ่มไปข้างหน้า

"1.1" + "1.1" = "1.11.1"
(+"1.1") + (+"1.1") = 2.2   // Note: the parentheses are added for clarity, not required.

ตัวแปร (Variables)

คุณใช้ตัวแปรเป็นสัญญลักษณ์แทนค่าข้อมูลในแอปพลิเคชัน โดยชื่อตัวแปร (identifier) มีรูปแบบเป็นไปตามกฏเกณฑ์ที่กำหนด

ชื่อตัวแปรในจาวาสคริปต์จะต้องขึ้นต้นด้วยตัวอักษรหนึ่งตัว, เส้นใต้ (_), หรือเครื่องหมายดอลลาร์ ($)  ตัวอักขระที่ตามมาเป็นตัวเลข (0-9) ได้ และเนื่องจากจาวาสคริปต์แยกแยะตัวอักษรใหญ่เล็กได้ ตัวอักษรจึงเป็นได้ทั้งตัวใหญ่ "A" ถึง "Z" และตัวเล็ก "a" ถึง "z"

เริ่มตั้งแต่จาวาสคริปต์ 1.5, คุณสามารถใช้อักขระแบบ ISO 8859-1 หรือยูนิโค้ด เช่น å และ ü ใน ชื่อตัวแปรได้ และยังสามารถใช้ \uXXXX แทนตัวอักขระในชื่อตัวแปรได้ด้วย

ตัวอย่างการใช้ชื่อที่ถูกต้องคือ  Number_hits, temp99, และ _name

การประกาศตัวแปร

คุณสามารถประกาศตัวแปรได้สองวิธีคือ:

  • ด้วยคำสั่ง var, เช่น var x = 42 รูปแบบนี้ใช้ประกาศได้ทั้งตัวแปรเฉพาะที่ (local) และตัวแปรส่วนกลาง (global)
  • โดยการกำหนดค่าให้ตัวแปร, เช่น x = 42 เป็นการประกาศให้เป็นตัวแปรส่วนกลาง ไม่สามารถเปลี่ยนค่าด้วยตัวแปรเฉพาะที่ได้ และวิธีนี้จะทำให้เกิดคำเตือนจาวาสคริปต์ขึ้น จึงไม่ควรประกาศตัวแปรด้วยวิธีนี้

การประมวลผลตัวแปร

ตัวแปรที่ประกาศขึ้นด้วยคำสั่ง var และไม่กำหนดค่าเริ่มต้น จะมีค่าเป็น undefined

ถ้ามีการเรียกใช้ตัวแปรที่ไม่ได้มีการประกาศใช้ จะเกิดข้อผิดพลาด ReferenceError ขึ้น

var a;
console.log("The value of a is " + a); // logs "The value of a is undefined"
console.log("The value of b is " + b); // throws ReferenceError exception

คุณสามารถใช้ undefined เพื่อตรวจดูว่าตัวแปรมีค่าหรือไม่ ในโค้ดต่อไปนี้ตัวแปร input ไม่ถูกกำหนดค่า ทำให้คำสั่ง if ประมวลผลได้ค่าจริง (true)

var input;
if(input === undefined){
  doThis();
} else {
  doThat();
}

ค่า undefined จะกลายเป็นเท็จ (false) เมื่อใช้ในบริบทแบบตรรกะ โดยในตัวอย่าง, โปรแกรมจะเรียกใช้ฟังก์ชัน myFunction เพราะ myArray ไม่ได้ถูกกำหนดค่า

var myArray = new Array();
if (!myArray[0]) myFunction(); 

ค่า undefined ถูกแปลงเป็น NaN เมื่ออยู่ในบริบทการคำนวณ

var a;
a + 2 = NaN

เมื่อคุณประมวลผลค่าตัวแปรที่เป็นค่าว่าง (null) ค่าว่างจะกลายเป็น 0 ในบริบทการคำนวณ และกลายเป็นเท็จ (false) ในบริบทแบบตรรกะ  ดังตัวอย่าง

var n = null;
console.log(n * 32); // Will log 0 to the console

ขอบเขตของตัวแปร

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

จาวาสคริปต์ไม่กำหนดขอบเขตในบล็อกคำสั่ง {} นั่นคือ ตัวแปรเฉพาะที่ในบล็อกคำสั่งใด จะมีขอบเขตอยู่ในฟังก์ชัน (หรือบริบทส่วนกลาง) ที่หุ้มบล็อกนั้นอีกที จากโค้ดตัวอย่างจะได้ค่า x เป็น 5 เพราะว่าขอบเขตของ x จริงๆคือฟังก์ชัน (หรือบริบทส่วนกลาง)  ที่หุ้มบล็อกคำสั่ง if อยู่และมี x ประกาศอยู่ข้างในอีกที แต่ไม่ใช่ในบล็อกคำสั่ง if

if (true) {
  var x = 5;
}
console.log(x);

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

/**
 * Example 1
 */
console.log(x === undefined); // logs "true"
var x = 3;

/**
 * Example 2
 */
// will return a value of undefined
var myvar = "my value";
 
(function() {
  console.log(myvar); // undefined
  var myvar = "local value";
})();

ตัวอย่างข้างบนสามารถแปลงให้เป็นอย่างนี้ได้:

/**
 * Example 1
 */
var x;
console.log(x === undefined); // logs "true"
x = 3;
 
/**
 * Example 2
 */
var myvar = "my value";
 
(function() {
  var myvar;
  console.log(myvar); // undefined
  myvar = "local value";
})();

ผลจากการ hoisting จะเห็นได้ว่า, วิธีที่ดีที่สุด คือให้เขียนคำสั่ง var ทุกตัวในฟังก์ชันไว้ที่ด้านบนของฟังก์ชันเท่าที่จะทำได้ เพื่อให้โค้ดมีความชัดเจนมากยิ่งขึ้น

ตัวแปรส่วนกลาง (Global)

need links to pages discussing scope chains and the global object ตัวแปรส่วนกลางจริงๆแล้วเป็นคุณสมบัติของอ็อบเจกต์ส่วนกลาง อ็อบเจกต์ส่วนกลางของหน้าเว็บคือ window ที่คุณสามารถกำหนดและเรียกใช้ค่าตัวแปรส่วนกลางนี้โดยใช้รูปแบบ window.variable

ด้วยเหตุนี้ทำให้คุณสามารถเรียกใช้ตัวแปรส่วนกลางที่ถูกประกาศในหน้าต่างนั้น หรือในเฟรมจากอีกหน้าต่าง หรือในเฟรมโดยระบุชื่อหน้าต่างหรือชื่อเฟรม ตัวอย่างเช่น, ถ้ามีตัวแปรชื่อ phoneNumber ถูกประกาศใน FRAMESET คุณสามารถอ้างถึงตัวแปรนี้จากเฟรมลูกได้ด้วยคำสั่ง parent.phoneNumber

ค่าคงที่ (Constants)

คุณสามารถสร้างค่าคงที่ ชนิดอ่านได้อย่างเดียว ด้วยคำสั่ง const ด้วยวิธีการแบบเดียวกับการตั้งชื่อตัวแปร โดยเริ่มต้นด้วยตัวอักษร,เส้นใต้,หรือเครื่องหมายดอลลาร์ แล้วตามด้วยตัวอักษร,ตัวเลข,หรือเสันใต้ได้

const prefix = '212';

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

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

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

// THIS WILL CAUSE AN ERROR
function f() {};
const f = 5;

// THIS WILL CAUSE AN ERROR ALSO
function f() {
  const g = 5;
  var g;

  //statements
}

ตัวข้อมูล (Literals)

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

ตัวข้อมูลอาร์เรย์

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

ตัวอย่างต่อไปนี้แสดงการสร้างอาร์เรย์ชื่อ coffees ที่มีสมาชิกสามตัว และมีความยาวเท่ากับ 3

var coffees = ["French Roast", "Colombian", "Kona"];

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

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

โดยตัวข้อมูลอาร์เรย์ ก็คืออ็อบเจกต์แบบอาร์เรย์ ดูรายละเอียดได้ที่ Array Object

คอมมาส่วนเกินในตัวข้อมูลอาร์เรย์

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

var fish = ["Lion", , "Angel"];

อาร์เรย์นี้มีสองสมาชิกที่มีค่าข้อมูล และหนึ่งสมาชิกที่ว่าง ( fish[0] คือ "Lion", fish[1] คือ undefined, และ fish[2] คือ "Angel" )

ถ้าคุณใส่คอมมาที่ท้ายรายการ คอมมานั้นจะถูกละไว้ เช่นในตัวอย่างถัดไป, ความยาวอาร์เรย์เป็น 3 โดยไม่มี myList[3]ส่วนคอมมาตัวอื่นจะหมายถึงยังมีสมาชิกตามมาอีก (หมายเหตุ: คอมมาตัวท้ายทำให้เกิดข้อผิดพลาดในเบราวเซอร์รุ่นเก่าได้ วิธีที่ดีที่สุดคือไม่ต้องใส่มัน)

var myList = ['home', , 'school', ];

ตัวอย่างต่อไป, ความยาวอาร์เรย์เป็น 4, แต่ไม่ได้กำหนด myList[0] และ myList[2]

var myList = [ , 'home', , 'school'];

อีกตัวอย่าง, ความยาวอาร์เรย์เป็น 4, ไม่ได้กำหนด myList[1] และ myList[3] โดยคอมมาสุดท้ายถูกละไว้

var myList = ['home', , 'school', , ];

การทำความเข้าใจในผลของคอมมาส่วนเกิน เป็นสิ่งสำคัญในการเข้าใจภาษาจาวาสคริปต์ อย่างไรก็ดีเมื่อคุณเริ่มเขียนโค้ด การประกาศสมาชิกที่หายไปด้วย undefined จะช่วยให้โค้ดของคุณดูง่ายและแก้ไขได้สะดวก

ตัวข้อมูลตรรกะ

ข้อมูลตรรกะมีค่าข้อมูลได้สองค่า คือจริง (true) และเท็จ (false)

อย่าสับสนระหว่างค่าข้อมูลพื้นฐานตรรกะ true และ false กับค่าของอ็อบเจ็กต์ Boolean เนื่องจากอ็อบเจ็กต์ Boolean จริงๆแล้วคือ ตัวหุ้มค่าข้อมูลพื้นฐานตรรกะไว้อีกชั้น ดูรายละเอียดเพิ่มเติมได้ที่ Boolean Object

ตัวข้อมูลจำนวนเต็ม

จำนวนเต็มสามารถแสดงได้ในรูปเลขฐานสิบ,  ฐานสิบหก , และฐานแปด

  • ตัวข้อมูลจำนวนเต็มฐานสิบ ประกอบด้วยลำดับตัวเลขที่ไม่มี 0 นำ
  • ถ้ามีเลข 0 นำหน้าตัวข้อมูลจำนวนเต็ม หมายถึงเป็นเลขฐานแปด โดยจำนวนเต็มฐาน แปด จะมีเลขประจำหลักได้ตั้งแต่ 0-7 เท่านั้น
  • ถ้านำหน้าด้วย 0x (หรือ 0X) หมายถึงเป็นเลขฐานสิบหก โดยจำนวนเต็มฐานสิบหก จะประกอบด้วย เลข (0-9) และตัวอักษร a-f และ A-F

ตัวข้อมูลจำนวนเต็มฐานแปด  ถูกยกเลิกไปตั้งแต่มีมาตรฐาน ECMA-262 รุ่นที่ 3 แล้ว (ในโหมด strict) แต่จาวาสคริปต์ยังคงรองรับการใช้งานอยู่เพื่อคงความเข้ากันได้ย้อนหลัง

ตัวอย่างการใช้งานตัวข้อมูลจำนวนเต็ม:

0, 117 and -345 (decimal, base 10)
015, 0001 and -077 (octal, base 8) 
0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16)

ตัวข้อมูลทศนิยม

ตัวข้อมูลทศนิยมประกอบด้วยส่วนต่างๆด้งนี้:

  • จำนวนเต็มฐานสิบ ที่มีเครื่องหมายได้ (นำหน้าด้วย "+" หรือ "-"),
  • จุดทศนิยม ("."),
  • ทศนิยม (จำนวนเต็มหลังจุด),
  • ค่ายกกำลัง

ค่ายกกำลังจะใช้ "e" หรือ "E" ตามด้วยจำนวนเต็มที่มีเครื่องหมายได้ (นำหน้าด้วย "+" หรือ "-") โดยตัวข้อมูลทศนิยมนี้จะต้องมีเลขอย่างน้อยหนึ่งหลักและจุดทศนิยมหรือ "e" (หรือ "E")

ตัวอย่างของตัวข้อมูลทศนิยม เช่น 3.1415, -3.1E12, .1e12, and 2E-12

มีรูปแบบอย่างย่อคือ:

[(+|-)][ตัวเลข][.ตัวเลข][(E|e)[(+|-)]ตัวเลข]

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

3.14
2345.789
.3333333333333333333
-.283185307179586

ตัวข้อมูลอ็อบเจกต์

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

ตัวอย่างต่อไปนี้แสดงการใช้งานตัวข้อมูลอ็อบเจกต์, สมาชิกตัวแรกของอ็อบเจกต์ car มีชื่อคุณสมบัติว่า myCar และมีค่าข้อมูลเป็นค่าสตริง "Saturn", สมาชิกตัวที่สองใช้ชื่อคุณสมบัติว่า getCar ซึ่งกำหนดให้มีค่าเป็นผลลัพธ์ของฟังก์ชัน CarTypes("Honda"), และสมาชิกตัวที่สามมีชื่อคุณสมบัติว่า special และมีค่าเป็นตัวแปร Sales

var Sales = "Toyota";

function CarTypes(name) {
  if (name == "Honda") {
    return name;
  } else {
    return "Sorry, we don't sell " + name + ".";
  }
}

var car = { myCar: "Saturn", getCar: CarTypes("Honda"), special: Sales };

console.log(car.myCar);   // Saturn
console.log(car.getCar);  // Honda
console.log(car.special); // Toyota 

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

var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };

console.log(car.manyCars.b); // Jeep
console.log(car[7]); // Mazda

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

var unusualPropertyNames = {
  "": "An empty string",
  "!": "Bang!"
}
console.log(unusualPropertyNames."");   // SyntaxError: Unexpected string
console.log(unusualPropertyNames[""]);  // "An empty string"
console.log(unusualPropertyNames.!);    // SyntaxError: Unexpected token !
console.log(unusualPropertyNames["!"]); // "Bang!"

 ข้อสังเกตุ:

var foo = {a: "alpha", 2: "two"};
console.log(foo.a);    // alpha
console.log(foo[2]);   // two
//console.log(foo.2);  // Error: missing ) after argument list
//console.log(foo[a]); // Error: a is not defined
console.log(foo["a"]); // alpha
console.log(foo["2"]); // two

ตัวข้อมูลสตริง

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

  • "foo"
  • 'bar'
  • "1234"
  • "one line \n another line"
  • "John's cat"

คุณสามารถเรียกใช้เมธอดของอ็อบเจกต์สตริงกับตัวข้อมูลสตริงได้ โดยจาวาสคริปต์จะแปลงตัวข้อมูลสตริงให้เป็นอ็อบเจกต์สตริงชั่วคราว แล้วเรียกใช้เมธอด จากนั้นก็ทิ้งอ็อบเจกต์สตริงชั่วคราวนั้นไป นอกจากนี้คุณยังใช้คุณสมบัติ String.length กับตัวข้อมูลสตริงได้อีกด้วย:

print("John's cat".length) // Will print the number of symbols in the string including whitespace. In this case, 10.

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

การใช้ตัวอักขระพิเศษในสตริง

นอกเหนือจากการใช้ตัวอักขระปกติแล้ว, คุณยังสามารถใช้ตัวอักขระพิเศษในสตริงได้ ดังเช่นตัวอย่างต่อไปนี้

"one line \n another line"

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

ตาราง 2.1 อักขระพิเศษในจาวาสคริปต์
อักขระ ความหมาย
\b Backspace
\f Form feed
\n New line
\r Carriage return
\t Tab
\v Vertical tab
\' Apostrophe or single quote
\" Double quote
\\ Backslash character
\XXX อักขระที่เข้ารหัส Latin-1 กำหนดด้วยเลขฐานแปดสามหลัก XXX ระหว่าง 0 ถึง 377  เช่น, \251 เป็นลำดับฐานแปดของสัญญลักษณ์ copyright
\xXX อักขระที่เข้ารหัส Latin-1 กำหนดด้วยเลขฐานสิบหกสองหลัก XX ระหว่าง 00 ถึง FF  เช่น, \xA9 เป็นลำดับฐานสิบหกของสัญญลักษณ์ copyright
\uXXXX อักขระยูนิโคดกำหนดด้วยเลขฐานสิบหกสี่หลัก XXXX เช่น, \u00A9 เป็นลำดับยูนิโคดของสัญญลักษณ์ copyright

อักขระหลีก (Escaping characters)

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

คุณสามารถแทรกเครื่องหมายคำพูดภายในสตริงโดยนำหน้าด้วย \ เพื่อเป็นการหลีกเครื่องหมายคำพูด เช่น

var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service.";
console.log(quote);

ผลลัพธ์ที่ได้คือ:

He read "The Cremation of Sam McGee" by R.W. Service.

ถ้าต้องการใส่ตัวอักขระ \ ในสตริง, คุณต้องใช้ \\ เพื่อหลีกเครื่องหมาย \ , ตามตัวอย่างต้องการกำหนดค่าตำแหน่งไฟล์เป็น  c:\temp ให้สตริง

var home = "c:\\temp";

คุณยังสามารถหลีกการขึ้นบรรทัดใหม่โดยใช้ \ ก่อนขึ้นบรรทัด, โดยเครื่องหมาย \ กับการขึ้นบรรทัดใหม่จะถูกถอดออกจากค่าของสตริง

var str = "this string \
is broken \
across multiple\
lines."
console.log(str);   // this string is broken across multiplelines.

ถึงแม้จาวาสคริปต์จะไม่มีรูปแบบ "heredoc",  แต่คุณก็สามารถทำคล้ายๆกันได้ด้วยการเพิ่ม อักขระพิเศษ \n และหลีกการขึ้นบรรทัดใหม่ด้วย \ ที่ท้ายบรรทัดได้:

var poem = 
"Roses are red,\n\
Violets are blue.\n\
I'm schizophrenic,\n\
And so am I."

ยูนิโค้ด (Unicode)

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

ชุดอักขระยูนิโค้ดสามารถใช้ได้กับการเข้ารหัสที่รู้จักกันทั้งหมด โดยยูนิโค้ดยึดรูปแบบตามชุดอักขระ ASCII (American Standard Code for Information Interchage) ที่ใช้ค่าตัวเลขและชื่อแทนอักขระแต่ละตัว โดยการเข้ารหัสจะกำหนดเอกลักษณ์และค่าตัวเลข (ตำแหน่งโค้ด) ของอักขระ รวมทั้งค่าบิทของตัวเลขนี้ ซึ่งค่าตัวเลขในแบบ 16 บิท (ค่าโค้ด) จะแทนด้วยเลขฐานสิบหกและใช้อักษร U นำ, เช่น U+0041 ใช้แทน A ที่มีชื่อเฉพาะว่า ตัวอักษร A ใหญ่แบบละติน

จาวาสคริปต์ในเวอร์ชันก่อน 1.3 ไม่รองรับการใช้งานยูนิโคด

ความเข้ากันได้ของยูนิโค้ดกับ ASCII และ ISO

ยูนิโค้ดมีความเข้ากันได้ทั้งหมดกับมาตรฐานระหว่างประเทศ ISO/IEC 10646-1; 1993, ที่เป็นสับเซ็ตของ ISO 10646.

มีหลายมาตรฐานการเข้ารหัส (รวมทั้ง UTF-8, UTF-16 และ ISO UCS-2) ที่ใช้วิธีแทนค่ายูนิโค้ดด้วยจำนวนบิท

การเข้ารหัสยูนิโค้ดแบบ UTF-8 เข้ากันได้กับอักขระ ASCII  และมีหลายโปรแกรมรองรับ โดยอักขระยูนิโค้ด 128 ตัวแรกจะตรงกับอักขระ ASCII และมีค่าไบต์เท่ากัน ส่วนอักขระยูนิโค้ด U+0020 ถึง U+007E  จะตรงกับอักขระ ASCII 0x20 ถึง 0x7E  สิ่งที่ต่างจาก ASCII ซึ่งรองรับอักษรละตินและใช้ชุดอักขระ 7 บิทก็คือ UTF-8 ใช้ข้อมูล 1 ถึง 4 อ็อกเตท (1 อ็อกเตทคือ 1 ไบท์ หรือ 8 บิท) แทนแต่ละอักขระ ทำให้ได้อักขระหลายล้านตัว ส่วนมาตรฐานการเข้ารหัสแบบ UTF-16 ซึ่งใช้ 2 อ็อกเตทแทนอักขระยูนิโค้ด ซึ่งเมื่อใช้ร่วมกับอักขระหลีกแล้ว UTF-16 จะสามารถแทนอักขระยูนิโค้ดได้ทั้งหมดโดยใช้ข้อมูล 4 อ็อกเตท ในขณะที่อีกมาตรฐาน ISO UCS-2 (Universal Character Set - ชุดอักขระสากล) ใช้ข้อมูล 2 อ็อกเตท

จาวาสคริปต์และเนวิเกเตอร์รองรับ  UTF-8/ยูนิโค้ด ซึ่งหมายความว่าคุณสามารถใช้อักขระ ที่ไม่ใช่ละติน, อักขระนานาชาติ, และอักขระท้องถิ่น รวมถึงสัญญลักษณ์พิเศษทางเทคนิคในโปรแกรมจาวาสคริปต์ได้ โดยยูนิโค้ดได้ให้แนวทางการเข้ารหัสข้อความหลายภาษาไว้ และเนื่องจากการเข้ารหัส UTF-8 ของยูนิโคดเข้ากันได้กับ ASCII , โปรแกรมจึงสามารถใช้อักขระ ASCII ได้ โดยคุณสามารถใช้อักขระยูนิโค้ดที่ไม่ใช่ ASCII ในข้อความหมายเหตุ, ตัวข้อมูลแบบสตริง, ชื่อตัวแปร, และใน regular expression ของจาวาสคริปต์ได้

อักขระหลีกยูนิโค้ด

คุณสามารถใช้อักชระหลีกยูนิโค้ดในตัวข้อมูลแบบสตริง, regular expression, และชื่อตัวแปร โดยอักขระหลีกจะประกอบด้วยอักขระ ASCII หกตัวในรูปแบบ \u รวมกับเลขฐานสิบหกสี่หลัก เช่น, \u0049 คือสัญญลักษณ์ copyright ซึ่งทุกๆอักขระหลีกยูนิดโค้ดจะถูกแปลให้เป็นอักขระเดียวในจาวาสคริปต์

โค้ดต่อไปนี้จะคืนค่าสัญญลักษณ์ copyright และสตริง "Netscape Communications"

var x = "\u00A9 Netscape Communications";

ตารางต่อไปนี้แสดงรายการอักขระพิเศษและค่ายูนิโค้ด

ตาราง 2.2 ค่ายูนิโค้ดของอักขระพิเศษ
ประเภท ค่ายูนิโค้ด ชื่อ Format name
White space values \u0009 Tab <TAB>
\u000B Vertical Tab <VT>
\u000C Form Feed <FF>
\u0020 Space <SP>
Line terminator values \u000A Line Feed <LF>
\u000D Carriage Return <CR>
Additional Unicode escape sequence values \u0008 Backspace <BS>
\u0009 Horizontal Tab <HT>
\u0022 Double Quote "
\u0027 Single Quote '
\u005C Backslash \

จาวาสคริปต์มีวิธีจัดการอักขระหลีกยูนิโค้ดแตกต่างจากในจาวา ในจาวาสคริปต์, อักขระหลีกจะยังไม่ถูกแปลความหมายเป็นอักขระพิเศษในทันที ตัวอย่างเช่น, อักขระหลีกตัวปิดบรรทัด (line termanitor) ที่อยู่ในสตริงจะยังไม่ทำงานจนกว่าจะจบสตริงแล้ว และจาวาสคริปต์ก็ไม่สนใจอักขระหลีกใดๆที่ใช้ในข้อความหมายเหตุ ส่วนในจาวา, ถ้ามีอักขระหลีกอยู่ในบรรทัดหมายเหตุใด มันจะถูกแปลความหมายแบบอักขระยูนืโค้ด ถ้าอยู่ในตัวข้อมูลแบบสตริง ตัวแปลจาวาจะแปลความหมายอักขระหลีกนั้นทันที เช่น, ถ้าอักขระหลีกตัวปิดบรรทัด (เช่น \u000A)  ถูกใช้ในจาวา, จะถือเป็นการสิ้นสุดค่าข้อมูลสตริงทันที และอาจทำให้เกิดข้อผิดพลาดได้เพราะตัวปิดบรรทัดไม่ควรอยู่ในตัวข้อมูลแบบสตริง วิธีแก้คุณต้องใช้ \n เมื่อต้องการให้ขึ้นบรรทัดใหม่ในตัวข้อมูลสตริง ส่วนในจาวาสคริปต์นั้น อักขระหลีกตัวนี้ (\u000A) จะทำงานแบบเดียวกับ \n

อักขระยูนิโค้ดในจาวาสคริปต์

ในเวอร์ชันก่อนๆของ Gecko ไฟล์จาวาสคริปต์ที่โหลดจาก XUL ต้องมีการเข้ารหัสอักขระแบบ Latin-1 แต่ใน Gecko 1.8 เป็นต้นมา รูปแบบการเข้ารหัสจะอิงตามการเข้ารหัสอักขระในไฟล์ XUL นั้น ถ้าต้องการข้อมูลเพิ่มเติมโปรดดูที่ International characters in XUL JavaScript

การแสดงอักขระด้วยยูนิโค้ด

คุณสามารถใช้ยูนิโค้ดแสดงอักขระหลายภาษาหรือสัญญลักษณ์ทางเทคนิคได้ โดยการแสดงผลอักขระอย่างถูกต้องนั้น โปรแกรมไคลเอนท์เช่น Mozilla Firefox หรือ Netscape จำเป็นต้องรองรับยูนิโค้ด และต้องมีฟ๊อนท์ยูนิโค้ดที่เหมาะสมติดตั้งพร้อมใช้งานรวมทั้งระบบที่ไคลเอนท์ทำงานอยู่ก็ต้องรองรับยูนิโค้ดด้วย บ่อยครั้งที่ฟ๊อนท์ยูนิโค้ดไม่สามารถแสดงอักขระยูนิโค้ดได้ทั้งหมด ในบางระบบเช่น WIndows 95, สามารถรองรับยูนิโค้ดได้บางส่วนเท่านั้น

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

ดูข้อมูลเพิ่มเติมเกี่ยวกับยูนิโค้ดได้ที่ Unicode Home Page และจาก The Unicode Standard, Version 2.0, จัดพิมพ์โดย Addison-Wesley, 1996

แหล่งข้อมูล

Document Tags and Contributors

Contributors to this page: Zarazi
Last updated by: Zarazi,