5 cara untuk menjadikan JavaScript anda lebih berfungsi

Artikel ini akan memperkenalkan konsep pengaturcaraan berfungsi secara ringkas dan menerangkan lima cara untuk meningkatkan gaya fungsi kod JavaScript.

mata teras

Pengaturcaraan fungsional adalah paradigma pengaturcaraan yang menggunakan fungsi dan aplikasi mereka dan bukannya senarai arahan. Ia lebih abstrak dan berasal dari matematik. JavaScript amat sesuai untuk pengaturcaraan berfungsi kerana fungsi adalah jenis objek pertama.
Fungsi tulen adalah bahagian utama pengaturcaraan berfungsi. Memandangkan hujah -hujah yang sama, mereka sentiasa mengembalikan nilai yang sama dan tidak mengubah apa yang ada di luar skop fungsi. Mereka membuat kod anda lebih mudah untuk pelabuhan dan ujian.
Dalam pengaturcaraan berfungsi, pembolehubah harus tetap tidak berubah. Selepas menetapkan pembolehubah, ia harus kekal di seluruh program. Ini boleh dicapai dengan sentiasa mengisytiharkan pembolehubah menggunakan
• . const
Adalah disyorkan untuk menggunakan fungsi anak panah dan pengendali ternary dalam pengaturcaraan fungsi JavaScript. Fungsi anak panah mempunyai nilai pulangan tersirat, yang membantu memvisualisasikan pemetaan input-ke-output. Pengendali ternary adalah ungkapan yang selalu mengembalikan nilai, jadi berguna untuk memastikan nilai pulangan wujud.
Gunakan
• gelung dalam pengaturcaraan berfungsi harus dielakkan kerana ia bergantung kepada keadaan yang boleh berubah. Kaedah array rekursif dan lebih tinggi harus digunakan. Di samping itu, taipkan paksaan harus dielakkan untuk mengekalkan konsistensi jenis. Ini boleh dilakukan dengan menulis komen pengisytiharan jenis sebelum mengisytiharkan fungsi tersebut. for

Apakah pengaturcaraan berfungsi?

Pengaturcaraan fungsional adalah paradigma pengaturcaraan yang menggunakan fungsi dan aplikasi mereka, dan bukannya senarai arahan yang digunakan dalam bahasa pengaturcaraan

yang penting. Ini adalah gaya pengaturcaraan yang lebih abstrak, dengan akar dalam matematik -terutamanya cawangan matematik yang dipanggil Lambda Calculus, yang direka oleh Gereja Matematik Alonzo pada tahun 1936 sebagai model pengiraan formal. Ia terdiri daripada ungkapan dan fungsi yang memetakan satu ungkapan yang lain. Pada asasnya, inilah yang kita lakukan dalam pengaturcaraan berfungsi: Kami menggunakan fungsi untuk menukar nilai kepada nilai yang berbeza.

Pengarang artikel ini telah jatuh cinta dengan pengaturcaraan berfungsi pada tahun -tahun kebelakangan ini. Kami mula menggunakan perpustakaan JavaScript yang menggalakkan lebih banyak gaya berfungsi dan kemudian melompat terus ke dalam air dalam dengan belajar bagaimana menulis kod di Haskell.

Haskell adalah bahasa pengaturcaraan yang semata -mata berfungsi pada tahun 1990 -an, sama seperti Scala dan Clojure. Dengan bahasa -bahasa ini, anda akan dipaksa untuk mengekod dalam gaya berfungsi. Pembelajaran Haskell memberi kita pemahaman yang nyata tentang semua manfaat pengaturcaraan berfungsi.

JavaScript adalah bahasa multi-paradigma kerana ia boleh digunakan untuk memprogram dalam gaya yang penting, berorientasikan objek, atau berfungsi. Walau bagaimanapun, ia sesuai dengan gaya berfungsi, kerana fungsi adalah objek kelas pertama, yang bermaksud mereka boleh diberikan kepada pembolehubah. Ini juga bermakna bahawa fungsi boleh diluluskan sebagai hujah kepada fungsi lain (biasanya dipanggil panggilan balik) atau sebagai nilai pulangan untuk fungsi lain. Fungsi yang mengembalikan fungsi lain atau menerima fungsi lain sebagai parameter dipanggil fungsi pesanan lebih tinggi, dan mereka adalah bahagian asas pengaturcaraan berfungsi.

Pada tahun -tahun kebelakangan ini, pengaturcaraan JavaScript dalam gaya berfungsi telah menjadi semakin popular, terutama selepas kebangkitan React. React menggunakan API deklaratif yang sesuai untuk kaedah berfungsi, jadi pemahaman pepejal prinsip pengaturcaraan berfungsi akan meningkatkan kod React anda.

Mengapa pengaturcaraan berfungsi begitu baik?

Pendek kata, bahasa pengaturcaraan berfungsi sering membawa kepada kod yang ringkas, jelas dan elegan. Kod ini biasanya lebih mudah untuk diuji dan boleh dijalankan dalam persekitaran pelbagai threaded tanpa sebarang masalah.

Jika anda bercakap dengan banyak pengaturcara yang berbeza, anda mungkin mendapat pendapat yang berbeza mengenai pengaturcaraan fungsional dari semua orang - dari mereka yang benar -benar membencinya kepada mereka yang benar -benar menyukainya. Kami (pengarang artikel ini) berada di sisi "Love It", tetapi kita memahami sepenuhnya bahawa ia bukan hidangan semua orang, terutama kerana ia sangat berbeza dari cara kita biasanya mengajar.

Tetapi apabila anda menguasai pengaturcaraan berfungsi, dan apabila proses pemikiran mengklik di tempat, ia menjadi sifat kedua dan mengubah cara anda menulis kod anda.

Peraturan 1: Memurnikan fungsi anda

Bahagian utama pengaturcaraan berfungsi adalah untuk memastikan fungsi yang anda tulis adalah "tulen". Jika anda tidak biasa dengan istilah ini, fungsi tulen pada dasarnya memenuhi syarat -syarat berikut:

• Ia mempunyai ketelusan petikan. Ini bermakna, diberi hujah yang sama, fungsi itu akan sentiasa mengembalikan nilai yang sama. Mana -mana panggilan fungsi boleh digantikan dengan nilai pulangan, dan program ini masih akan berjalan dengan cara yang sama. Ia tidak mempunyai kesan sampingan. Ini bermakna fungsi tidak membuat sebarang perubahan di luar skop fungsi. Ini mungkin termasuk mengubah nilai global, rakaman ke konsol, atau mengemas kini DOM.
fungsi tulen

mesti mempunyai sekurang -kurangnya satu parameter, dan

mesti mengembalikan nilai. Jika anda berfikir dengan teliti, jika mereka tidak menerima sebarang parameter, mereka tidak akan mempunyai data untuk digunakan, dan jika mereka tidak mengembalikan nilai, apakah gunanya fungsi itu? Fungsi tulen mungkin tidak semestinya diperlukan pada mulanya, tetapi menggunakan fungsi yang tidak suci akan menyebabkan perubahan keseluruhan dalam program, mengakibatkan beberapa kesilapan logik yang serius! Contoh:

Dalam fungsi yang tidak suci, fungsi

bergantung kepada pembolehubah mutable

. Sebagai contoh, jika pembolehubah

// 不纯
let minimum = 21;
const checkAge = (age) => age >= minimum;

// 纯
const checkAge = (age) => {
    const minimum = 21;
    return age >= minimum;
};

dikemas kini kemudian dalam program, fungsi

mungkin mengembalikan boolean menggunakan input yang sama. checkAge minimum Katakan kita menjalankan kod berikut: minimum checkAge

Sekarang, katakan bahawa kemudian dalam kod, fungsi

mengemas kini nilai

hingga 18.

checkAge(20); // false

Kemudian, katakan kita menjalankan kod berikut:

// 不纯
let minimum = 21;
const checkAge = (age) => age >= minimum;

// 纯
const checkAge = (age) => {
    const minimum = 21;
    return age >= minimum;
};

Fungsi checkAge kini dinilai kepada nilai yang berbeza, walaupun input yang sama diberikan.

Fungsi tulen menjadikan kod anda lebih mudah ke pelabuhan kerana ia tidak bergantung pada nilai lain selain daripada apa -apa nilai yang disediakan sebagai parameter. Hakikat bahawa nilai pulangan tidak pernah berubah menjadikan fungsi tulen lebih mudah untuk diuji.

Menulis fungsi tulen secara konsisten juga menghapuskan kemungkinan mutasi dan kesan sampingan.

Mutasi adalah bendera merah besar dalam pengaturcaraan fungsional, dan jika anda ingin mengetahui lebih lanjut, anda boleh membaca tentangnya dalam panduan untuk tugasan dan mutasi yang berubah -ubah dalam JavaScript.

Untuk menjadikan fungsi anda lebih mudah ke pelabuhan, pastikan fungsi anda sentiasa murni.

Peraturan 2: Pastikan pembolehubah tidak berubah

Mengisytiharkan pembolehubah adalah salah satu perkara pertama yang mana -mana pengaturcara belajar. Ia menjadi remeh, tetapi sangat penting apabila menggunakan gaya pengaturcaraan berfungsi.

Salah satu prinsip utama pengaturcaraan berfungsi ialah apabila pembolehubah ditetapkan, ia akan tetap menjadi keadaan sepanjang program.

Ini adalah contoh yang paling mudah tentang bagaimana penugasan semula/pembolehubah pembolehubah dalam kod anda boleh menjadi bencana:

checkAge(20); // false

Jika anda berfikir dengan teliti, nilai -nilai n tidak boleh menjadi 10 dan 11;

Amalan pengekodan biasa dalam pengaturcaraan penting adalah menggunakan kod berikut untuk meningkatkan nilai:

checkAge(20); // true

Dalam matematik, pernyataan x = x 1 tidak logik kerana jika anda menolak x dari kedua -dua belah pihak, anda akan mendapat 0 = 1, yang jelas tidak betul.

Oleh itu, di Haskell, anda tidak boleh memberikan pembolehubah kepada nilai dan kemudian menetapkan semula kepada nilai lain. Untuk mencapai ini dalam JavaScript, anda harus mengikuti peraturan yang selalu menggunakan

untuk mengisytiharkan pembolehubah. const

Peraturan 3: Gunakan fungsi anak panah

Dalam matematik, konsep fungsi adalah konsep pemetaan satu set nilai kepada yang lain. Angka berikut menunjukkan fungsi yang memetakan nilai yang ditetapkan di sebelah kiri ke nilai yang ditetapkan di sebelah kanan melalui kuasa dua:

Ini adalah bagaimana anda menulisnya dalam matematik menggunakan notasi anak panah: f: x → x². Ini bermakna fungsi F memetakan nilai x ke x².

kita boleh menulis fungsi ini dengan cara yang sama menggunakan fungsi anak panah:

Ciri utama menggunakan gaya berfungsi dalam JavaScript adalah penggunaan fungsi anak panah dan bukannya fungsi biasa. Sudah tentu, ini merebak ke gaya, menggunakan fungsi anak panah dan bukannya fungsi biasa sebenarnya tidak mempengaruhi tahap "berfungsi" kod.

const n = 10;
n = 11; // TypeError: "Attempted to assign to readonly property."

Walau bagaimanapun, salah satu perkara yang paling sukar untuk menyesuaikan diri apabila menggunakan gaya pengaturcaraan berfungsi adalah cara berfikir tentang setiap fungsi sebagai input pemetaan ke output. Tidak ada proses yang dipanggil. Kami mendapati bahawa menggunakan fungsi anak panah dapat membantu kita memahami proses fungsi dengan lebih baik.

Fungsi anak panah mempunyai nilai pulangan tersirat, yang membantu menggambarkan peta ini.

Struktur fungsi anak panah -terutama nilai pulangan tersirat mereka -membantu menulis fungsi tulen, kerana struktur mereka sebenarnya "input dipetakan ke output":

// 不纯
let minimum = 21;
const checkAge = (age) => age >= minimum;

// 纯
const checkAge = (age) => {
    const minimum = 21;
    return age >= minimum;
};

Satu lagi perkara yang kita suka menekankan, terutamanya ketika menulis fungsi anak panah, adalah menggunakan pengendali ternary. Jika anda tidak biasa dengan pengendali ternary, mereka adalah penyataan if...else dalam bentuk condition ? value if true : value if false.

Anda boleh membaca lebih lanjut mengenai mereka dalam petua cepat: Cara menggunakan pengendali tripartit di JavaScript.

Salah satu sebab utama untuk menggunakan pengendali ternary dalam pengaturcaraan berfungsi adalah keperluan else pernyataan. Program mesti tahu apa yang perlu dilakukan jika keadaan asal tidak dipenuhi. Sebagai contoh, Haskell menguatkuasakan pernyataan , dan jika tidak else pernyataan diberikan, ia mengembalikan ralat. else

Satu lagi sebab untuk menggunakan pengendali ternary ialah mereka adalah ungkapan yang selalu mengembalikan nilai, bukannya

pernyataan yang boleh digunakan untuk melakukan operasi yang mungkin mempunyai kesan sampingan. Ini amat berguna untuk fungsi anak panah, kerana ia bermakna anda dapat memastikan nilai pulangan wujud dan menyimpan input imej ke peta output. Sekiranya anda tidak pasti tentang nuansa antara pernyataan dan ungkapan, panduan mengenai pernyataan dan ekspresi adalah baik dibaca. if-else

Untuk menggambarkan kedua -dua syarat ini, berikut adalah contoh fungsi anak panah mudah menggunakan pengendali ternary:

Fungsi

checkAge(20); // false

akan mengembalikan nilai "makan" atau "tidur" berdasarkan nilai parameter action. state

Jadi, ringkasnya: Apabila membuat kod anda lebih berfungsi, anda harus mengikuti kedua -dua peraturan ini:

Menulis fungsi menggunakan notasi anak panah
Gantikan pernyataan
• dengan pengendali ternary if...else

Peraturan 4: Padam gelung

Memandangkan menulis kod berulang menggunakan

sangat biasa dalam pengaturcaraan, nampaknya pelik mengatakan bahawa anda ingin mengelakkannya. Sebenarnya, ketika kami mula -mula mendapati bahawa Haskell tidak mempunyai apa -apa jenis operasi gelung for, kami mengalami kesulitan memahami bagaimana untuk melaksanakan beberapa operasi standard. Walau bagaimanapun, terdapat beberapa sebab yang sangat baik mengapa for gelung tidak muncul dalam pengaturcaraan berfungsi, dan kami dengan cepat mendapati bahawa setiap jenis lelaran dapat dilaksanakan tanpa menggunakan gelung for. for

tidak digunakan

Sebab yang paling penting mengapa gelung dilingkari adalah bahawa mereka bergantung pada keadaan yang boleh berubah. Mari lihat fungsi jumlah yang mudah: for

checkAge(20); // true

seperti yang anda lihat, kita perlu menggunakan

dalam gelung for sendiri dan dalam pembolehubah yang kita kemas kini dalam gelung for. let

Seperti yang dinyatakan sebelum ini, ini biasanya merupakan amalan buruk dalam pengaturcaraan berfungsi, kerana semua pembolehubah dalam pengaturcaraan berfungsi harus tidak berubah.

Jika kita mahu menulis kod di mana semua pembolehubah tidak berubah, kita boleh menggunakan rekursi:

const n = 10;
n = 11; // TypeError: "Attempted to assign to readonly property."

Seperti yang anda lihat, tiada pembolehubah dikemas kini.

ahli matematik di kalangan kita pasti akan mengetahui bahawa semua kod ini tidak perlu, kerana kita hanya boleh menggunakan formula penjumlahan pintar 0.5*n*(n 1). Tetapi ini adalah cara yang baik untuk menggambarkan perbezaan antara kebolehubahan gelung dan rekursi. for Walau bagaimanapun, rekursi bukanlah satu -satunya penyelesaian kepada masalah kebolehubahan, terutamanya apabila berurusan dengan tatasusunan. JavaScript mempunyai banyak kaedah array yang lebih tinggi di atas yang meleleh melalui nilai dalam array tanpa mengubah sebarang pembolehubah.

Sebagai contoh, katakan kita mahu menambah 1 ke setiap nilai dalam array. Menggunakan kaedah penting dan gelung

, fungsi kami mungkin kelihatan seperti ini:

for Walau bagaimanapun, kita boleh menggunakan kaedah terbina dalam JavaScript dan menulis fungsi seperti ini:

// 不纯
let minimum = 21;
const checkAge = (age) => age >= minimum;

// 纯
const checkAge = (age) => {
    const minimum = 21;
    return age >= minimum;
};

Jika anda tidak pernah melihat fungsi map sebelum ini, ia pasti bernilai mengetahui tentang mereka-dan semua kaedah pelbagai pesanan tinggi terbina dalam JavaScript, seperti

, terutamanya jika anda benar-benar mempunyai rasa pengaturcaraan berfungsi dalam kepentingan JavaScript. Anda boleh mengetahui lebih lanjut mengenai mereka dalam kaedah array yang tidak berubah: Cara menulis kod JavaScript yang sangat jelas.

checkAge(20); // false

Haskell tidak mempunyai gelung map sama sekali. Untuk menjadikan JavaScript anda lebih berfungsi, cuba elakkan menggunakan gelung filter dengan menggunakan kaedah array rekursif dan terbina dalam.

for Peraturan 5: Elakkan Jenis Mandatori for

Adalah mudah untuk melupakan kepentingan jenis data apabila pengaturcaraan dalam bahasa seperti JavaScript yang tidak memerlukan pengisytiharan jenis. Tujuh jenis data primitif yang digunakan dalam JavaScript adalah:

nombor

String

• boolean
• Simbol
• bigint
• Undefined
• null
• Haskell adalah bahasa yang sangat ditaip yang memerlukan pengisytiharan jenis. Ini bermakna sebelum sebarang fungsi, anda perlu menggunakan sistem Hindley-Milner untuk menentukan jenis data masuk dan output jenis data.
• Contoh:

Ini adalah fungsi yang sangat mudah yang menambah dua nombor (x dan y) bersama -sama. Untuk setiap fungsi, termasuk fungsi yang sangat mudah seperti ini, nampaknya agak tidak masuk akal untuk menjelaskan jenis data kepada program ini, tetapi ini akhirnya membantu menunjukkan bagaimana fungsi itu dijangka berfungsi dan apa yang diharapkan dapat kembali. Ini menjadikan kod lebih mudah untuk debug, terutamanya jika kod menjadi lebih kompleks.

Pengisytiharan taip mengikuti struktur berikut:

checkAge(20); // true

Kekuatan jenis boleh menjadi masalah besar apabila menggunakan JavaScript, yang mempunyai pelbagai helah yang boleh digunakan (walaupun penyalahgunaan ) untuk memintas ketidakkonsistenan dalam jenis data. Berikut adalah petua yang paling biasa dan bagaimana untuk mengelakkannya:

sambungan. "Hello" 5 dinilai sebagai "hello5", yang tidak konsisten. Jika anda ingin menyusun rentetan dengan nilai angka, anda harus menulis "Hello" String (5).

const n = 10;
n = 11; // TypeError: "Attempted to assign to readonly property."

pernyataan boolean dan 0. Dalam JavaScript, nilai 0 dalam pernyataan bersamaan dengan palsu. Ini boleh membawa kepada teknik pengaturcaraan malas yang mengabaikan memeriksa sama ada data berangka adalah sama dengan 0.

Contoh:

• // 不纯
  let minimum = 21;
  const checkAge = (age) => age >= minimum;
  
  // 纯
  const checkAge = (age) => {
      const minimum = 21;
      return age >= minimum;
  };

  Ini adalah fungsi yang menilai sama ada nombor adalah nombor juga. Ia menggunakan simbol ! untuk membuang hasil n % 2 kepada boolean, tetapi hasil n % 2 bukan boolean, tetapi nombor (0 atau 1).

  Petua Seperti ini, sementara kelihatan pandai dan mengurangkan jumlah kod yang anda tulis, mereka memecahkan peraturan konsistensi jenis pengaturcaraan berfungsi. Oleh itu, cara terbaik untuk menulis fungsi ini adalah seperti berikut:

  checkAge(20); // false

  Satu lagi konsep penting adalah untuk memastikan bahawa semua nilai data dalam array adalah jenis yang sama. JavaScript tidak menguatkuasakan ini, tetapi jika tidak ada jenis yang sama, ia boleh menyebabkan masalah apabila anda ingin menggunakan kaedah array pesanan yang lebih tinggi.

  Sebagai contoh, fungsi produk yang mengalikan semua nombor dalam array dan mengembalikan hasilnya boleh ditulis dengan anotasi pengisytiharan jenis berikut:

  checkAge(20); // true

  Di sini, pengisytiharan jenis jelas menyatakan bahawa input fungsi adalah array yang mengandungi unsur -unsur nombor jenis, tetapi ia hanya mengembalikan satu nombor. Perisytiharan jenis jelas menggambarkan input dan output yang diharapkan dari fungsi ini. Jelas sekali, fungsi ini tidak akan berfungsi jika array mengandungi lebih daripada sekadar nombor.

  Haskell adalah bahasa yang sangat ditaip, manakala JavaScript adalah bahasa yang lemah, tetapi untuk menjadikan JavaScript anda lebih berfungsi, anda harus menulis komen pengisytiharan jenis sebelum mengisytiharkan fungsi anda dan pastikan untuk mengelakkan pintasan yang dipaksa.

  kita juga harus menyebut di sini bahawa jika anda mahukan alternatif yang sangat ditaip kepada JavaScript yang akan menguatkuasakan konsistensi jenis untuk anda, anda boleh beralih kepada TypeScript.

  Kesimpulan

  semuanya, lima peraturan berikut akan membantu anda melaksanakan kod fungsi:

  • Pastikan fungsi anda PURE .
  • Sentiasa mengisytiharkan pembolehubah dan fungsi menggunakan const .
  • Gunakan anak panah untuk fungsi tersebut.
  • Elakkan menggunakan for gelung .
  • Gunakan anotasi pengisytiharan jenis dan elakkan jenis jalan pintas yang dipaksa.

  Walaupun peraturan ini tidak menjamin bahawa kod anda semata -mata berfungsi, mereka akan menjadikannya lebih berfungsi secara besar -besaran dan membantu menjadikannya lebih bersih, lebih jelas dan lebih mudah untuk diuji.

  Kami benar -benar berharap peraturan ini akan membantu anda sebanyak mungkin! Kami berdua adalah peminat besar pengaturcaraan berfungsi dan kami sangat mengesyorkan bahawa mana -mana pengaturcara menggunakannya.

  Jika anda ingin menggali lebih mendalam ke dalam JavaScript berfungsi, kami sangat mengesyorkan anda membaca "Kebanyakan panduan yang mencukupi untuk pengaturcaraan berfungsi oleh Profesor Frisby, yang boleh didapati secara dalam talian secara percuma. Jika anda ingin pergi keluar untuk belajar Haskell, kami mengesyorkan menggunakan Tutorial Interaktif Haskell dan membaca buku yang sangat baik Belajar Haskell untuk faedah yang lebih besar, yang juga boleh didapati secara percuma dalam talian.

  soalan yang sering ditanya mengenai pengaturcaraan fungsional JavaScript

  Apakah pengaturcaraan berfungsi dalam JavaScript? Pengaturcaraan berfungsi adalah paradigma pengaturcaraan yang merawat pengiraan sebagai penilaian fungsi matematik dan mengelakkan perubahan keadaan dan data yang boleh berubah. Dalam JavaScript, ia melibatkan penggunaan fungsi sebagai warga kelas pertama dan mengelakkan kesan sampingan.

  Apakah fungsi kelas pertama dalam JavaScript? Fungsi kelas pertama dalam JavaScript bermakna fungsi itu dianggap sama seperti pembolehubah lain. Mereka boleh diberikan nilai kepada pembolehubah, diluluskan sebagai parameter ke fungsi lain, dan dikembalikan sebagai nilai dari fungsi lain.

  Apakah invarians dalam pengaturcaraan berfungsi? Invariance bermaksud bahawa apabila objek dibuat, ia tidak boleh diubah. Dalam konteks pengaturcaraan fungsi JavaScript, ini bermakna mengelakkan mengubahsuai pembolehubah atau struktur data selepas memulakannya.

  Apakah fungsi pesanan yang lebih tinggi? Fungsi pesanan yang lebih tinggi adalah fungsi yang mengambil fungsi lain sebagai parameter atau pulangan fungsi sebagai hasil. Mereka menyokong kombinasi fungsi, menjadikannya lebih mudah untuk membuat kod modular dan boleh diguna semula.

  Adakah terdapat sebarang perpustakaan/kerangka yang memudahkan pengaturcaraan berfungsi dalam JavaScript? Ya, beberapa perpustakaan dan kerangka (seperti Ramda dan Lodash) menyediakan utiliti dan fungsi yang menyokong konsep pengaturcaraan fungsi JavaScript. Mereka boleh membantu memudahkan dan meningkatkan amalan pengaturcaraan berfungsi.

Atas ialah kandungan terperinci 5 cara untuk menjadikan JavaScript anda lebih berfungsi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!