Lexical grammar

Halaman ini menjelaskan tata bahasa leksikal JavaScript. Teks sumber skrip JavaScript dipindai dari kiri ke kanan dan diubah menjadi urutan elemen masukan yang merupakan token, karakter kontrol, terminator baris, komentar atau whitespace. ECMAScript juga mendefinisikan kata kunci dan literal tertentu dan memiliki aturan untuk penyisipan titik koma secara otomatis untuk mengakhiri pernyataan.

Karakter kontrol tidak memiliki representasi visual namun digunakan untuk mengendalikan interpretasi teks.

Karakter whitespace meningkatkan keterbacaan teks sumber dan memisahkan token-token. Karakter ini biasanya tidak diperlukan untuk fungsionalitas kode. Alat minifikasi sering digunakan untuk membuang whitespace agar mengurangi jumlah data yang perlu ditransfer.

Selain karakter whitespace, karakter terminator baris digunakan untuk meningkatkan keterbacaan teks sumber. Namun, dalam beberapa kasus, terminator baris dapat mempengaruhi eksekusi kode JavaScript karena ada beberapa tempat di mana mereka dilarang. Terminator baris juga mempengaruhi proses penyisipan titik koma otomatis. Terminator baris dicocokkan dengan kelas \s dalam regular expressions.

Hanya kode Unicode berikut yang diperlakukan sebagai terminator baris di ECMAScript, karakter pemecah baris lainnya diperlakukan sebagai whitespace (misalnya, Next Line, NEL, U+0085 dianggap sebagai whitespace).

Komentar digunakan untuk menambahkan petunjuk, catatan, saran, atau peringatan ke kode JavaScript. Hal ini dapat mempermudah membaca dan memahami. Mereka juga dapat digunakan untuk menonaktifkan kode agar tidak dieksekusi; Ini juga dapat menjadi alat debugging yang berharga.

JavaScript memiliki dua cara untuk memberi komentar pada kodenya.

Cara pertama adalah komentar //; Ini membuat semua teks yang mengikutinya pada baris yang sama menjadi sebuah komentar. Sebagai contoh:

function komentar() {
  // Ini adalah komentar JavaScript satu baris
  console.log('Hello world!');
}
komentar();

Cara kedua adalah komentar gaya  /* */ , yang jauh lebih fleksibel.

Misalnya, Anda bisa menggunakannya dalam satu baris:

function komentar() {
  /* Ini adalah komentar JavaScript satu baris */
  console.log('Hello world!');
}
komentar();

Anda juga bisa membuat komentar beberapa baris, seperti ini:

function komentar() {
  /* Komentar ini merentang dalam beberapa baris. Perhatikan
     bahwa kita tidak perlu mengakhir komentar sebelum selesai. */
  console.log('Hello world!');
}
komentar();

Anda juga bisa menggunakannya di tengah baris, jika Anda mau, meskipun ini bisa membuat kode Anda lebih sulit dibaca sehingga harus digunakan dengan hati-hati:

function komentar(x) {
  console.log('Hello ' + x /* menysipkan nilai dari x */ + ' !');
}
comment('world');

Selain itu, Anda bisa menggunakannya untuk menonaktifkan kode agar tidak berjalan, dengan membungkus kode dalam komentar, seperti ini:

function comment() {
  /* console.log('Hello world!'); */
}
comment();

Dalam hal ini, pemaggilan console.log() tidak pernah dikeluarkan, karena itu ada di dalam komentar. Sejumlah baris kode dapat dinonaktifkan dengan cara ini.

• break (en-US)
• case (en-US)
• catch (en-US)
• class
• const (en-US)
• continue (en-US)
• debugger (en-US)
• default (en-US)
• delete (en-US)
• do
• else (en-US)
• export
• extends
• finally (en-US)
• for (en-US)
• function
• if (en-US)
• import (en-US)
• in (en-US)
• instanceof (en-US)
• new (en-US)
• return (en-US)
• super (en-US)
• switch (en-US)
• this (en-US)
• throw (en-US)
• try (en-US)
• typeof (en-US)
• var (en-US)
• void (en-US)
• while (en-US)
• with (en-US)
• yield

Berikut ini disediakan sebagai kata kunci akan datang menurut spesifikasi ECMAScript. Mereka tidak memiliki fungsi khusus saat ini, namun mungkin pada beberapa waktu mendatang, sehingga tidak dapat digunakan sebagai pengidentifikasi.

Selalu dicadangkan:

• enum

Berikut ini hanya dicadangkan saat ditemukan dalam kode mode strict "ketat":

• implements
• interface
• let (en-US)
• package
• private
• protected
• public
• static

Berikut ini hanya dicadangkan saat ditemukan dalam kode modul:

• await

Kata kunci standart lama yang masih dingunakan hingga sekarang

Berikut adalah dicadankan sebagai kata kunci akan datang pada spesifikasi ECMAScript usang (ECMAScript 1 s/d 3).

• abstract
• boolean
• byte
• char
• double
• final
• float
• goto
• int
• long
• native
• short
• synchronized
• throws
• transient
• volatile

Selain itu literal-literal null, true, dan false tidak dapat digunakan sebagai pengidentifikasi didalam ECMAScript.

Kata yang dicadangkan sebenarnya hanya berlaku untuk pengidentifikasi (vs. IdentifierNames ). Seperti yang dijelaskan di es5.github.com/#A.1, ini semua adalah IdentifierNames yang tidak mengecualikan ReservedWords .

a.import
a['import']
a = { import: 'test' }.

Di sisi lain, hal-hal berikut ini ilegal karena ini adalah pengidentifikasi, yaitu IdentifierName tanpa kata-kata yang dicadangkan. Pengidentifikasi digunakan untuk FunctionDeclaration dan FunctionExpression.

function import() {} // Illegal.

Lihat juga null (en-US) untuk informasi lebih lanjut.

null

Lihat juga Boolean (en-US) untuk informasi lebih lanjut.

true
false

Decimal

1234567890
42

// Waspada saat mengunakan nol dimuka:
0888 // 888 diuraikan sebagai desimal
0777 // diuraikan sebagai oktal, 511 dalam desimal

Perhatikan bahwa literal desimal dapat dimulai dengan angka nol ( 0 ) diikuti oleh digit desimal lainnya, namun jika semua digit setelah angka 0 teratas lebih kecil dari 8, angka tersebut diartikan sebagai angka oktal. Ini tidak akan melempar JavaScript, lihat bug 957513. Lihat juga halaman tentang parseInt().

Biner

Sintaksis bilangan biner menggunakan nol dimuka diikuti huruf kecil atau huruf besar Latin "B" ( 0b atau 0B ). Karena sintaksis ini baru di ECMAScript 2015, lihat tabel kompatibilitas browser, di bawah ini. Jika digit setelah 0b tidak 0 atau 1, SyntaxError (en-US) berikut dilempar: "Missing binary digits after 0b".

var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607

Oktal

Sintaksis bilangan oktal menggunakan nol dimuka diikuti huruf kecil atau huruf besar Latin "O" ( 0o atau 0O). Karena sintaks ini baru di ECMAScript 2015, lihat tabel kompatibilitas browser, di bawah ini. Jika digit setelah 0o berada di luar kisaran (01234567), SyntaxError berikut dilempar: "Missing octal digits after 0o".

var n = 0O755; // 493
var m = 0o644; // 420

// Juga dimungkinkan hanya menggunakan nol dimuka (lihat tentang desimal diatas)
0755
0644

Heksadesimal

Sintaksis bilangan heksadesimal menggunakan nol dimuka diikuti huruf kecil atau huruf besar Latin "X" ( 0x atau 0X). Jika digit setelah 0x berada di luar rentang (0123456789ABCDEF), SyntaxError berikut dilempar: "Identifier starts immediately after numeric literal".

0xFFFFFFFFFFFFFFFFF // 295147905179352830000
0x123456789ABCDEF   // 81985529216486900
0XA                 // 10

Lihat juga Objek and Penginisialisasi objek untuk informasi lebih lanjut.

var o = { a: 'foo', b: 'bar', c: 42 };

// notasi singkat. baru di ES2015
var a = 'foo', b = 'bar', c = 42;
var o = {a, b, c};

// bukannya
var o = { a: a, b: b, c: c };

Lihat juga Array untuk informasi lebih lanjut.

[1954, 1974, 1990, 2014]

'foo'
"bar"

Rangkaian pelolosan/escape heksadesimal

'\xA9' // "©"

Rangkaian pelolosan/escape Unicode

Rangkaian pelolosan Unicode memerlukan setidaknya empat karakter diawali \u.

'\u00A9' // "©"

Penerapan point kode Unicode

Baru di ECMAScript 2015. Dengan pelolosan kode Unicode, tiap karakter dapat diloloskan menggunakan bilangan hexadesimal jadi dimungkinkan untuk menggunkan kode Unicode sampai 0x10FFFF. Dengan pelolosan Unicode sederhana terkadang lebih dibutuhkan untuk menulis bagian pengganti secara terpisah untuk mencapai tujuan yang sama.

Lihat juga String.fromCodePoint() atau String.prototype.codePointAt().

'\u{2F804}'

// ekuivalen dengan pelolosan Unicode sederhana
'\uD87E\uDC04'

Lihat juga RegExp untuk informasi lebih lanjut.

/ab+c/g

// Suatu literal "kosong" regular expression
// diperlukan grup bukan penangkap
// untuk menghindarkan ambiguitas denga komentar satu baris
/(?:)/

Lihat juga template strings (en-US) untuk informasi lebih lanjut.

`string text`

`string text baris 1
 string text baris 2`

`string text ${expression} string text`

tag `string text ${expression} string text`

Beberapa pernyataan JavaScript harus diakhiri dengan titik koma an oleh karena itu dipengaruhi oleh penyisipan otomatis semicolon (ASI):

• Pernyataan kosong/empty
• Pernyataan variabel let, const
• Deklarasi modul import, export
• Pernyataan ekspresi
• debugger
• continue, break, throw
• return

Spesifikasi ECMAScript menyebutkan tiga aturan penyisipan titik koma.

1.  Titik koma disisipkan sebelumnya, bila terminator baris or "}" diteramukan yang tidak diizinkan oleh tata bahasa.

{ 1 2 } 3

// di transformasikan ke ASI kedalam

{ 1 2 ;} 3;

2.  Titik koma disisipkan di bagian akhir, saat akhir aliran input token terdeteksi dan parser tidak dapat mengurai aliran input tunggal aliran sebagai program yang lengkap.

Disini ++ tidak diperlakukan sebagai operator postfix yang menerapkan variabel b, karena terminator baris terjadi antara b dan ++.

a = b
++c

// di transformasikan ke ASI kedalam

a = b;
++c;

3. Titik koma disisipkan pada akhirnya, ketika sebuah pernyataan dengan produksi terbatas dalam tata bahasa diikuti oleh terminator baris. Pernyataan-pernyataan ini dengan aturan "tidak diperlukan terminator baris" adalah:

• PostfixExpressions (++ and --)
• continue
• break
• return
• yield, yield*
• module

return
a + b

// di transformasikan ke ASI kedalam

return;
a + b;

• Sebelum Firefox 5 (JavaScript 1.8.6), kata kunci dicadangkan akan datang dapat digunakan saat tidak menggunakan mode strict. Pelanggaran ECMAScript ini telah diperbaiki di Firefox 5.

• Jeff Walden: Bilangan biner dan oktal
• Mathias Bynens: Rangkaian karakter pelolosan JavaScript
• Boolean
• Number
• RegExp
• String