Hati-hati pemaksaan jenis: fitur lanjutan ini dapat menjadi penyebab bug halus, jadi pastikan Anda mengetahui cara kerjanya.

Pengetikan dinamis JavaScript berarti kode Anda bisa sedikit lebih sederhana, tetapi masih memungkinkan untuk membuat kesalahan. Untuk menghindarinya, penting untuk mengetahui bagaimana JavaScript menyelesaikan nilai dengan tipe yang berbeda, untuk membandingkannya.

Memahami konversi tipe dan pemaksaan dalam JavaScript sangat penting untuk menulis program yang andal dan efisien. Setiap konsep memiliki kasus penggunaan khusus dan praktik terbaik yang dapat memengaruhi perilaku kode Anda.

Mengapa Jenis Konversi dan Pemaksaan Terjadi di JavaScript?

Bahasa JavaScript diketik secara dinamis. Ini berarti bahwa, tidak seperti bahasa yang diketik secara statis, JavaScript tidak mengharuskan Anda untuk secara eksplisit menentukan tipe data dari suatu variabel sebelum menggunakannya. Alih-alih, JavaScript menentukan jenis saat runtime bergantung pada nilai variabel.

Karena tipe data tidak dideklarasikan secara eksplisit hingga runtime, saat Anda melakukan operasi yang memerlukan data berbeda jenis, JavaScript secara otomatis memeriksa kompatibilitasnya satu sama lain untuk operasi yang ingin Anda lakukan. Jika mereka kompatibel satu sama lain, operasi berjalan normal.

instagram viewer

Namun, misalkan mereka tidak kompatibel dengan operasi—misalnya, mencoba menambahkan string dan angka. Dalam kasus seperti itu, JavaScript secara otomatis "memaksa" salah satu jenis agar sesuai dengan yang lain untuk memastikan bahwa operasi berhasil alih-alih menimbulkan kesalahan. Proses ini dikenal sebagai paksaan tipe atau paksaan implisit.

Ketik Paksaan

Pemaksaan tipe adalah konversi otomatis nilai dari satu tipe data ke tipe data lainnya, yang dilakukan oleh JavaScript selama menjalankan program untuk memastikan bahwa operasi berhasil dijalankan.

Tapi tidak semua tipe data bisa dipaksakan. String, angka, dan boolean adalah satu-satunya tipe data JavaScript bahwa bahasa akan memaksa menjadi jenis yang berbeda. Saat Anda mencoba melakukan operasi yang tidak kompatibel dengan tipe data yang tidak dapat dipaksakan oleh JavaScript, itu akan menimbulkan kesalahan.

Jenis paksaan JavaScript berdasarkan jenis operasi dan operator yang Anda gunakan dalam operasi.

Pemaksaan Dengan Operator “+”.

Dalam JavaScript, “+” operator memiliki dua perilaku berbeda tergantung pada jenis operannya. Itu dapat melakukan penambahan numerik dan penggabungan string. Ini dapat menyebabkan pemaksaan tipe ketika salah satu operan bukan tipe yang diharapkan.

Jika kedua operan adalah angka, "+” operator melakukan penambahan:

membiarkan angka1 = 42;
membiarkan angka2 = 10;
membiarkan jumlah = bilangan1 + bilangan2; // Tambahan
menghibur.log (jumlah); // 52

Jika kedua operan adalah string, tanda “+” operator melakukan penggabungan string:

membiarkan str1 = "Halo";
membiarkan str2 = "dunia";
membiarkan hasil = str1+ " " + str2; // Rangkaian string
menghibur.log (hasil); // "Halo Dunia"

Namun, jika salah satu operan bukan string, JavaScript akan secara implisit memaksanya menjadi string sebelum melakukan penggabungan:

// Angka dan String
membiarkan bilangan = 42;
membiarkan str = "Halo";
// num dipaksa menjadi string dan kemudian digabungkan
membiarkan result_1 = num + str;
menghibur.log (hasil_1); // "42Halo"


// String dan Boolean
membiarkan bool = BENAR;
// bool dipaksa menjadi string dan kemudian digabungkan
membiarkan result_2 = bool + str;
menghibur.log (hasil_2); // "halo sejati"

Pemaksaan Dengan Operator “-”.

Dalam JavaScript, “-” operator terutama digunakan untuk operasi pengurangan. Ketika satu atau kedua operan dalam operasi yang melibatkan “-” bukan angka, JavaScript akan mencoba memaksanya menjadi angka.

Saat kedua operan adalah angka, JavaScript melakukan pengurangan. Itu juga melakukan pengurangan ketika satu atau kedua operan adalah string yang mewakili angka:

const angka1 = 10;
const angka2 = 20;
const result_1 = bil2 - num1; // Pengurangan
menghibur.log (hasil_1); // 10
const strNum = "10";
const strNum2 = "20";
const hasil = strNum2 - strNum; // Ketik paksaan ke angka, lalu pengurangan
menghibur.log (hasil_1); // 10

Ketika tak satu pun dari operan adalah angka atau string yang mewakili angka, JavaScript akan mencoba untuk memaksa tipe data menjadi setara numeriknya. Jika tipe data tidak memiliki ekuivalen numerik, operasi akan kembali NaN (Bukan Angka):

// true dipaksa menjadi 1, false dipaksa menjadi 0
const boolNum = BENAR;
const boolNum2 = PALSU;
const result_1 = boolNum - boolNum2;
menghibur.log (hasil_1); // 1
// array kosong dipaksa menjadi 0
const arrNum = [];
const arrNum2 = [];
const result_2 = arrNum - arrNum2;
menghibur.log (hasil_2); // 0
// objek kosong dipaksa ke NaN
const objNum = {};
const result_3 = arrNum - objNum;
menghibur.log (hasil_3); // 0 - NaN = NaN

Dalam contoh ini, JavaScript memaksa nilai boolean BENAR Dan PALSU dengan nilai ekuivalen numeriknya, 1 Dan 0, masing-masing. Array kosong dipaksa untuk 0, dan benda-benda kosong dipaksa untuk NaN.

Pemaksaan Dengan Kesetaraan (==)/() Operator

Dalam JavaScript, operator kesetaraan (== Dan ) membandingkan nilai persamaan. Namun, mereka berperilaku berbeda karena paksaan tipe.

The “==” (kesetaraan longgar) operator melakukan pemaksaan tipe, artinya ia mencoba mengonversi operan ke tipe yang sama sebelum perbandingan:

"10" == 10; // BENAR

Dalam contoh ini, JavaScript memaksa string "10" menjadi angka 10, sehingga ekspresinya menjadi BENAR.

Namun, “” (persamaan ketat) operator tidak melakukan pemaksaan tipe. Ini membutuhkan nilai dan tipe yang sama agar perbandingan dapat dikembalikan BENAR:

"10"10; // PALSU

Dalam contoh ini, perbandingan kembali PALSU karena operan memiliki tipe yang berbeda (string dan angka).

Anda umumnya harus menggunakan (kesetaraan ketat) dalam JavaScript untuk menghindari perilaku pemaksaan tipe yang tidak terduga.

Pemaksaan tipe atau konversi implisit dapat menyebabkan perilaku yang tidak diharapkan karena sifatnya yang otomatis. Jika Anda perlu mengonversi tipe, disarankan untuk mengonversi tipe secara eksplisit. Proses konversi tipe secara eksplisit dikenal sebagai konversi tipe. Ini juga disebut sebagai pengecoran tipe dan konversi tipe eksplisit.

Ketik Konversi

Konversi tipe, juga dikenal sebagai pengecoran tipe, adalah proses eksplisit untuk mengonversi nilai dari satu tipe data ke tipe lainnya dalam JavaScript menggunakan fungsi bawaan seperti Nomor(), Rangkaian(), Boolean(), parseInt(), Dan parseFloat().

Anda dapat melakukan konversi tipe dengan meneruskan nilai yang ingin Anda konversi ke fungsi konversi bawaan sebagai argumen. Fungsi-fungsi ini kemudian mengonversi nilai Anda ke jenis yang Anda inginkan.

Berikut adalah contoh menggunakan Nomor() fungsi:

const numStr = "123";
const bilangan = Nomor(numStr); // Mengubah string menjadi angka
menghibur.log (bil); // 123

Melewati string yang merupakan nomor yang valid sebagai argumen ke Nomor() fungsi akan mengembalikan angka. Melewati string yang merupakan nomor yang tidak valid akan dikembalikan NaN.

Berikut adalah contoh menggunakan Rangkaian() fungsi:

const bool = BENAR;
const str2 = Rangkaian(bool); // Mengubah boolean menjadi string
menghibur.log (str2); // "BENAR"

Melewati tipe data apa pun ke dalam kecuali Simbol ke dalam Rangkaian() fungsi akan mengubah tipe data menjadi string.

Berikut adalah contoh menggunakan Boolean() fungsi:

// Mengubah string menjadi boolean (truthy: true, falsy: false)
const str = "Halo";
const bool2 = Boolean(str);
menghibur.log (bool2); // BENAR

Melewati nilai-nilai kebenaran ke Boolean() fungsi mengembalikan boolean "true" sementara meneruskan nilai falsy mengembalikan boolean "false".

Berikut adalah contoh menggunakan ParseInt() Dan ParseFloat() fungsi:

// Mengkonversi string menjadi integer
const numStr = "123.00";
const angka1 = parseInt(numStr);
menghibur.log (angka1); // 123
// Mengonversi string menjadi bilangan titik-mengambang
const floatStr = "3.14";
const angka2 = parseFloat(floatStr);
menghibur.log (bil2); // 3.14

Itu parseInt() fungsi mem-parsing argumen string dan mengembalikan integer. Itu parseFloat() fungsi mengubah string menjadi angka floating-point.

Memanfaatkan Pemaksaan dan Konversi Jenis

Dengan memahami pemaksaan dan konversi tipe, Anda dapat membuat keputusan berdasarkan informasi tentang kapan dan bagaimana memanfaatkannya secara efektif dalam kode Anda. Penting untuk mencapai keseimbangan yang tepat, menggunakan pemaksaan tipe dengan bijaksana untuk kode yang ringkas dan nyaman dan mengandalkan konversi tipe eksplisit untuk konversi tipe yang disengaja dan dapat diprediksi.