Operator Unarius ECMAScript

Operator unari hanya memiliki satu parameter, yaitu objek atau nilai yang akan dioperasikan. Mereka adalah operator paling sederhana di ECMAScript.

delete

Operator delete menghapus referensi ke properti atau metode objek yang sebelumnya didifinisi. Misalnya:

var o = new Object;
o.name = "David";
alert(o.name);	// keluaran "David"
delete o.name;
alert(o.name);	//menampilkan "undefined"

Dalam contoh ini, penghapusan properti name berarti memutuskan referensi kepadanya, sehingga diatur menjadi undefined (yaitu nilai variabel yang belum diinisialisasi).

Operator delete tidak dapat menghapus properti dan metode yang belum didefinisikan pengembang. Contohnya, kode di bawah ini akan memicu kesalahan:

delete o.toString;

Meskipun toString adalah nama yang valid, baris kode ini akan memicu kesalahan, karena metode toString() adalah metode ECMAScript asli, bukan yang didefinisikan pengembang.

void

Operator void mengembalikan undefined untuk setiap nilai. Operator ini biasanya digunakan untuk menghindari keluaran nilai yang tidak boleh ditampilkan, seperti saat memanggil fungsi JavaScript dari elemen HTML <a>. Untuk melakukan hal ini dengan benar, fungsi tidak boleh mengembalikan nilai yang valid, atau browser akan membersihkan halaman dan hanya menampilkan hasil fungsi.

<a href="javascript:window.open('about:blank')">Klik saya</a>

Jika menempatkan baris kode ini di halaman HTML, klik tautan yang ada, Anda akan melihat tampilan "[object]" di layar.TIY

Karena metode window.open() mengembalikan referensi jendela yang baru dibuka. Kemudian objek ini akan diubah menjadi string yang akan ditampilkan.

Untuk menghindari efek ini, gunakan operator void untuk memanggil fungsi window.open():

<a href="javascript:void(window.open('about:blank'))">Klik saya</a>

Ini membuat pemanggilan window.open() mengembalikan undefined, yang bukan nilai yang valid, tidak akan ditampilkan di jendela browser.

Pemberitahuan:Ingatlah, semua fungsi yang tidak mengembalikan nilai sebenarnya mengembalikan undefined.

Operator peng tambahan/pengurangan awal

Dua operator yang dipinjam dari C (dan Java) adalah operator peng tambahan awal dan pengurangan awal.

Operator peng tambahan awal adalah menambahkan nilai 1, berbentuk menempatkan dua tanda penambahan sebelum variabel (++):

var iNum = 10;
++iNum;

Baris kode kedua menambahkan nilai iNum menjadi 11, yang sebenarnya setara dengan:

var iNum = 10;
iNum = iNum + 1;

Hal yang sama, operator pengurangan awal mengurangi nilai 1, berbentuk menempatkan dua tanda pengurangan sebelum variabel (--):

var iNum = 10;
--iNum;

Dalam contoh ini, baris kode kedua mengurangi nilai iNum menjadi 9.

Pada penggunaan operator prefix, perhatikan bahwa operasi penambahan dan pengurangan terjadi sebelum perhitungan ekspresi. Berikut adalah contoh:

var iNum = 10;
--iNum;
alert(iNum);	//mengeluarkan "9"
alert(--iNum);	//mengeluarkan "8"
alert(iNum);	//mengeluarkan "8"

Kode baris kedua mengurangi nilai iNum, kode baris ketiga menampilkan hasilnya ("9"). Kode baris keempat lagi mengurangi nilai iNum, tetapi kali ini pengurangan sebelum dan operasi output muncul dalam satu kalimat, hasilnya adalah "8". Untuk membuktikan bahwa semua operasi pengurangan sudah terjadi, kode baris kelima kembali menampilkan "8".

Dalam ekspresi aritmatika, prioritas operator penambahan dan pengurangan sebelum adalah sama, jadi perhitungan harus dilakukan dari kiri ke kanan. Contoh:

var iNum1 = 2;
var iNum2 = 20;
var iNum3 = --iNum1 + ++iNum2;	//sama dengan "22"
var iNum4 = iNum1 + iNum2;		//sama dengan "22"

Dalam kode sebelumnya, iNum3 sama dengan 22, karena ekspresi yang dihitung adalah 1 + 21. Variabel iNum4 juga sama dengan 22, juga 1 + 21.

Operator pengurangan/penambahan setelah

Ada dua operator yang diambil langsung dari C (dan Java), yaitu operator pengurangan setelah dan penambahan setelah.

Operator pengurangan setelah juga menambahkan nilai 1, berbentuk menempatkan dua garis tambah (++) di belakang variabel:

var iNum = 10;
iNum++;

Tidak mengecewakan, operator pengurangan setelah juga mengurangi nilai 1, berbentuk menambahkan dua garis bawah (--) di belakang variabel:

var iNum = 10;
iNum--;

Kode baris kedua mengurangi nilai iNum menjadi 9.

Berbeda dengan operator prefix, operator postfix melakukan penambahan atau pengurangan setelah ekspresi yang mengandungnya dihitung. Dengan contoh berikut:

var iNum = 10;
iNum--;
alert(iNum);	//mengeluarkan "9"
alert(iNum--);	//mengeluarkan "9"
alert(iNum);	//mengeluarkan "8"

Sebagai contoh operator prefix, kode baris kedua mengurangi nilai iNum, kode baris ketiga menampilkan hasilnya ("9"). Kode baris keempat melanjutkan menampilkan nilai iNum, tetapi kali ini operator pengurangan digunakan dalam satu kalimat. Karena pengurangan terjadi setelah ekspresi dihitung, kalimat ini menampilkan angka "9". Setelah menjalankan kode baris kelima, fungsi alert menampilkan "8", karena setelah menjalankan kode baris keempat dan sebelum menjalankan kode baris kelima, pengurangan setelah terjadi.

Dalam ekspresi aritmatika, prioritas operator penambahan dan pengurangan setelah adalah sama, jadi perhitungan harus dilakukan dari kiri ke kanan. Contoh:

var iNum1 = 2;
var iNum2 = 20;
var iNum3 = iNum1-- + iNum2++;	//sama dengan "22"
var iNum4 = iNum1 + iNum2;		//sama dengan "22"

In the previous code, iNum3 is equal to 22 because the expression calculates 2 + 20. The variable iNum4 is also equal to 22, but it calculates 1 + 21 because the increment and decrement operations occur after assigning the value to iNum3.

Unary Plus and Unary Minus

Most people are familiar with unary plus and unary minus, which are used in ECMAScript in the same way as you learned in high school mathematics.

Unary plus has no effect on numbers in essence:

var iNum = 20;
iNum = +iNum;
alert(iNum);	//Output "20"

This code applies unary plus to the number 20 and returns 20.

Although unary plus has no effect on numbers, it has interesting effects on strings, converting them to numbers.

var sNum = "20";
alert(typeof sNum);	//Output "string"
var iNum = +sNum;
alert(typeof iNum);	//Output "number"

This code converts the string "20" to a real number. When the unary plus operator operates on a string, it calculates the string in a way similar to parseInt(), the main difference being that only strings starting with "0x" (representing hexadecimal numbers) can be converted to decimal values by unary operators. Therefore, using unary plus to convert "010", the result is always 10, while "0xB" will be converted to 11.

On the other hand, unary minus is the negation of a number (for example, converting 20 to -20):

var iNum = 20;
iNum = -iNum;
alert(iNum);	//Output "-20"

Similar to the unary plus operator, the unary minus operator will also convert a string to an approximate number and also negate the value. For example:

var sNum = "20";
alert(typeof sNum);	//Output "string"
var iNum = -sNum;
alert(iNum);		//Output "-20"
alert(typeof iNum);	//Output "number"

In the above code, the unary minus operator will convert the string "-20" to -20 (the unary minus operator handles hexadecimal and decimal values in a similar way to the unary plus operator, but it also negates the value).