ไวยากรณ์ และ ไทป์

พื้นฐาน

จาวาสคริปต์ (ในที่นี้จะใช้ย่อ JS) ยืมวากยสัมพันธ์ส่วนใหญ่มากจากภาษา Java, แต่มันก็ยังได้รับอิทธิพลมาจากภาษาอื่นๆ ได้แก่ Awk, Perl and Python.

ใน JS อักขระอักษรตัวเล็กกับตัวใหญ่นั้นถือว่าต่างกัน (case-sensitive) , กลุ่มตัวอักขระที่ใช้ในภาษาจะเป็นกลุ่ม Unicode

ใน JS, คำสั่งต่างๆ (instructions) ถูกเรียกว่า ประโยค(statements). แต่ละคำสั่งถูกแยกด้วยเครื่องหมาย semicolon (;). อักขระช่องว่าง (spaces), อักขระ tabs และ อักขระขึ้นบรรทัดใหม่ (newline characters) จะถูกเรียกรวมว่า ช่องว่าง(whitespace). ซอร์ส (source) ต้นฉบับจะถูกอ่านจากซ้ายไปขวา  แล้วถูกเปลี่ยนเป็นลำดับของอินพุตอีเลเมนต์ (input element). อีเลเมนต์นั้นมีชนิดต่างๆ ได้แก่ โทเคน (tokens), อักขระควบคุม (control characters), ตัวสุดบรรทัด (line terminators), คอมเม็นต์ (comments) และ ช่องว่าง(whitespace)

คอมเม็นต์ (Comments)

วากยสัมพันธ์ของคอมเม็นต์ เป็นแบบเดียวกับในภาษา C++ และภาษาส่วนมากอื่นๆ :

// a one line comment
 
/* this is a longer, 
   multi-line comment
 */
 
/* You can't, however, /* nest comments */ SyntaxError */

การประกาศชื่อ (Declarations)

มีวิธีการ 3 แบบ ได้แก่

var

ประกาศตัวแปร, และอาจกำหนดค่าตั้งต้นของมันให้ด้วย

let

ประกาศตัวแปรที่จำกัดในบล็อก, และอาจกำหนดค่าตั้งต้นของมันให้ด้วย

const

ประกาศค่าคงที่ (อ่านได้อย่างเดียว แก้อีกไม่ได้)

ตัวแปร (Variables)

เราใช้ตัวแปรเพื่อเก็บค่าต่างๆ. ชื่อตัวแปรเหล่านี้, จะขอเรียกกว้างๆ ว่า ชื่อ identifiers, มีรูปแบบเป็นไปตามกฏเกณฑ์ที่กำหนด.

ชื่อต้องเร่ิมต้นด้วยตัวอักษร หรือ ตัวอักขระ _ (underscore)  หรือตัวอักขระ $ (dollar sign). อักขระตัวต่อไปอาจมีอักขระตัวเลข(0-9) ได้. ใน JS, อักษรตัวพิมพ์ใหญ่(uppercase) กับตัวพิมพ์เล็ก(lowercase) นั้นถือว่าต่างกัน (case-sensitive), อักขระอักษรได้แก่ "A" ถึง "Z" (ตัวพิมพ์ใหญ่) และ  "a" ถึง "z" (ตัวพิมพ์เล็ก ).

เรายังสามารถใช้อักขระส่วนใหญ่ในกลุ่ม ISO 8859-1 หรืออักขระกลุ่ม Unicode เช่น å และ ü ในชื่อได้ (ดูรายละเอียดเพิ่มใน​ this blog post). และยังสามารถใช้ชุดอักขระ  Unicode escape sequences ในชื่อได้อีกด้วย

ตัวอย่างชื่อที่ถูกต้อง เช่น Number_hits, temp99, and _name.

การประกาศตัวแปร (Declaring variables)

เราสามารถประกาศตัวแปรหนึ่งๆได้ 3 วิธี:

• ด้วยคีย์เวิร์ด var. เช่น, var x = 42. แบบนี้ใช้ประกาศได้ทั้งตัวแปร  local และ ตัวแปร global.
• ไม่ต้องใช้คีย์เวิร์ด, คือเพียงแค่กำหนดค่าให้กับชื่อตัวแปร. เช่น, x = 42. ตัวแปรแบบนี้จะเป็นตัวแปร global เสมอ. แต่ไม่ควรใช้วิธีนี้ และจะมีคำเตือนแจ้งเมื่อมีการใช้แบบนี้ภายใต้โหมดคุมเข้ม(strict).
• ด้วยคีย์เวิร์ด let. เช่น, let y = 13. แบบนี้ใช้ประกาศตัวแปร local ที่จำกัดอยู่ภายในบล็อก (block scope local variable). ดู Variable scope ด้านล่าง.

การหาค่าตัวแปร (Evaluating variables)

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

การเข้าใช้ตัวแปรที่ยังไม่ถูกประกาศ หรือ การเข้าใช้ชื่อที่ถูกประกาศด้วยประโยค let ก่อนที่มันจะมีค่า(before initialization), ล้วนทำให้เกิด exception ReferenceError. ตัวอย่าง:

var a;
console.log("The value of a is " + a); // The value of a is undefined

console.log("The value of b is " + b); // Uncaught ReferenceError: b is not defined

console.log("The value of c is " + c); // The value of c is undefined
var c;

console.log("The value of x is " + x); // Uncaught ReferenceError: x is not defined
let x;

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

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

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

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

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

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

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.

คุณสามารถใช้ 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"

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

อักขระหลีก (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";

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

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

แหล่งข้อมูล

• Text Escaping and Unescaping in JavaScript – โปรแกรมยูทิลิตี้ใช้แปลงอักขระยูนิโค้ดจากจาวาสคริปต์