Taip Paksaan dalam JavaScript Diterangkan

Dalam JavaScript, pembolehubah tidak memerlukan pengisytiharan jenis tertentu dan boleh menyimpan nilai sebarang jenis data. Sebagai bahasa yang ditaip secara longgar, JavaScript secara automatik menukar nilai daripada satu jenis kepada jenis lain di belakang tabir untuk memastikan kod anda berjalan lancar. Walaupun tingkah laku ini menjadikan JavaScript lebih fleksibel, ia juga boleh membawa kepada hasil yang tidak dijangka dan pepijat yang sukar ditemui, jika anda tidak biasa dengan cara ia berfungsi.

Dalam siaran ini, kita akan mempelajari tentang pemaksaan jenis dalam JavaScript, meliputi pelbagai jenis paksaan, contoh dan amalan terbaik untuk membantu anda memahami dan mengawal kod anda dengan lebih berkesan.

Mari kita terjun terus ke dalamnya!?

Apakah Paksaan Jenis?

Paksaan jenis merujuk kepada penukaran nilai secara automatik atau manual daripada satu jenis data kepada jenis data yang lain.

Contohnya, menukar rentetan seperti “123” kepada nombor 123.

Dalam JavaScript, paksaan jenis boleh terdiri daripada dua jenis:

• Paksaan Tersirat: Apabila JavaScript menukar nilai secara automatik.
• Paksaan Eksplisit: Apabila anda sengaja menukar nilai menggunakan fungsi atau pengendali terbina dalam.

Sebelum mempelajari tentang jenis paksaan yang berbeza, adalah penting untuk memahami jenis data utama JavaScript, kerana paksaan sentiasa melibatkan penukaran antara mereka.

Jenis Data dalam JavaScript

1. Jenis Primitif:
   • Nombor (cth., 42, 3.14, NaN)
   • Rentetan (cth., "hello", '123')
   • Boolean (cth., benar, salah)
   • Tidak ditentukan
   • Batal
   • Simbol
   • BigInt (cth., 123n)
2. Objek:
   • Tatasusunan, fungsi, objek, dsb.

Ketahui lebih lanjut tentang jenis data.

Sekarang, mari kita lihat jenis paksaan jenis.

Paksaan Jenis Tersirat

Paksa jenis tersirat berlaku apabila JavaScript menukar jenis nilai secara automatik kepada jenis lain untuk memadankan keperluan operasi atau ungkapan. Proses ini juga dikenali sebagai penukaran jenis.

Contoh Paksaan Jenis Tersirat

Contoh 1: Paksaan Rentetan dengan Operator

Dalam JavaScript, apabila anda menggunakan operator dan salah satu nilai ialah rentetan, JavaScript secara automatik menukar nilai lain kepada rentetan dan menggabungkannya. Proses ini dipanggil paksaan rentetan.

console.log(3 + "7"); 
// Output: "37" (3 is coerced to "3")

Contoh 2: Paksaan Berangka dengan Operator Aritmetik

Apabila anda menggunakan operator aritmetik seperti -, *, /, atau %, ia berfungsi dengan nombor. Jika anda memberi mereka sesuatu yang lain, itu bukan nombor (seperti rentetan), JavaScript menukarnya secara automatik kepada nombor sebelum menjalankan operasi. Ini dipanggil paksaan berangka.

console.log("7" - 3); 
// Output: 4 (string "7" coerced to number 7)

console.log(true * 3);
// Output: 3 (true coerced to 1)

Contoh 3: Paksaan dalam Bersyarat

Dalam JavaScript, apabila nilai digunakan dalam keadaan (seperti dalam pernyataan if atau while), nilai itu ditukar secara automatik kepada boolean (true atau false).

• Nilai benar: Apa-apa sahaja yang bukan 0, NaN, batal, tidak ditentukan, palsu atau rentetan kosong ("") dianggap benar.
• Nilai palsu: 0, NaN, null, undefined, false dan rentetan kosong ("") dianggap palsu.

console.log(3 + "7"); 
// Output: "37" (3 is coerced to "3")

Contoh 4: Kesaksamaan Longgar (==) dan Paksaan

Pengendali kesaksamaan longgar (==) membandingkan dua nilai dengan menukarkannya kepada jenis yang sama jika ia berbeza. Dalam erti kata lain, ia cuba menjadikan nilai sepadan dengan menukar satu atau kedua-duanya sebelum membandingkannya.

console.log("7" - 3); 
// Output: 4 (string "7" coerced to number 7)

console.log(true * 3);
// Output: 3 (true coerced to 1)

Paksaan Jenis Eksplisit

Paksa jenis eksplisit berlaku apabila anda sengaja menukar nilai daripada satu jenis kepada jenis lain, menggunakan fungsi atau pengendali terbina dalam.

Kaedah Biasa untuk Paksaan Eksplisit

Menukar kepada Rentetan

• Menggunakan String():

if ("Hello") { 
  console.log("This is truthy!"); // This will run because "Hello" is truthy 
}

if (27) { 
  console.log("This is also truthy!"); // This will run because 27 is truthy 
}

if (0) { 
  console.log("This won't run"); // This will not run because 0 is falsy 
}

if (null) { 
  console.log("This won't run either"); // This will not run because null is falsy 
}

if (!0) { 
  console.log("This will run"); // This will run because !0 is true (0 coerced to false, then negated) 
}

• Menggunakan .toString():

console.log(5 == "5"); 
// Output: true (string "5" coerced to number 5)

console.log(null == undefined); 
// Output: true (both are considered "empty")

• Penggabungan dengan Rentetan Kosong:

  console.log(String(37)); 
  // Output: "37"

Menukar kepada Nombor

• Menggunakan Nombor():

  console.log((37).toString()); 
  // Output: "37"

• Menggunakan Unary : Ini digunakan untuk menukar nilai kepada nombor.

  console.log(37 + ""); 
  // Output: "37"

• Menggunakan Unary -: Ini digunakan untuk menukar nilai kepada nombor dan menafikannya.

  console.log(Number("37")); 
  // Output: 37

• Menggunakan parseInt() atau parseFloat():

  // If the value is a string that can be converted to a number, it returns the number representation.
  console.log(+"37"); 
  // Output: 37

  // If the value is a boolean, true becomes 1 and false becomes 0.
  console.log(+true);   // Output: 1 (true becomes 1)
  console.log(+false);  // Output: 0 (false becomes 0)

  // If the value cannot be converted to a valid number, it returns NaN (Not-a-Number).
  console.log(+undefined);  // Output: NaN (undefined cannot be converted)
  console.log(+null);       // output: 0 (null is converted to 0)
  console.log(+{});         // Output: NaN (object cannot be converted)

Menukar kepada Boolean

• Menggunakan Boolean():

  // If the value is a number, it simply negates the number.
  console.log(-3);  // Output: -3 (negates the number)

  // If the value is a string that can be converted to a number, it first converts it and then negates it.
  console.log(-"37"); // Output: -37 (string "37" is converted to number and negated)

  // If the value is a boolean, true becomes -1 and false becomes -0.
  console.log(-true);   // Output: -1
  console.log(-false);  // Output: -0 

  // If the value cannot be converted to a valid number, it returns NaN (Not-a-Number).
  console.log(-undefined);  // Output: NaN (undefined cannot be converted)
  console.log(-null);       // Output: -0 (null is converted to 0 and negated to -0)
  console.log(-{});         // Output: NaN (object cannot be converted)

• Menggunakan Double Negation (!!): Double Negation ialah cara cepat untuk menukar sebarang nilai kepada boolean. Ia berfungsi dengan terlebih dahulu menafikan nilai (menggunakan operator tunggal !), yang menukar nilai kepada boolean (benar atau palsu), kemudian menafikannya sekali lagi untuk mendapatkan nilai boolean asal.

  // parseInt(): Converts a string to an integer.
  console.log(parseInt("123.45")); 
  // Output: 123

  // parseFloat(): Converts a string to a floating-point number.
  console.log(parseFloat("123.45")); 
  // Output: 123.45

Mengapa Paksaan Tersirat Boleh Menyebabkan Masalah?

Paksaan jenis tersirat boleh membuat kod mengelirukan, terutamanya untuk pemula atau semasa menyemak kod lama. Memandangkan paksaan berlaku secara automatik, sukar untuk mengetahui niat asalnya.

Mari kita fahami ini dengan beberapa contoh:

Keputusan yang tidak dijangka:

Paksaan tersirat boleh menyebabkan hasil yang tidak dijangka, terutamanya apabila bekerja dengan jenis data yang berbeza. Ini menyukarkan untuk meramalkan bagaimana ekspresi tertentu akan bertindak.

Contohnya:

  console.log(Boolean(0)); 
  // Output: false

  console.log(Boolean(1)); 
  // Output: true

  console.log(Boolean(""));  
  // Output: false (empty string is falsy)

Dalam contoh di atas, ungkapan pertama melakukan penggabungan rentetan kerana pengendali, tetapi yang kedua melakukan penolakan berangka kerana - mencetuskan paksaan kepada nombor.

Mencampurkan Jenis Data:

Apabila anda mencampurkan jenis data dalam operasi, ini boleh membawa kepada hasil yang tidak dijangka atau pepijat, terutamanya apabila anda menjangkakan satu jenis tetapi mendapat sesuatu yang lain.

Contohnya:

console.log(3 + "7"); 
// Output: "37" (3 is coerced to "3")

Penyahpepijatan Sukar:

Adalah sukar untuk mencari tempat penukaran yang tidak dijangka berlaku, menjadikan pepijat lebih sukar untuk dinyahpepijat.

Contohnya:

console.log("7" - 3); 
// Output: 4 (string "7" coerced to number 7)

console.log(true * 3);
// Output: 3 (true coerced to 1)

Nilai Palsu dan Perbandingan Jenis:

JavaScript mempunyai beberapa nilai palsu seperti 0, "", null, undefined, NaN, false. Apabila nilai ini digunakan dalam perbandingan atau operasi logik, penukaran jenis tersirat boleh menyebabkan kekeliruan. Jika anda tidak memahami cara JavaScript mentafsir nilai ini, ia boleh membawa kepada ralat yang tidak dijangka.

Contohnya:

if ("Hello") { 
  console.log("This is truthy!"); // This will run because "Hello" is truthy 
}

if (27) { 
  console.log("This is also truthy!"); // This will run because 27 is truthy 
}

if (0) { 
  console.log("This won't run"); // This will not run because 0 is falsy 
}

if (null) { 
  console.log("This won't run either"); // This will not run because null is falsy 
}

if (!0) { 
  console.log("This will run"); // This will run because !0 is true (0 coerced to false, then negated) 
}

Bagaimana Mengelakkan Masalah Paksaan Jenis?

Berikut ialah beberapa amalan terbaik untuk membantu anda mengelakkan masalah yang disebabkan oleh paksaan jenis tersirat:

Gunakan Kesaksamaan Tegas (===):

Lebih suka === daripada == untuk mengelakkan paksaan jenis yang tidak dijangka semasa perbandingan.

console.log(5 == "5"); 
// Output: true (string "5" coerced to number 5)

console.log(null == undefined); 
// Output: true (both are considered "empty")

Bersikap Eksplisit Apabila Menukar Jenis:

Gunakan kaedah penukaran jenis eksplisit untuk menentukan dengan jelas perubahan jenis yang diingini.

  console.log(String(37)); 
  // Output: "37"

Elakkan Jenis Campuran dalam Operasi:

Tulis kod yang tidak bergantung pada paksaan tersirat dengan memastikan operan adalah daripada jenis yang sama.

  console.log((37).toString()); 
  // Output: "37"

Sahkan Input:

Apabila anda menerima input atau data pengguna daripada API, pastikan anda mengesahkan dan menukarnya kepada jenis yang betul, seperti nombor atau rentetan.

  console.log(37 + ""); 
  // Output: "37"

Ketahui Kelakuan Tatasusunan dan Objek:

Tatasusunan dan objek berkelakuan berbeza apabila dipaksa menggunakan rentetan.

• Tatasusunan: Apabila dipaksa kepada rentetan, JavaScript menukar tatasusunan kepada rentetan dengan elemennya dicantumkan dengan koma. Contohnya:

  console.log(Number("37")); 
  // Output: 37

• Objek: Secara lalai, apabila objek dipaksa kepada rentetan, ia mengembalikan "[objek Objek]", melainkan objek itu mempunyai kaedah toString() tersuai. Contohnya:

  // If the value is a string that can be converted to a number, it returns the number representation.
  console.log(+"37"); 
  // Output: 37

  // If the value is a boolean, true becomes 1 and false becomes 0.
  console.log(+true);   // Output: 1 (true becomes 1)
  console.log(+false);  // Output: 0 (false becomes 0)

  // If the value cannot be converted to a valid number, it returns NaN (Not-a-Number).
  console.log(+undefined);  // Output: NaN (undefined cannot be converted)
  console.log(+null);       // output: 0 (null is converted to 0)
  console.log(+{});         // Output: NaN (object cannot be converted)

Kesimpulan

Paksaan tersirat dalam JavaScript boleh membantu, tetapi ia juga boleh menyebabkan tingkah laku yang tidak dijangka, menyebabkan pepijat dan menjadikan kod lebih sukar untuk dikekalkan. Untuk mengelakkan isu ini, gunakan kesaksamaan yang ketat, tukar jenis secara eksplisit dan sahkan input. Dengan cara ini, anda boleh menulis kod JavaScript yang lebih bersih, lebih dipercayai dan lebih mudah diselenggara.

Itu sahaja untuk hari ini.

Saya harap ia membantu.

Terima kasih kerana membaca.

Untuk lebih banyak kandungan seperti ini, klik di sini.

Ikuti saya di X(Twitter) untuk petua pembangunan web harian.

Lihat toast.log, sambungan penyemak imbas yang membolehkan anda melihat ralat, amaran dan log semasa ia berlaku di tapak anda — tanpa perlu membuka konsol penyemak imbas. Klik di sini untuk mendapatkan diskaun 25% untuk toast.log.

Teruskan Pengekodan!!

Atas ialah kandungan terperinci Taip Paksaan dalam JavaScript Diterangkan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!