Teknik meminjam dari bahasa yang sangat ditaip di JS

Artikel ini membincangkan cara menggunakan bahasa yang sangat ditaip dalam kod JavaScript. Teknik ini bukan sahaja mengurangkan kesilapan kod, tetapi juga mengurangkan jumlah kod. Walaupun artikel ini mengambil JavaScript sebagai contoh, petua ini juga digunakan untuk kebanyakan bahasa yang lemah.

Mata utama:

Petua memohon bahasa yang sangat ditaip dalam JavaScript dapat mengurangkan pepijat dan mengurangkan jumlah kod.
"peraturan jenis yang konsisten" (yang menentukan bahawa semua nilai hanya mempunyai satu jenis) boleh digunakan untuk JavaScript untuk meningkatkan kualiti kod dan kebolehbacaan.
Pemeriksaan jenis dan penukaran jenis hendaklah dilakukan di pinggir modul untuk mengelakkan pepijat yang disebabkan oleh pemutus jenis tersirat dan memudahkan kod.
Penggunaan "Null" dan "Undefined" dalam JavaScript harus dipertimbangkan dengan teliti, terutama ketika berurusan dengan jenis rujukan seperti objek dan tatasusunan.
TypeScript adalah alat yang disyorkan untuk menguatkuasakan semantik yang lebih kuat di JavaScript, dengan kelebihan seperti pengesanan ralat awal dan dokumentasi kod yang lebih jelas.

sistem jenis javascript Pertama, mari kita cepat semak bagaimana sistem jenis data JavaScript berfungsi. JavaScript membahagikan nilai -nilainya menjadi dua kategori:

Jenis primitif
• seperti rentetan, nombor, dan boolean. Apabila anda menetapkan jenis asal kepada pemboleh ubah, nilai baru sentiasa dibuat, yang merupakan salinan nilai yang diberikan.
Jenis rujukan
• , seperti objek dan array. Jenis rujukan tugasan selalu menyalin rujukan yang sama. Untuk menjelaskan ini, mari kita lihat contoh kod berikut:

Apabila kita menukar A, pembolehubah B juga berubah kerana mereka semua merujuk kepada array yang sama. Ini adalah bagaimana semua jenis rujukan berfungsi. JavaScript tidak menguatkuasakan apa -apa jenis, yang bermaksud bahawa mana -mana pembolehubah boleh menyimpan sebarang jenis data pada bila -bila masa. Selebihnya artikel ini membincangkan kelemahan pendekatan ini dan bagaimana untuk menggunakan helah mudah dalam menguatkuasakan jenis untuk menulis kod JavaScript yang lebih baik.

<code class="language-javascript">var a = [];
var b = a;

a.push('Hello');</code>

Memperkenalkan peraturan jenis yang konsisten

Peraturan jenis yang konsisten secara teorinya mudah: semua nilai harus mempunyai hanya satu jenis. Bahasa yang sangat ditaip menguatkuasakan peraturan ini di peringkat pengkompil, dan mereka tidak membenarkan anda mencampur dan memadankan jenis mengikut kehendak. Jenis lemah memberi kita banyak kebebasan. Satu contoh yang sama adalah menggabungkan nombor ke dalam rentetan. Anda tidak perlu melakukan penukaran jenis yang membosankan seperti dalam bahasa seperti C. Jangan risau, saya tidak akan memberitahu anda untuk melepaskan semua kemudahan. Peraturan jenis yang konsisten hanya memerlukan anda untuk memberi perhatian kepada bagaimana pembolehubah dan fungsi berkelakuan, jadi kod anda akan diperbaiki.

Jenis dalam pembolehubah

Pertama, mari kita lihat bagaimana peraturan itu digunakan untuk pembolehubah. Ia sangat mudah: Pembolehubah anda harus selalu mempunyai satu jenis.

<code class="language-javascript">var a = [];
var b = a;

a.push('Hello');</code>

Contoh di atas menunjukkan masalah. Peraturan ini menghendaki kita berpura -pura bahawa baris terakhir kod dalam contoh ini melemparkan ralat kerana ketika kita mula -mula menentukan teks berubah -ubah, kita memberikan nilai jenis rentetan, dan sekarang kita memberikan nombor kepadanya. Peraturan jenis yang konsisten bermakna kita tidak membenarkan menukar jenis pembolehubah dengan cara ini. Lebih mudah untuk menyimpulkan kod anda apabila pembolehubah anda konsisten. Ia terutamanya membantu dengan fungsi yang lebih panjang di mana mudah untuk mengabaikan sumber pembolehubah. Apabila bekerja di pangkalan kod yang tidak mengikuti peraturan ini, saya secara tidak sengaja menyebabkan banyak kesilapan kerana saya melihat pembolehubah yang diisytiharkan dan kemudian mengandaikan ia akan tetap jenis yang sama - kerana mari kita hadapi, masuk akal, bukan? Biasanya tidak ada alasan untuk menetapkan jenis yang berbeza kepada pemboleh ubah yang sama.

Taipkan parameter fungsi

Peraturan yang sama juga berlaku di sini. Parameter fungsi juga harus konsisten. Contoh ralat:

<code class="language-javascript">var text = 'Hello types';

// 错误！不要这样做！
text = 1;</code>

apa masalahnya di sini? Secara umumnya dipercayai bahawa logik cawangan berdasarkan pemeriksaan jenis bukanlah amalan yang baik. Terdapat beberapa pengecualian untuk ini, tetapi biasanya pilihan yang lebih baik adalah menggunakan polimorfisme. Anda harus cuba memastikan bahawa parameter fungsi juga mempunyai hanya satu jenis. Jika anda lupa untuk mempertimbangkan jenis yang berbeza, ia mengurangkan kemungkinan masalah dan menjadikan kod lebih mudah kerana anda tidak perlu menulis kod untuk mengendalikan semua jenis kes yang berbeza. Cara yang lebih baik untuk menulis fungsi jumlah adalah seperti berikut:

<code class="language-javascript">function sum(a, b) {
  if (typeof a === 'string') {
    a = 1;
  }

  return a + b;
}</code>

maka anda mengendalikan jenis pemeriksaan dalam kod panggilan dan bukannya dalam fungsi. Seperti yang dapat dilihat dari atas, fungsi ini lebih mudah sekarang. Walaupun kita perlu memindahkan jenis pemeriksaan di tempat lain, lebih awal kita melaksanakannya dalam kod, semakin baik ia akan berfungsi. Kami akan membincangkan penggunaan pemeriksaan jenis dan jenis kemudian dalam artikel ini, termasuk bagaimana pemeriksaan jenis boleh dengan mudah dilepaskan jika digunakan dengan tidak betul.

taip nilai pulangan fungsi

Ini berkaitan dengan dua yang lain: fungsi anda harus selalu mengembalikan nilai jenis yang sama. Kita boleh memberikan contoh angularjs di sini. AngularJS menyediakan fungsi yang menukarkan teks kepada huruf kecil, dipanggil angular.lowercase. Terdapat juga fungsi standard, string.prototype.tolowerCase. Kita dapat membandingkan tingkah laku mereka untuk lebih memahami bahagian peraturan ini:

<code class="language-javascript">function sum(a, b) {
  return a + b;
}</code>

Variabel A akan mengandungi apa yang anda harapkan: "Hello Jenis". Tetapi apa yang akan disertakan? Adakah ia akan menjadi rentetan kosong? Adakah fungsi itu akan membuang pengecualian? Atau mungkin ia hanya batal? Dalam kes ini, nilai B adalah batal. Perhatikan bahawa sukar untuk meneka dengan segera apa hasilnya - kami mempunyai tiga hasil yang mungkin dari awal. Untuk fungsi sudut, untuk nilai bukan rentetan, ia akan sentiasa mengembalikan input. Sekarang, mari kita lihat bagaimana fungsi terbina dalam berkelakuan:

<code class="language-javascript">var a = [];
var b = a;

a.push('Hello');</code>

Hasil panggilan pertama adalah sama, tetapi panggilan kedua melemparkan pengecualian. Fungsi terbina dalam mengikuti peraturan jenis yang konsisten dan tidak membenarkan jenis parameter yang salah. Nilai pulangan sentiasa rentetan. Oleh itu, kita boleh mengatakan bahawa fungsi terbina dalam lebih baik, tetapi anda mungkin tertanya-tanya bagaimana untuk melakukan ini? Mari kita pertimbangkan kes penggunaan biasa untuk fungsi tersebut. Kami menggunakannya pada satu ketika dalam kod kami untuk menukar rentetan ke huruf kecil. Seperti yang sering berlaku dalam kod JavaScript, kita tidak boleh 100% menentukan sama ada input kita sentiasa rentetan. Tidak mengapa, kerana kami adalah pengaturcara yang baik dan kami menganggap bahawa kod kami tidak salah. Apa yang berlaku jika kita menggunakan fungsi AngularJS yang tidak mematuhi peraturan ini? Nilai bukan rentetan melaluinya tanpa sebarang masalah. Ia mungkin lulus beberapa fungsi, dan kami juga boleh menghantarnya melalui panggilan XMLHTTPREQUEST. Sekarang nilai yang salah ada di pelayan kami dan akhirnya pergi ke pangkalan data. Anda dapat melihat apa yang saya maksudkan, bukan? Jika kita menggunakan fungsi terbina dalam yang mematuhi peraturan, kita akan segera mencari kesilapan pada masa itu. Setiap kali anda menulis fungsi, pastikan jenis yang dikembalikannya konsisten. Contoh yang buruk ditunjukkan di bawah:

<code class="language-javascript">var text = 'Hello types';

// 错误！不要这样做！
text = 1;</code>

Begitu juga, seperti pembolehubah dan parameter, jika kita mempunyai fungsi sedemikian, kita tidak boleh membuat andaian mengenai tingkah lakunya. Kita perlu gunakan jika untuk menyemak jenis yang mengembalikan nilai. Kami mungkin melupakannya pada satu ketika dan kemudian kesilapan lain akan muncul di tangan kami. Kami boleh menulis semula dalam beberapa cara, berikut adalah penyelesaian kepada masalah ini:

<code class="language-javascript">function sum(a, b) {
  if (typeof a === 'string') {
    a = 1;
  }

  return a + b;
}</code>

Kali ini kami memastikan bahawa semua laluan mengembalikan rentetan. Kini lebih mudah untuk menyimpulkan hasil fungsi tersebut.

null dan undefined adalah khas

Setakat ini, kami sebenarnya hanya membincangkan genre asal. Anda harus mengikuti peraturan yang sama ketika datang ke objek dan tatasusunan, tetapi anda perlu mengetahui dua kes khas. Apabila memproses jenis rujukan, kadang -kadang perlu untuk menunjukkan bahawa tiada nilai. Contoh yang baik ialah Document.GetElementById. Jika elemen yang sepadan tidak dijumpai, ia akan kembali null. Inilah sebabnya kami menganggap Null sebagai berkongsi jenis dengan sebarang objek atau array, tetapi hanya objek atau tatasusunan tersebut. Anda harus mengelakkan kembali null dari fungsi yang boleh mengembalikan nilai asal seperti nombor. Undefined juga boleh dianggap sebagai "bernilai" yang dirujuk. Untuk kebanyakan tujuan ia boleh dianggap sama dengan batal, tetapi null lebih baik kerana semantiknya dalam bahasa berorientasikan objek lain.

array dan null

Apabila menggunakan tatasusunan, anda juga harus menganggap bahawa tatasusunan kosong biasanya lebih baik daripada null. Walaupun tatasusunan adalah jenis rujukan, anda boleh menggunakan null dengan mereka, biasanya lebih masuk akal untuk mengembalikan array kosong. Mari kita lihat contoh berikut:

<code class="language-javascript">var a = [];
var b = a;

a.push('Hello');</code>

Ini mungkin salah satu penggunaan array yang paling biasa. Anda mendapat array dari fungsi dan berulang di atasnya untuk melaksanakan operasi lain. Apa yang berlaku kepada kod di atas jika getListOfitems mengembalikan null apabila tiada projek? Ia melemparkan kesilapan kerana null tidak mempunyai panjang (atau atribut lain). Apabila anda mempertimbangkan menggunakan array seperti ini, atau bahkan list.foreach atau list.map, anda dapat melihat bahawa mengembalikan array kosong apabila tidak ada nilai biasanya idea yang baik.

jenis pemeriksaan dan jenis penukaran

Mari kita ketahui lebih lanjut mengenai pemeriksaan jenis dan penukaran jenis dengan lebih terperinci. Bilakah anda perlu melakukan pemeriksaan jenis? Bilakah anda harus melakukan penukaran jenis?

Taip penukaran

Matlamat pertama penukaran jenis

adalah untuk memastikan nilai anda adalah jenis yang betul. Nilai harus menjadi nombor dan bukan rentetan, dan sebagainya. Matlamat kedua adalah bahawa anda hanya perlu menukar nilai sekali. Tempat terbaik untuk melakukan penukaran jenis adalah di sumber. Sebagai contoh, jika anda mendapat data dari pelayan, anda harus melakukan apa -apa penukaran jenis yang diperlukan dalam fungsi yang memproses data yang diterima. Data parsing dari DOM adalah tempat yang sangat biasa di mana kesilapan mula berlaku. Katakan anda mempunyai kotak teks yang mengandungi nombor dan anda mahu membacanya. Atau, ia mungkin menjadi sifat dalam beberapa elemen HTML, dan ia tidak perlu menjadi input pengguna.

<code class="language-javascript">var text = 'Hello types';

// 错误！不要这样做！
text = 1;</code>

Oleh kerana nilai -nilai yang anda dapat dari DOM biasanya rentetan, adalah penting untuk menaip menukar ketika membacanya. Untuk beberapa tahap, anda boleh memikirkannya sebagai "kelebihan" modul. Data masuk ke modul JavaScript anda dengan membaca fungsinya, jadi ia mesti menukar data ke format yang betul. Dengan melakukan penukaran jenis di pinggir modul, kami memastikan bahawa ia tidak perlu diproses secara dalaman. Ini sangat mengurangkan kemungkinan pemutus jenis tersirat yang menyebabkan kesilapan. Ia juga membolehkan kita menulis kod kurang kerana kita tidak membenarkan nilai yang salah untuk memasukkan modul dari tepi.

<code class="language-javascript">function sum(a, b) {
  if (typeof a === 'string') {
    a = 1;
  }

  return a + b;
}</code>

typeof and type check

Anda hanya perlu menggunakan TypeOf untuk pengesahan, bukan berdasarkan logik cawangan jenis. Terdapat beberapa pengecualian untuk ini, tetapi ia adalah peraturan yang baik. Mari lihat dua contoh:

<code class="language-javascript">function sum(a, b) {
  return a + b;
}</code>

Ini adalah contoh menggunakan TypeOf untuk pengesahan. Kami memastikan bahawa parameter yang diserahkan kepada fungsi adalah jenis yang betul. Walau bagaimanapun, contoh berikut menunjukkan logik cawangan berdasarkan jenis.

<code class="language-javascript">var a = [];
var b = a;

a.push('Hello');</code>

Jangan buat ini. Walaupun mungkin perlu untuk melakukannya kadang -kadang, ini sering menjadi tanda reka bentuk yang buruk. Jika anda mendapati diri anda melaksanakan logik ini dengan kerap, anda mungkin perlu menukar nilai ke jenis yang betul pada awal kod anda. Jika anda akhirnya menggunakan banyak jenis dalam kod anda, ini mungkin bermakna anda mungkin perlu menukar nilai yang anda ingin bandingkan. Pemeriksaan jenis sering tersebar, yang biasanya merupakan tanda jenis yang direka dengan baik. Seperti yang dinyatakan sebelum ini, anda harus mencuba penukaran jenis di tepi modul, kerana ia membolehkan anda untuk mengelakkan jenis Cascade. Jika anda menukar seawal mungkin, tiada fungsi yang anda panggil kemudian tidak perlu melakukan pemeriksaan jenis atau penukaran jenis. Ini juga terpakai kepada objek: Jika anda mendapati diri anda menggunakan Instanceof untuk banyak cek atau memeriksa sifat -sifat pada objek, ini bermakna anda mungkin harus membina data dengan cara yang berbeza. Peraturan yang sama seperti TypeOf juga terpakai kepada Instanceof: Anda harus cuba mengelakkannya, kerana ia mungkin tanda reka bentuk yang buruk. Walau bagaimanapun, terdapat satu keadaan yang tidak dapat dielakkan:

<code class="language-javascript">var text = 'Hello types';

// 错误！不要这样做！
text = 1;</code>

Jika kod anda perlu mengendalikan jenis pengecualian khusus, Instanceof biasanya pilihan yang baik, kerana tangkapan JavaScript tidak membenarkan perbezaan mengikut jenis seperti beberapa bahasa lain. Dalam kebanyakan kes lain, anda harus cuba mengelakkan contoh.

Kesimpulan

Seperti yang telah kita temukan, jenis JavaScript yang lemah membawa kita kebebasan yang besar, tetapi kita juga harus berhati -hati. Jika tidak, kita akan berakhir dengan kekacauan genre tanpa makna. Dengan memastikan kod kami mengikuti peraturan jenis yang konsisten, kami dapat mengelakkan banyak masalah. Lebih mudah untuk menyimpulkan kod kita apabila kita mengetahui jenisnya. Kami tidak perlu membina banyak jenis pemeriksaan dalam kod kami untuk mengelakkan kesilapan. Ini seolah -olah sukar jika anda tidak menggunakan bahasa yang sangat ditaip, tetapi ia banyak membayar apabila anda perlu debug atau mengekalkan kod anda. Untuk maklumat lanjut mengenai topik ini, saya cadangkan anda menyemak TypeScript. Ia adalah bahasa seperti JavaScript, tetapi ia menambah semantik jenis yang lebih kuat kepada bahasa. Ia juga mempunyai pengkompil yang meludahkan kesilapan apabila anda cuba melakukan beberapa perkara bodoh seperti mencampurkan dan memadankan jenis.

FAQs mengenai bahasa yang sangat ditaip dalam JavaScript (FAQ)

Apakah perbezaan antara bahasa yang sangat ditaip dan bahasa yang lemah?

Bahasa yang sangat ditaip merujuk kepada bahasa di mana pembolehubah terikat kepada jenis data tertentu. Contohnya termasuk Java dan C. Sebaliknya, bahasa yang lemah ditaip seperti JavaScript membenarkan pembolehubah untuk memegang sebarang jenis data dan menaip penukaran secara automatik jika perlu. Jika ditangani secara tidak wajar, fleksibiliti ini boleh membawa kepada hasil yang tidak dijangka.

Bagaimana untuk menguatkuasakan menaip kuat dalam JavaScript?

JavaScript sendiri adalah bahasa yang lemah, tetapi anda boleh menguatkuasakan jenis yang kuat menggunakan TypeScript, superset javascript yang ditaip secara statik. TypeScript menambah jenis statik ke JavaScript, yang membolehkan pemeriksaan jenis pada masa kompilasi. Ini membantu mengesan kesilapan awal dalam proses pembangunan. "Corak ketat" adalah satu lagi kaedah dalam JavaScript yang menjadikan bahasa itu berkelakuan lebih seperti bahasa yang sangat ditaip dengan membuang kesilapan untuk tindakan yang tidak selamat.

Apakah faedah menggunakan bahasa yang sangat ditaip?

Bahasa yang sangat ditaip menawarkan beberapa faedah. Mereka boleh membantu menangkap kesilapan pada masa kompilasi dan bukannya runtime, yang dapat menjimatkan banyak masa debugging. Mereka juga membuat kod lebih dokumentari diri, kerana jenis data pembolehubah jelas menunjukkan bagaimana ia digunakan. Selain itu, mereka boleh membuat kod lebih diramalkan dan lebih mudah untuk disimpulkan kerana mereka menghalang penukaran jenis yang tidak dijangka.

Bolehkah saya menggunakan JavaScript sebagai bahasa yang sangat ditaip?

Walaupun JavaScript bukan bahasa yang sangat ditaip secara lalai, anda boleh menguatkuasakan taip yang kuat menggunakan alat seperti typescript atau aliran. Alat ini menambah jenis statik ke JavaScript, yang membolehkan pemeriksaan jenis pada masa penyusunan. Ini membantu mengesan kesilapan awal dalam proses pembangunan. Walau bagaimanapun, adalah penting untuk diperhatikan bahawa alat -alat ini tidak mengubah sifat JavaScript yang mendasari mereka hanya menyediakan lapisan keselamatan jenis di atasnya.

Apa itu TypeScript dan bagaimana ia berkaitan dengan JavaScript?

TypeScript adalah JavaScript Statis Stative Superset yang dibangunkan oleh Microsoft. Ia menambah jenis statik ke JavaScript, yang membolehkan pemeriksaan jenis pada masa penyusunan. Ini membantu mengesan kesilapan awal dalam proses pembangunan. Kod TypeScript ditukar kepada JavaScript, yang bermaksud ia boleh berjalan di mana -mana JavaScript berjalan. Ia serasi sepenuhnya dengan JavaScript dan boleh menggunakan semua ciri JavaScript.

Apakah kelemahan menggunakan bahasa yang sangat ditaip?

Walaupun bahasa yang sangat ditaip menawarkan banyak faedah, mereka juga mempunyai beberapa kelemahan. Mereka boleh menjadi lebih verbose dan memerlukan lebih banyak kod untuk menyelesaikan tugas yang sama seperti bahasa lemah. Mereka juga memerlukan langkah penyusunan, yang mungkin melambatkan proses pembangunan. Selain itu, mereka mungkin kurang fleksibel dan lebih sukar digunakan untuk tugas -tugas tertentu, seperti mengendalikan data dinamik.

Bagaimana "mod ketat" berfungsi dalam javascript?

"Corak ketat" adalah ciri dalam JavaScript yang menjadikan bahasa itu berkelakuan lebih seperti bahasa yang sangat ditaip. Ia membuang kesilapan untuk tindakan yang tidak selamat, seperti memberikan nilai kepada sifat baca sahaja atau menggunakan pembolehubah sebelum mengisytiharkannya. Ini membantu mengesan kesilapan awal dalam proses pembangunan. Untuk mengaktifkan "mod ketat", tambah garis "Gunakan ketat;" di bahagian atas fail atau fungsi JavaScript.

Apakah jenis paksaan dalam JavaScript?

Jenis paksaan adalah ciri dalam JavaScript di mana bahasa secara automatik menukar satu jenis data ke yang lain apabila perlu. Sebagai contoh, jika anda cuba menambah nombor dan rentetan, JavaScript akan menukar nombor ke rentetan sebelum melakukan penambahan. Walaupun ini mudah, ia juga boleh membawa kepada hasil yang tidak dijangka jika ditangani dengan tidak betul.

Bagaimana untuk mengelakkan paksaan jenis dalam JavaScript?

Satu cara untuk mengelakkan paksaan jenis dalam JavaScript adalah menggunakan "mod ketat", yang membuang kesilapan untuk tindakan yang tidak selamat. Cara lain ialah menggunakan pengendali "===" dan bukannya pengendali "==" untuk perbandingan, kerana bekas tidak melakukan paksaan jenis. Di samping itu, anda boleh menambah jenis statik ke JavaScript menggunakan alat seperti TypeScript atau aliran, yang membantu menangkap kesilapan yang berkaitan dengan jenis pada masa penyusunan.

Apakah masa depan bahasa yang sangat ditaip dalam JavaScript?

Penggunaan bahasa yang sangat ditaip dalam JavaScript boleh meningkat pada masa akan datang kerana mereka memberikan banyak faedah seperti menangkap kesilapan awal dan membuat kod lebih diramalkan. Alat seperti TypeScript dan aliran menjadi lebih popular, dan alat dan ciri baru sedang dibangunkan untuk menjadikan JavaScript lebih selamat jenis. Walau bagaimanapun, fleksibiliti dan dinamik JavaScript akan terus menjadi pilihan pertama bagi banyak pemaju.

Atas ialah kandungan terperinci Teknik meminjam dari bahasa yang sangat ditaip di JS. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!