Untuk menjadikan semua huraian lanjut lebih jelas kepada anda, muat turun fail PDF ini atau buka sahaja imej ini dalam tab baharu penyemak imbas anda.
Kadang-kadang menarik untuk diberi perhatian sama ada laman web yang kelihatan cantik sentiasa menggunakan "cantik" kod html, iaitu tepat, berstruktur, bebas ralat. Kod HTML adalah sejenis seni. Ia tidak begitu maju dan pelbagai seperti bahasa dinamik, namun ia boleh ditulis dengan agak elegan dan mahir.
Berikut ialah senarai ciri yang boleh digunakan untuk menentukan sama ada kod itu ditulis dengan kemahiran atau tidak.
1.DOCTYPE ditakrifkan dengan betul. Rentetan ini bukan sahaja membolehkan anda mengenal pasti kod anda, tetapi juga "memberitahu" penyemak imbas cara memaparkan halaman anda.
2. Bahagian kemas dalam tag
Pengepala ditetapkan. Pengekodan telah diisytiharkan. Helaian gaya disambungkan. Skrip disertakan, tetapi tidak ditulis sepenuhnya.
3. Memberikan ID kepada dokumen anda membolehkan anda mencipta sifat CSS yang unik untuk setiap halaman. Sebagai contoh, anda mungkin mahu anda
teg itu kelihatan istimewa, contohnya, pada halaman utama. Dalam lembaran gaya CSS anda, anda boleh menulis: #home h2() untuk mencapai ini.
4. Menu bersih. Anda mungkin sering melihat senarai digunakan sebagai menu. Ini sangat mudah, kerana... memberi anda keupayaan untuk mengawalnya.
5. Melampirkan semua kandungan halaman dalam tag utama 6. Perkara penting hendaklah diletakkan pada permulaan. Berita dan peristiwa penting dalam kod harus didahulukan, dan menu dan kandungan yang tidak penting harus diletakkan di penghujungnya. 7. "Pemasukan" elemen tapak. Kebanyakan elemen tapak diulang pada setiap halaman, yang bermaksud ia perlu disertakan menggunakan perintah include php. 8. Kod mesti dijadualkan kepada bahagian. Jika setiap bahagian kod diinden, struktur kod akan menjadi lebih jelas. Kod yang dijajar ke kiri sukar dibaca dan difahami. 9. Tag penutup yang betul. Kecualikan teg akhir dalam teg yang tidak berganding dan pastikan teg yang dipadankan telah ditutup. 10. Gunakan tag tajuk. Penggunaan tajuk adalah perlu kerana... mereka menunjukkan hierarki bahagian dan memberinya lebih banyak susunan. 12. Tiada gaya! Kod html anda harus menumpukan pada struktur dan kandungan, bukan reka bentuk halaman! Letakkan semua gaya dalam fail CSS yang berasingan. Saya akan memberikan peraturan asas yang mesti diikuti semasa membangunkan kod, supaya dalam seminggu anda boleh melihat kod dan menentukan fungsi mana untuk melakukan apa. Satu lagi kelebihan menulis kod boleh dibaca ialah kemudahan mencari dan membetulkan ralat. Saya akan katakan dengan segera bahawa contoh yang saya tandai sebagai "salah" tidak bermakna ia tidak berfungsi, tetapi ia tidak betul dari sudut pandangan membangunkan kod yang boleh dibaca. Sentiasa apabila memaparkan teks pada skrin, pembolehubah dalam baris mesti diletakkan di luar kurungan. Ini bukan sahaja mudah untuk dilihat, tetapi juga berkesan, kerana ia menghasilkan output yang lebih pantas ke skrin. Contoh yang salah: echo "Nilai ialah $val" Contoh yang betul: echo "Nilai ialah ".$val Setiap fungsi harus diterangkan dengan ulasan pendek jika boleh. Setiap serpihan, jika anda fikir ia cukup sukar untuk difahami, harus diterangkan dengan ulasan ringkas. Dan secara umum, ulasan itu harus menerangkan semua yang anda anggap perlu. Anda mesti memutuskan sendiri jenis ulasan yang ingin anda gunakan. Ini boleh menjadi satu baris teks, atau blok baris, yang menerangkan tujuan fungsi, maklumat tentang pengarangnya, dsb. boleh diganti dengan mudah Contoh yang salah: "; echo "Nombor sebelum ialah ".($i - 1); echo " Contoh yang betul: Nombor adalah
Sila ambil perhatian bahawa dua binaan php dibuka di sini, dan teks HTML dimasukkan di antaranya. Mungkin contoh ini tidak menunjukkan kelebihan yang jelas untuk memindahkan teks di luar struktur PHP, tetapi sebenarnya, apabila anda perlu berurusan dengan jadual, peraturan sedemikian boleh menjadi sangat berguna. Contoh yang salah: Ingat, php bukan Pascal dengan blok permulaan...akhirnya. Di sini blok harus dibuka pada baris yang sama di mana ia bermula, dan ditutup sejajar dengan permulaan blok: Contoh yang salah: $res = mysql_result(mysql_query("PILIH Nombor DARI db"), 0, 0) Contoh yang betul: $query = mysql_query("PILIH Nombor DARI db"); $res = mysql_result($query, 0, 0); Sebenarnya, ini adalah elemen yang agak penting untuk menulis kod yang boleh dibaca. Saya telah melihat beberapa orang meninggalkan baris kosong dan menggunakan ruang sesedikit mungkin, memikirkan bahawa mereka mengambil ruang tambahan. Ini pada asasnya salah, kerana bait tambahan akan membolehkan orang lain menjimatkan masa untuk menghuraikan kod orang lain. Contoh yang salah: Contoh yang betul: Ingat bahawa +1 sentiasa boleh digantikan dengan ++ dan +n dengan +=n. Contoh penggantian: $i = $i + 1 bersamaan dengan $i++ baik buruk Secara relatifnya, anda boleh melatih seseorang untuk menggunakan alat dan dokumentasi yang diperlukan, komunikasi yang betul dengan pelanggan dan dalam pasukan, penetapan matlamat dan keutamaan yang betul (tentu saja, setakat anda memiliki semua ini sendiri). Tetapi apabila ia datang kepada kod sebenar, perkara menjadi kurang jelas. Ya, anda boleh menunjukkan perkara yang lemah, anda juga boleh menjelaskan apa yang salah dengan mereka. Dan lain kali dapatkan semakan dengan set masalah baharu sepenuhnya. Profesion pengaturcara, seperti kebanyakan profesion lain, perlu dipelajari setiap hari selama beberapa tahun, dan, pada umumnya, sepanjang hayat seseorang. Mula-mula, anda menguasai satu set pengetahuan asas dalam jumlah kursus semester N, kemudian anda menginjak-injak pelbagai rake untuk masa yang lama, mengamalkan pengalaman rakan-rakan yang lebih tua, mengkaji contoh yang baik dan buruk (atas sebab tertentu, yang buruk lebih banyak biasa). Bercakap tentang pengetahuan asas, perlu diingatkan bahawa keupayaan untuk menulis kod profesional yang cantik adalah sesuatu yang, untuk satu sebab atau yang lain, pengetahuan asas ini secara kategori Dikecualikan. Sebaliknya, dalam institusi yang berkaitan, serta dalam buku, kami diberitahu tentang algoritma, bahasa, prinsip OOP, corak reka bentuk... Ya, anda perlu tahu semua ini. Tetapi pada masa yang sama, pemahaman tentang rupa kod yang baik biasanya muncul dengan pengalaman praktikal (biasanya pada satu tahap atau negatif) di bawah tali pinggang seseorang. Dan dengan syarat bahawa kehidupan "mencucuk" anda bukan sahaja dengan contoh berair kod buruk, tetapi juga dengan contoh yang benar-benar layak ditiru. Di sinilah letaknya keseluruhan kesukaran: idea anda tentang kod "layak" dan "cantik" sepenuhnya berdasarkan pengalaman peribadi anda selama bertahun-tahun. Sekarang cuba sampaikan idea ini dalam masa yang singkat kepada seseorang yang mempunyai pengalaman yang sama sekali berbeza atau bahkan tiada pengalaman langsung. Tetapi jika kualiti kod yang ditulis oleh orang yang bekerja dengan kami adalah sangat penting bagi kami, maka ia masih berbaloi untuk dicuba! Tetapi adakah kualiti estetik kod merupakan faktor yang mempengaruhi penunjuk di atas secara positif? Hal ini demikian kerana kod cantik, tanpa mengira tafsiran subjektif konsep kecantikan, mempunyai ciri-ciri berikut (pada satu tahap atau yang lain boleh dikurangkan antara satu sama lain) kualiti yang paling penting: Dan sekarang, untuk beralih daripada perkataan umum kepada khusus, mari kita lakukan sebaliknya dan katakan bahawa ia boleh dibaca dan kod terurus yang biasanya dilihat oleh kami sebagai cantik dan ditulis secara profesional. Sehubungan itu, kami akan terus menumpukan pada membincangkan bagaimana untuk mencapai kualiti ini. Tidak kira bahasa pengaturcaraan khusus dan tugas yang sedang diselesaikan, agar sekeping kod mempunyai dua kualiti ini dengan secukupnya, ia mestilah: Ini semua, tentu saja, baik dan penting, tetapi apabila bercakap tentang pelaksanaan logik perniagaan dalam projek sebenar, kita biasanya perlu berurusan dengan algoritma yang sama sekali berbeza, lebih mengingatkan ilustrasi dalam buku kanak-kanak mengenai pengaturcaraan. Sesuatu seperti ini (diambil daripada): Oleh itu, dengan kelinearan saya tidak mengaitkan kerumitan asimptotik algoritma seperti bilangan maksimum blok kod bersarang antara satu sama lain, atau tahap bersarang subseksyen kod terpanjang. Sebagai contoh, serpihan linear sempurna: Do_a(); do_b(); do_c(); Do_a(); if (check) ( something(); ) else ( anything(); if (whatever()) ( for (a in b) ( if (good(a)) ( something(); ) ) ) ) Catatan: memandangkan di sini dan seterusnya kami memerlukan contoh kod untuk menggambarkan idea tertentu, kami akan serta-merta bersetuju bahawa ia akan ditulis dalam bahasa seperti C umum yang abstrak, kecuali dalam kes di mana ciri-ciri bahasa sedia ada tertentu diperlukan. Untuk kes sedemikian, ia akan ditunjukkan secara eksplisit dalam bahasa apa contoh itu ditulis (khususnya, akan ada contoh dalam Java dan Javascript). Mari cuba lakukan ini berdasarkan "algoritma pembaikan automatik" dalam rajah di atas: Listen_client(); jika (!is_clean()) ( ... ) check_cost(); jika (!client_agree()) ( ... ) find_defects(); jika (defects_found()) ( ... ) create_request(); ambil duit(); selamat tinggal(); Listen_client(); jika (!is_clean()) ( ... ) check_cost(); if (client_agree()) ( find_defects(); if (defects_found()) ( ... ) create_request(); take_money(); ) else ( ... ) bye(); Jika (!client_agree()) ( ... ) else ( find_defects(); if (defects_found()) ( ... ) create_request(); take_money(); bye(); ) Jika (!client_agree()) ( ... return; ) find_defects(); jika (defects_found()) ( ... ) create_request(); ambil duit(); selamat tinggal(); Sudah tentu, adalah salah untuk membuat kesimpulan bahawa anda tidak boleh menggunakan operator lain. Pertama, konteks tidak selalu membenarkan kita untuk meletakkan rehat, teruskan, kembali atau melontar(walaupun selalunya ia membenarkannya). Kedua, faedah daripada ini mungkin tidak begitu jelas seperti dalam contoh di atas, dan mudah lain akan kelihatan lebih mudah dan lebih jelas daripada yang lain. Dan ketiga, terdapat kos tertentu apabila menggunakan berbilang kembali dalam prosedur dan fungsi, kerana itu ramai yang secara umumnya menganggap pendekatan ini sebagai anti-corak (pendapat peribadi saya: biasanya faedah masih meliputi kos ini). Oleh itu, teknik ini (dan mana-mana yang lain) harus dilihat sebagai petunjuk, dan bukan sebagai arahan tanpa syarat untuk bertindak. Oleh itu, kami akan menunjukkan teknik berdasarkan contoh "buruk" dari permulaan bab: Do_a() if (check) ( something(); ) else ( anything(); if (whatever()) ( for (a in b) ( if (good(a)) ( something(); ) ) ) ) ) Prosedur do_on_whatever() ( for (a in b) ( if (good(a)) ( something(); ) ) ) do_a(); if (check) ( something(); ) else ( anything(); if (whatever()) ( do_on_whatever(); ) ) Walau bagaimanapun, perlu diingat bahawa perkara yang sama dokumentasi diri akan sangat menderita jika sekeping kod yang dikeluarkan tidak mempunyai tugasan lengkap keseluruhan yang dilakukan oleh kod tersebut. Kesukaran dalam memilih nama yang betul untuk prosedur mungkin merupakan petunjuk bagi kes sedemikian (lihat fasal 6.1). Jika (semak) ( do_a(); something(); if (whatever()) ( for (a in b) ( if (good(a)) ( something(); ) ) ) else ( do_a(); anything ( ); if (whatever()) ( for (a in b) ( if (good(a)) ( something(); ) ) ) ) Do_a(); jika (semak) ( sesuatu (); ) lain ( apa-apa (); ) jika (apa sahaja ()) ( untuk (a dalam b) ( jika (baik (a)) ( sesuatu (); ) ) ) Cara terbaik untuk memerangi ini adalah untuk meminimumkan saiz kawasan di dalam blok. Itu. semua baris yang tidak menjangkakan pengecualian berlaku mesti dialihkan ke luar blok. Walaupun dalam beberapa kes, dari sudut kebolehbacaan, pendekatan yang bertentangan mungkin lebih berfaedah: daripada menulis banyak blok kecil cuba tangkap, adalah lebih baik untuk menggabungkan mereka menjadi satu yang besar. Di samping itu, jika keadaan membenarkan anda untuk tidak mengendalikan pengecualian di sini dan sekarang, tetapi untuk membuangnya ke dalam timbunan, biasanya lebih baik untuk berbuat demikian. Tetapi kita mesti ingat bahawa kebolehubahan di sini hanya mungkin jika anda sendiri boleh menetapkan atau menukar kontrak prosedur yang anda edit. Jika (a) ( jika (b) ( buat_sesuatu(); ) ) Jika (a && b) ( lakukan_sesuatu(); ) Jika (a) ( var1 = b; ) lain ( var1 = c; ) Var1 = a ? b:c; Jika (a) ( var1 = b; ) jika (aa) ( var1 = c; ) lain ( var1 = d; ) Var1 = a ? b:aa? c:d; Perhatikan bahawa permulaan pembolehubah var1 kini dijalankan dalam satu operasi tunggal, yang sekali lagi menyumbang kepada dokumentasi diri (lihat fasal 6.8). Ia mungkin untuk menyelesaikan masalah melalui cuba...akhirnya, tetapi ini tidak sepenuhnya betul, kerana dalam kes ini tidak ada perbincangan mengenai pengendalian pengecualian. Dan pendekatan sedemikian akan sangat menghalang proses linearisasi. Mari lakukan ini (sebenarnya, saya pernah menggunakan fasal 5.1 bahkan sebelum saya menulisnya): Prosedur berunding_dengan_klien() ( check_cost(); if (!client_agree()) ( pay_for_wash(); return; ) find_defects(); if (defects_found()) ( say_about_defects(); if (!client_agree()) ( pay_for_wash_and_dyagnosis() ; return; ) ) create_request(); take_money(); ) listen_client(); if (!is_clean()) ( wash(); ) negotiate_with_client(); selamat tinggal(); Dalam pengertian ini, penyelesaian kejuruteraan yang ideal adalah apabila tiada apa yang dilakukan, tetapi semuanya berfungsi seperti yang diperlukan. Sudah tentu, dalam dunia nyata, penyelesaian sempurna jarang tersedia, itulah sebabnya kami pengaturcara masih perlu melakukan kerja. Tetapi ideal inilah yang harus kita perjuangkan. Sudah tentu, kaedah yang paling jelas untuk menangani masalah adalah untuk memindahkan kod yang digunakan semula ke dalam prosedur dan kelas yang berasingan. Ia juga bernilai menyebut teknik nyahduplikasi yang sangat berguna yang diterangkan dalam fasal 4.3. Prosedur proc1() ( init(); do1(); ) prosedur proc2() ( init(); do2(); ) proc1(); proc2(); Di dalamnya(); do1(); do2(); Ini terutamanya terpakai, sudah tentu, untuk semakan untuk null. Sebagai peraturan, ini disebabkan oleh ketakutan abadi pengaturcara di mana-mana NPE dan keinginan untuk sekali lagi selamat daripada mereka. Jenis cek yang tidak diperlukan adalah contoh berikut: Obj = Objek baru(); ... jika (obj != null) ( obj.call(); ) Di sini anda juga boleh memasukkan berpuluh-puluh jenis pemeriksaan lain untuk syarat yang jelas dipenuhi (atau jelas tidak dipenuhi). Obj = factory.getObject(); obj.call1(); // jika obj adalah null, kita akan sudah mati) jika (obj != null) ( obj.call2(); ) Contoh ketiga adalah sedikit kurang jelas daripada dua yang pertama, tetapi hanya ada di mana-mana: Prosedur proc1(obj) ( if (!is_valid(obj)) return; obj.call1(); ) procedure proc2(obj) ( if (!is_valid(obj)) return; obj.call2(); ) obj = kilang. getObject(); if (is_valid(obj) ( proc1(obj); proc2(obj); ) Pilihan di sini mungkin berbeza: Satu lagi pendekatan yang berguna ialah menggunakan corak NullObject, yang melibatkan penggunaan objek dengan kaedah yang tidak melakukan apa-apa, tetapi juga tidak menyebabkan ralat, bukannya yang "berbahaya" null. Kes khas pendekatan ini boleh dianggap sebagai penolakan untuk menggunakan null untuk pembolehubah koleksi yang memihak kepada koleksi kosong. Ini juga termasuk istimewa selamat nol perpustakaan, antaranya saya ingin mengetengahkan satu set perpustakaan apache-commons untuk Jawa. Ia membolehkan anda menjimatkan sejumlah besar ruang dan masa, menghapuskan keperluan untuk menulis pemeriksaan rutin yang tidak berkesudahan null. Selalunya kita berhadapan dengan tugasan atau subtugas yang telah diselesaikan berkali-kali, sama ada menyusun atau mencari melalui tatasusunan, bekerja dengan format grafik 2D atau pelayan tinjauan panjang dalam Javascript. Peraturan umum ialah masalah standard mempunyai penyelesaian standard, dan penyelesaian ini membolehkan kami mendapatkan hasil yang diingini dengan menulis minimum kod kami. Kadang-kadang terdapat godaan, bukannya mencari sesuatu, mencuba dan menyesuaikan diri, untuk segera melakar basikal anda pada lutut anda. Kadang-kadang ini boleh dibenarkan, tetapi jika kita bercakap tentang kod yang diselenggara jangka panjang, seminit "simpanan" boleh bertukar menjadi berjam-jam penyahpepijatan dan membetulkan ralat pada kes sudut yang terlepas. Sebaliknya, hanya menyentuh topik yang agak luas, saya ingin mengatakan bahawa kadangkala pelaksanaan "basikal" boleh atau lebih baik daripada menggunakan penyelesaian siap sedia. Ini biasanya benar dalam kes di mana kepercayaan terhadap kualiti penyelesaian siap tidak lebih tinggi daripada dalam kod asli, atau dalam kes apabila kos untuk memperkenalkan pergantungan luar baharu secara teknikal tidak boleh diterima. Walau bagaimanapun, kembali kepada isu keringkasan kod, sudah tentu, menggunakan yang standard (contohnya, apache-commons Dan jambu batu untuk Java) dan perpustakaan bukan standard ialah salah satu cara paling berkesan untuk mengurangkan saiz kod anda sendiri. sebenarnya, sebarang kod, termasuk yang tidak digunakan, memerlukan bayaran untuk penyelenggaraannya dalam bentuk perhatian dan masa yang dibelanjakan. Oleh itu, dengan mengalih keluar kawasan yang tidak perlu dan tidak digunakan, kami bukan sahaja mengurangkan saiz kod, tetapi juga, sama pentingnya, menyumbang kepada dokumentasi diri. Sebagai ilustrasi, saya akan memberikan yang paling banyak, dari sudut pandangan saya, contoh yang menarik untuk bahasa Javascript. Selalunya, apabila menghuraikan ungkapan rentetan, anda boleh melihat timbunan berikut: Jika (obj && obj.s) ( // buat sesuatu ) Begitu juga, bandingkan bentuk tatatanda berikut: Jika (!a) ( a = defaultValue; ) A = a || nilai asal; Apabila membaca fail XML, walaupun tanpa mengetahui apa-apa tentang konteks, kita hampir selalu mendapat idea tentang apa yang diterangkan oleh fail, jenis data yang dibentangkan di dalamnya, dan juga, mungkin, bagaimana ia akan digunakan. Memperluas idea ini kepada kod program, di bawah istilah "dokumentasi kendiri" saya ingin menggabungkan banyak sifat kod yang membolehkan anda memahami dengan cepat, tanpa analisis terperinci dan pemahaman mendalam tentang konteks, memahami perkara yang dilakukan oleh kod ini. Saya ingin membezakan pendekatan ini dengan dokumentasi "luar", yang boleh dinyatakan dengan adanya ulasan atau dokumentasi berasingan. Tanpa menafikan keperluan untuk kedua-duanya dalam kes tertentu, saya perhatikan bahawa apabila ia berkaitan dengan kebolehbacaan kod, kaedah pendokumentasian diri adalah lebih berkesan. Jika medan dipanggil nama, nama objek harus disimpan di sana, dan bukan tarikh penciptaannya, nombor siri dalam tatasusunan, atau nama fail tempat ia bersiri. Jika kaedah itu dipanggil bandingkan(), ia harus membandingkan objek, dan tidak meletakkannya ke dalam jadual cincang, akses yang boleh didapati di suatu tempat 1000 baris lebih rendah dalam kod. Jika kelas dipanggil Peranti Rangkaian, maka kaedah awamnya hendaklah mengandungi operasi yang terpakai pada peranti, dan bukan pelaksanaan umum quicksort. Sukar untuk menyatakan dengan kata-kata berapa kerap, walaupun peraturan ini jelas, pengaturcara melanggarnya. Saya tidak fikir ia patut diterangkan bagaimana ini mempengaruhi kebolehbacaan kod mereka. Untuk mengelakkan masalah sedemikian, adalah perlu untuk memikirkan nama setiap pembolehubah, setiap kaedah dan kelas dengan berhati-hati yang mungkin. Pada masa yang sama, kita mesti mencuba bukan sahaja dengan betul, tetapi juga, jika boleh, sebanyak mungkin. penuh terangkan tujuan setiap reka bentuk. Jika ini tidak dapat dilakukan, punca biasanya adalah kesilapan reka bentuk kecil atau kasar, jadi ini harus diambil sekurang-kurangnya sebagai loceng penggera. Jelas sekali, ia juga bernilai meminimumkan penggunaan pembolehubah bernama i, j, k, s. Pembolehubah dengan nama sedemikian hanya boleh menjadi tempatan dan hanya mempunyai semantik yang paling diterima umum. Bila i, j, ini boleh menjadi pembilang gelung atau indeks dalam tatasusunan. Walaupun, jika boleh, adalah berbaloi untuk menyingkirkan pembilang sedemikian memihak kepada gelung foreach dan ekspresi berfungsi. Lebih kurang sama boleh dikatakan tentang masalah "terbalik" - apabila beberapa nama berbeza digunakan untuk entiti/operasi/algoritma yang sama. Masa untuk menganalisis kod tersebut mungkin meningkat dengan ketara berbanding jangkaan. Kesimpulannya mudah: dalam program anda, anda harus merawat kemunculan sinonim dan homonim dengan sangat berhati-hati dan cuba sedaya upaya untuk mengelakkan ini. Kesimpulan yang paling langsung berikutan daripada ini: semakin sedikit entiti yang anda masukkan, semakin mudah dan lebih baik kod anda akan menjadi. Contoh biasa pembolehubah "tambahan": Int sum = couSum(); int meningkatJumlah = jumlah + 1; beroperasi(increasedSum); ... Int sum = couSum(); beroperasi(jumlah + 1); ... Beroperasi(countSum() + 1); ... Walau bagaimanapun, ia harus digunakan hanya jika teknik ini menggalakkan dokumentasi diri dan tidak bercanggah dengannya. Sebagai contoh: Deskripsi dua kali ganda = b * b - 4 * a *c; double x1 = -b + sqrt(descr) / (2 * a); Merumuskan prinsip yang ditunjukkan dalam contoh ini, kita boleh membuat kesimpulan yang berikut: adalah dinasihatkan untuk mencipta pembolehubah/fungsi/objek dalam program anda hanya jika ia mempunyai prototaip dalam kawasan subjek. Pada masa yang sama, sesuai dengan fasal 6.1, kita mesti cuba memastikan bahawa nama objek ini menyatakan surat-menyurat ini sejelas mungkin. Jika tiada surat-menyurat sedemikian, kemungkinan besar menggunakan pembolehubah/fungsi/objek hanya membebankan kod anda, dan mengalih keluarnya hanya akan memberi manfaat kepada program. Anda boleh memberikan contoh kasar, membayangkan bahawa kehidupan sering melemparkan contoh sedemikian. Keadaan tidak langsung: Jika (i == abs(i)) ( ) Jika (i >= 0) ( ) Contoh mudah: Objek someobj = createSomeObj(); if (some_check()) ( // Tidak perlukan someobj di sini ) else ( someobj.call(); ) Tidak sukar untuk memikirkan cara membuat kod ini lebih baik sedikit: Jika (some_check()) ( // Tidak memerlukan someobj di sini ) else ( Objek someobj = createSomeObj(); someobj.call(); ) Nah, atau, jika pembolehubah diperlukan untuk satu panggilan, anda juga boleh menggunakan fasal 6.3: Jika (some_check()) ( // Tidak perlukan someobj di sini ) else ( createSomeObj().call(); ) Objek someobj = createSomeObj(); untuk (int i = 0; i< 10; i++) {
someobj.call();
}
Kes sedemikian tidak membatalkan prinsip umum, tetapi hanya berfungsi untuk menggambarkan bahawa setiap teknik mempunyai bidang aplikasinya sendiri dan harus digunakan dengan teliti. Ia membawa kepada kemunculan kebergantungan yang tidak perlu pada keadaan objek dalam kaedah yang berpotensi statik, atau secara amnya kepada pengurusan yang salah bagi keadaan objek. Akibatnya, ia menjadi sukar untuk menganalisis kod. Oleh itu, adalah perlu untuk cuba memberi perhatian kepada aspek ini, dengan jelas menonjolkan kaedah yang tidak bergantung pada keadaan objek. Jika teknik ini diabaikan, pembaca perlu mencari setiap objek dalam kod, di mana ia diisytiharkan, sama ada ia dimulakan di suatu tempat dengan nilai yang berbeza, dsb. Semua ini menyukarkan untuk menganalisis kod dan meningkatkan masa yang diperlukan untuk memahami kod. Itulah sebabnya, sebagai contoh, operasi berfungsi dari apache CollectionUtils Dan Koleksi jambu batu2 selalunya lebih disukai daripada terbina dalam Java untuk setiap gelung - mereka membenarkan anda untuk menggabungkan pengisytiharan dan permulaan koleksi. Mari bandingkan: Koleksi Untuk lebih jelas, mari kita pertimbangkan juga contoh dalam Javascript (diambil dari sini: http://habrahabr.ru/post/154105). Mari bandingkan: Var str = "disebut oleh"; untuk(var i =0; l= tweeps.length; i< l; ++i){
str += tweeps[i].name;
if(i< tweeps.length-1) {str += ", "}
}
Var str = "disebut oleh " + tweeps.map(function(t)( return t.name; )).join(", "); Juga, sebagai jenis kompromi sedemikian, seseorang harus mempertimbangkan keperluan untuk menentukan kontrak kaedah/kelas/prosedur menggunakan ulasan jika ia tidak dapat dinyatakan secara eksplisit dengan cara bahasa lain (lihat fasal 5.2). Dalam kes kami, matlamatnya adalah untuk menjadikan kod itu boleh dibaca dan diurus sebaik mungkin. Yang pada masa yang sama akan menyenangkan dari sudut pandangan estetik. Mempelajari contoh yang diberikan dalam artikel semasa, seseorang boleh dengan mudah melihat bahawa kedua-dua prinsip asal itu sendiri (lineariti, minima, dokumentasi diri) dan teknik khusus tidak bebas antara satu sama lain. Dengan menggunakan satu teknik, kita juga secara tidak langsung boleh mengikuti yang sama sekali berbeza. Dengan menambah baik salah satu petunjuk sasaran, kita boleh menyumbang kepada peningkatan yang lain. Walau bagaimanapun, fenomena ini juga mempunyai kelemahan: selalunya terdapat situasi apabila prinsip itu bercanggah secara langsung antara satu sama lain, serta dengan banyak peraturan lain yang mungkin dan dogma pengaturcaraan (contohnya, dengan prinsip OOP). Anda perlu mengambil ini sepenuhnya dengan tenang. Dalam pengaturcaraan, seperti dalam kebanyakan bidang aktiviti manusia yang lain, tidak boleh ada arahan universal untuk pelaksanaan. Setiap situasi memerlukan pertimbangan dan analisis yang berasingan, dan keputusan mesti dibuat berdasarkan pemahaman tentang spesifik situasi. Secara umum, fakta ini tidak sama sekali menafikan kegunaan kedua-dua menyimpulkan dan memahami prinsip umum dan menguasai kaedah khusus untuk melaksanakannya. Itulah sebabnya saya berharap semua yang dinyatakan dalam artikel itu benar-benar berguna untuk banyak pengaturcara. Nah, beberapa perkataan lagi tentang tempat kami bermula - tentang keindahan kod kami. Walaupun anda tahu tentang teknik "lanjutan" untuk menulis kod yang cantik, anda tidak seharusnya mengabaikan perkara paling mudah, seperti pemformatan automatik asas dan mengikut gaya pengekodan yang ditetapkan dalam projek. Selalunya pemformatan sahaja boleh melakukan keajaiban untuk sekeping kod yang hodoh. Serta pengelompokan pintar bahagian kod menggunakan baris kosong dan rehat. Tambah tag Mengetahui cara menulis kod tidak bermakna dapat melakukannya dengan betul. Kod yang baik adalah seperti siaran yang direka dengan cantik - ia mudah dibaca, mudah dinavigasi dan pembangun sentiasa memahami cara mengembangkannya, nyahpepijat atau menggunakannya untuk tujuan lain. Pertama, sedikit teori. Kod yang sama boleh ditulis dengan cara yang berbeza. Kod itu mungkin prosedural, berfungsi Dan berorientasikan objek. Pendekatan prosedural adalah yang paling mudah. Ia bermaksud skrip di mana arahan ditulis dan fungsi PHP asas dipanggil.
$a = 10; Pendekatan ini sesuai jika anda mempunyai kod yang sangat kecil atau ia melaksanakan satu tugas dengan ketat (contohnya, menjana gambar), seperti yang mereka katakan, "tidak melangkah ke kanan, atau melangkah ke kiri." Dalam pendekatan fungsional, kod anda dibahagikan kepada beberapa bahagian dan setiap bahagian diletakkan dalam fungsinya sendiri. Ini akan mengelakkan pertindihan kod, menjadikan kod itu ringkas dan lebih mudah dibaca. Sekarang mari cuba berfungsi.
//akan memulangkan kos //masukkan pemberat ke dalam pembolehubah Kod keluar lebih mudah dibaca. Pemberat dinyatakan dalam fungsi getWeights Dan dengan penambahan mudah hitung mereka di sana, berapa kos berat yang berbeza bagi setiap buah. Dan akhirnya pelaksanaan pada OOP.
kelas Berbuah ( setData fungsi awam($buah, $berat) ( fungsi peribadi getPrice($price, $weight) ( fungsi awam getResult() ( $fruiting = new Fruiting(); Seperti yang anda lihat, kod itu lebih besar. Untuk pengiraan mudah, anda boleh bertahan dengan pendekatan berfungsi, tetapi semua projek yang sangat besar dan kompleks ditulis menggunakan OOP. Semasa menulis bahan, saya cuba mengikut nasihat @ontofractal :) P.S. Apabila anda menulis kod, bayangkan bahawa ia akan dikekalkan oleh gila yang tidak stabil mental yang tahu di mana anda tinggal. Selamat hari kepada semua yang membaca sekarang penerbitan ini. Hari ini saya ingin memberitahu anda tentang salah satu alat pembinaan tapak web yang tidak boleh dilakukan oleh sumber web. Ini ialah menu tapak, atau seperti yang mereka katakan peta tapak. Hari ini terdapat bilangan jenis dan subjenis menu yang tidak terhad. Pembangun kedai dalam talian, blog, perkhidmatan pendidikan dan sumber lain sedang bereksperimen dan mencipta lebih banyak peta baharu dan luar biasa. Selepas membaca artikel itu, anda akan mengetahui kumpulan utama yang dibahagikan kepada semua jenis panel navigasi, anda akan dapat mencuba setiap daripada mereka, dan juga belajar cara menulis kod menu untuk laman web html. Sekarang mari kita turun ke perniagaan! Terdapat beberapa cara untuk mencipta menu dalam bahasa penanda. Konsep asas mereka adalah menggunakan senarai tidak bernombor. Oleh itu, dalam html 4, yang biasa kepada kami, pembangun menulis tag pada halaman Seperti yang dinyatakan dalam penerbitan terdahulu, elemen pasangan
Navigasi tapak Walau bagaimanapun, dengan kemunculan platform, bahasa penanda telah diisi semula dengan tag tambahan. Itulah sebabnya menu laman web moden dicipta menggunakan khas tag<
menu>. Dalam penggunaan, elemen ini tidak berbeza dengan senarai bertitik tumpu. Daripada satu <
ul> ditetapkan <
menu>. Walau bagaimanapun, perbezaan ketara kelihatan apabila dinilai dari segi kerja. Jadi, contoh kedua mempercepatkan kerja program carian dan robot dalam. Apabila menganalisis struktur tapak, mereka segera memahami bahawa sekeping kod ini bertanggungjawab untuk peta tapak. Terdapat menu mendatar, menegak dan lungsur. Kadangkala bar navigasi direka bentuk sebagai imej. Memandangkan segmen teknologi telah berkembang, perkhidmatan web sedang dibuat adaptif, i.e. Struktur halaman secara automatik menyesuaikan diri dengan saiz skrin peranti. Mari lihat kumpulan menu yang disenaraikan. Jenis navigasi ini adalah yang paling popular. Apabila panel direka bentuk secara mendatar, semua item menu terletak dalam pengepala halaman atau dalam "pengaki" (kadangkala elemen navigasi diduplikasi, muncul serentak di bahagian atas dan bawah). Sebagai contoh, kami akan membuat panel mendatar, item menu yang akan direka bentuk menggunakan CSS (helaian gaya berlatarkan), atau sebaliknya diubah. Ya, semua orang elemen berasingan akan terletak dalam segi empat tepat serong. Tertarik? Untuk transformasi kami menggunakan sifat css yang dipanggil mengubah. Untuk menentukan transformasi, gunakan fungsi terbina dalam skewX, di mana sudut kecondongan ditunjukkan dalam darjah. Malangnya, setiap penyemak imbas berfungsi dengan harta ini dengan cara tersendiri, walaupun terdapat piawaian yang ditetapkan. Oleh itu, awalan khas dicipta untuk menunjukkan ini: Sekarang mari kita gunakan pengetahuan yang diperoleh untuk menulis contoh.
Untuk program kedua kami menggunakan kod sebelumnya sebagai asas. Saya mahu item menu menegak saya mempunyai bucu bulat dan bukannya yang serong. Untuk ini saya menggunakan yang lain harta css jejari sempadan. Dalam artikel sebelum ini, saya telah pun menggunakan parameter ini, jadi saya rasa tidak akan ada sebarang kesulitan untuk memahami fungsinya.
Seperti yang telah anda perhatikan, perubahan utama dalam kod ini ialah ketiadaan pengisytiharan paparan: blok sebaris, yang sebenarnya bertanggungjawab untuk susunan mendatar titik navigasi. Kami telah melihat kumpulan utama bar navigasi, bagaimanapun, terdapat beberapa lagi jenis, atau lebih baik lagi, tambahan. Kadang-kadang situasi timbul apabila beberapa perkara melengkapkan yang utama. Dalam kes ini, anda tidak boleh melakukannya tanpa senarai juntai bawah. Mereka dicipta melalui transformasi menggunakan alat css. Di bawah saya telah melampirkan kod program kecil yang melaksanakan pendekatan ini.
DALAM dalam contoh ini Saya membahagikan unit menu kepada dua kelas: Kelas pertama bertanggungjawab untuk menu utama, dan s-menu bertanggungjawab untuk submenu. Dalam kod anda boleh menemui teknik seperti .m-menu > li:hover atau .m-menu > li. Jadi, dengan menggunakan:hover, anda menentukan cara elemen itu akan bertindak apabila anda menuding di atasnya. Dalam kes ini, tanda ">" mengubah suai pemilih supaya hanya objek kepunyaan peringkat atas adalah huruf kecil blok. Pada mulanya submenu telah ditetapkan paparan:tiada, yang memberitahu pengendali untuk menyembunyikan objek ini. Selepas menuding pada elemen navigasi yang menunjukkan berlegar, nilai harta paparan perubahan kepada blok dan senarai juntai bawah dibuka. Seperti yang anda lihat, pelaksanaan teknik ini sangat mudah. Kini anda telah menguasai jenis utama panel navigasi dan boleh mengubah suai, menambah dan memodenkannya sendiri. Jika anda menyukai artikel saya, maka langgan kemas kini blog dan kongsi sumber pengetahuan dengan rakan dan rakan sekerja. Selamat tinggal! Salam sejahtera, Roman Chueshov Baca: 1010 kali1. Keluarkan pembolehubah daripada kurungan
2. Pastikan anda menggunakan ulasan
3. Gunakan versi ringkas bagi fungsi gema. Sebagai contoh, rekod seperti
4. Jika boleh, alihkan blok besar HTML ke luar binaan PHP. Jangan menyalahgunakan fungsi php.
";
}
?>
Nombor sebelum ialah
5. Kod mesti diselaraskan berbanding dengan blok.
6. Permudahkan reka bentuk yang kompleks. Pecahkan mereka kepada yang mudah.
7. Gunakan lebih banyak ruang dan garisan kosong.
8. Gunakan pintasan untuk operasi matematik dan rentetan.
$i = $i — 1 bersamaan dengan $i—
$i = $i + $n bersamaan dengan $i+=$n
$i = $i."hello" bersamaan dengan $i.="hello"2. Mengapa kita memerlukan kod yang cantik?
Biasanya, apabila kami mengusahakan produk perisian tertentu, kualiti estetik kod bukanlah kebimbangan pertama kami.
Produktiviti kami, kualiti pelaksanaan fungsi, kestabilan operasinya, kemungkinan pengubahsuaian dan pengembangan, dll. adalah lebih penting bagi kami.
Jawapan saya: ya, dan pada masa yang sama, salah satu yang paling penting!
Mengapa kualiti ini benar-benar yang paling penting, dan bagaimana ia menyumbang kepada peningkatan penunjuk yang ditunjukkan pada permulaan perenggan, saya pasti, jelas kepada sesiapa yang terlibat dalam pengaturcaraan. 3. Tiga prinsip asas.
Bergerak untuk membentangkan pengalaman saya sendiri, saya perhatikan bahawa, semasa mengusahakan kebolehbacaan dan kebolehurusan kod saya sendiri dan orang lain, saya secara beransur-ansur mencapai pemahaman berikut.
Anda boleh menyenaraikan pelbagai petua dan teknik tanpa henti yang boleh digunakan untuk menjadikan kod anda lebih cantik. Tetapi saya berpendapat bahawa yang terbaik, atau sekurang-kurangnya keputusan yang agak baik boleh dicapai dengan memberi tumpuan kepada tiga prinsip ini. 4. Penyelarasan kod.
Nampaknya bagi saya bahawa daripada tiga prinsip asas, lineariti adalah yang paling tidak jelas, dan ia adalah yang paling sering diabaikan.
Mungkin kerana selama bertahun-tahun kajian (dan, mungkin, aktiviti saintifik) kami telah terbiasa membincangkan algoritma bukan linear secara semula jadi dengan anggaran seperti O(n3), O(nlogn) dan lain-lain.
Dan tidak sama sekali linear:
Ia adalah "kepingan" jenis kedua yang akan kami cuba tulis semula menggunakan teknik tertentu.4.1.
Teknik 1. Pilih cabang utama algoritma.
Dalam kebanyakan kes, masuk akal untuk mengambil senario linear algoritma yang paling lama berjaya sebagai cabang utama.
Cawangan utama inilah yang sepatutnya kita miliki pada tahap bersarang sifar.
Sebagai perbandingan, mari kita pertimbangkan pilihan di mana pada tahap sifar terdapat cawangan alternatif, bukannya yang utama:
Seperti yang anda lihat, tahap sarang sebahagian besar kod telah meningkat, dan melihat kod secara keseluruhan menjadi kurang menyenangkan.4.2.
Teknik 2. Penggunaan rehat, teruskan, kembali atau melontar untuk menghilangkan blok lain.
teruk: 4.3.
Teknik 3. Kami meletakkan sub-senario kompleks ke dalam prosedur yang berasingan.
Kerana Dalam kes "algoritma pembaikan", kami agak berjaya memilih cawangan utama, tetapi cawangan alternatif kami semuanya kekal sangat pendek.
lebih baik:
Sila ambil perhatian bahawa dengan memilih nama yang betul untuk prosedur yang diserlahkan, kami juga segera meningkatkan dokumentasi diri kod. Sekarang untuk serpihan ini, ia harus jelas secara umum apa yang dilakukannya dan mengapa ia diperlukan.4.4.
Teknik 4. Kami mengambil semua yang mungkin ke dalam unit luaran, hanya meninggalkan apa yang perlu dalam unit dalaman.
teruk:
lebih baik:4.5.
Teknik 5 (kes khas yang sebelumnya). Letak dalam cuba tangkap yang perlu sahaja.
Perlu diingatkan bahawa blok cuba tangkap biasanya menyusahkan apabila melibatkan kebolehbacaan kod, kerana Selalunya, bertindih antara satu sama lain, mereka sangat meningkatkan tahap keseluruhan sarang walaupun untuk algoritma mudah. 4.6.
Teknik 6. Gabungkan jika bersarang.
Semuanya jelas di sini. Daripada:
kami menulis:4.7.
Teknik 7. Gunakan operator ternary ( a? b:c) bukannya jika.
Daripada:
kami menulis:
Kadangkala masuk akal untuk menulis operator ternary bersarang, walaupun ini memerlukan pembaca mengetahui keutamaan subungkapan operator ternary dinilai.
kami menulis:
Tetapi ia mungkin tidak berbaloi untuk menyalahgunakan ini.4.8.
Merumuskan perkara di atas, mari cuba menulis pelaksanaan lengkap algoritma pembaikan secara linear yang mungkin.
listen_client(); if (!is_clean()) ( wash(); ) check_cost(); jika (!client_agree()) ( pay_for_wash(); bye(); return; ) find_defects(); if (defects_found()) ( say_about_defects(); if (!client_agree()) ( pay_for_wash_and_dyagnosis(); bye(); return; ) ) create_request(); ambil duit(); selamat tinggal();
Kami boleh berhenti di sini, tetapi nampaknya tidak begitu menarik sehingga kami perlu menghubungi 3 kali selamat tinggal() dan, sewajarnya, ingat bahawa apabila menambah cawangan baharu, ia perlu ditulis sebelum pemulangan setiap kali (sebenarnya, kos bagi berbilang pemulangan).
Jika anda berfikir bahawa kita kini telah merekodkan sesuatu yang remeh, maka, pada dasarnya, memang begitu. Walau bagaimanapun, saya memberi jaminan kepada anda bahawa dalam banyak projek langsung anda akan melihat pelaksanaan algoritma ini yang sama sekali berbeza...5. Pengecilan kod.
Saya fikir adalah tidak berguna untuk menerangkan bahawa dengan mengurangkan jumlah kod yang digunakan untuk melaksanakan fungsi tertentu, kami menjadikan kod itu lebih mudah dibaca dan boleh dipercayai. 5.1.
Teknik 1. Hapuskan pertindihan kod.
Begitu banyak yang telah diperkatakan tentang salin-tampal dan kemudaratan yang datang daripadanya sehingga sukar untuk menambah sesuatu yang baharu. Namun begitu, pengaturcara, generasi demi generasi, secara intensif menggunakan kaedah ini untuk melaksanakan fungsi perisian.
Dalam kes ini, masalah memisahkan umum daripada khusus sentiasa timbul. Selalunya ia tidak selalu jelas apakah kepingan kod yang serupa mempunyai lebih banyak persamaan atau perbezaan. Pilihan di sini dibuat semata-mata mengikut keadaan. Walau bagaimanapun, kehadiran bahagian yang sama bersaiz separuh skrin serta-merta menunjukkan bahawa kod ini boleh dan harus ditulis dengan lebih pendek.
Ia boleh dilanjutkan di luar just if kenyataan. Sebagai contoh, bukannya:
Mari menulis:
Atau pilihan yang bertentangan. Daripada:
a = Objek baru(); init(a); lakukan(a); b = Objek baru(); init(b); lakukan(b);
Mari menulis:
prosedur proc(a) ( init(a); lakukan(a); ) proc(Objek() baharu); proc(Objek baharu());5.2.
Teknik 2. Elakkan keadaan dan pemeriksaan yang tidak perlu.
Pemeriksaan tambahan adalah kejahatan yang boleh didapati dalam hampir mana-mana program. Sukar untuk menerangkan bagaimana prosedur dan algoritma yang paling remeh boleh tersumbat dengan semakan yang tidak perlu, pendua dan tidak bermakna.
Walaupun kemustahilan yang jelas, pemeriksaan sedemikian berlaku dengan kerap yang mengagumkan. (Saya akan membuat tempahan dengan segera bahawa contoh itu tidak terpakai pada bahasa dan persekitaran yang jarang berlaku di mana pengendali baru() boleh balik null. Dalam kebanyakan kes (termasuk di Jawa), ini pada dasarnya mustahil).
Di sini, sebagai contoh, adalah kes berikut:
Ia berlaku berkali-kali lebih kerap daripada jenis pemeriksaan sebelumnya.
Seperti yang anda lihat, pengarang segmen ini takut terserempak dengan objek yang tidak sah, jadi dia menyemaknya sebelum setiap bersin. Walaupun strategi sedemikian kadangkala boleh dibenarkan (terutamanya jika proc1() Dan proc2() dieksport sebagai API), dalam banyak kes ini hanyalah kekacauan kod.
Mungkin, pada pandangan pertama, pilihan ini kelihatan mustahil atau menakutkan, bagaimanapun, pada hakikatnya, dengan bantuan mereka, anda boleh meningkatkan kebolehbacaan dan kebolehpercayaan kod dengan ketara. 5.3.
Teknik 3. Elakkan menulis “basikal”. Kami menggunakan penyelesaian siap pakai secara maksimum.
Basikal hampir seperti salin-tampal: semua orang tahu ia buruk, dan semua orang menulisnya dengan kerap. Kami hanya boleh menasihati anda untuk sekurang-kurangnya cuba melawan kejahatan ini. 5.4.
Teknik 4. Kami tinggalkan dalam kod hanya apa yang sebenarnya digunakan.
Fungsi "Dangling" yang tidak dipanggil oleh sesiapa pun di mana-mana; bahagian kod yang tidak pernah dilaksanakan; keseluruhan kelas yang tidak digunakan di mana-mana, tetapi mereka terlupa untuk mengalih keluarnya - saya pasti semua orang boleh memerhati perkara sebegitu dalam projek mereka, dan mungkin juga mengambil mudah.
Oleh kerana kod yang tidak digunakan sebenarnya tidak dilaksanakan atau diuji, ia mungkin mengandungi panggilan yang salah kepada prosedur tertentu, semakan yang tidak perlu atau salah, panggilan ke prosedur dan perpustakaan luaran yang tidak diperlukan lagi dan pelbagai perkara lain yang mengelirukan atau hanya berbahaya.5.5.
Teknik 5. Kami menggunakan pengetahuan kami tentang bahasa dan bergantung kepada pembaca untuk memiliki pengetahuan ini.
Salah satu cara yang berkesan untuk menjadikan kod anda lebih ringkas, lebih pendek dan lebih jelas ialah penggunaan mahir ciri bahasa tertentu: pelbagai lalai, keutamaan operasi, bentuk pendek, dsb.
jika (obj != null && obj != undefined && obj.s != null && obj.s != undefined && obj.s != "") ( // lakukan sesuatu )
Ia kelihatan menakutkan, termasuk dari sudut pandangan "adakah penulis terlupa beberapa cek lain." Malah, mengetahui keunikan bahasa Javascript, dalam kebanyakan kes sedemikian, keseluruhan semakan boleh dikurangkan menjadi remeh:
Intinya ialah terima kasih kepada pelempar tersirat kepada boolean, cek jika (obj) () akan menghapuskan:
Secara umum, ia akan menghapuskan kebanyakan makna remeh yang boleh kita bayangkan. Malangnya, saya ulangi, pengaturcara menggunakan ciri ini agak jarang, itulah sebabnya cek "insurans semula" mereka kelihatan sangat rumit.
Dan
Pilihan kedua kelihatan lebih mudah, terima kasih kepada penggunaan semantik khusus operasi logik dalam bahasa skrip.6. Kod pendokumentasian sendiri.
Istilah "mendokumentasikan diri" paling kerap digunakan untuk menerangkan sifat format seperti XML atau JSON. Dalam konteks ini, tersirat bahawa fail mengandungi bukan sahaja set data, tetapi juga maklumat tentang strukturnya, nama entiti dan medan yang ditentukan oleh data ini. 6.1.
Teknik 1. Berhati-hati memilih nama fungsi, pembolehubah dan kelas. Anda tidak sepatutnya menipu orang yang akan membaca kod kami.
Peraturan paling penting yang harus diambil sebagai asas semasa menulis kod pendokumentasian sendiri ialah jangan sesekali menipu pembaca anda.
Pembolehubah dengan nama ii, i1, ijk42, asdsa dan lain-lain tidak boleh digunakan. Nah, mungkin jika anda bekerja dengan algoritma matematik... Tidak, lebih baik tidak.6.2.
Teknik 2. Kami cuba memanggil perkara yang sama sama, dan berbeza secara berbeza.
Salah satu kesukaran yang paling tidak menggalakkan yang timbul apabila membaca kod ialah sinonim dan homonim yang digunakan di dalamnya. Kadangkala dalam situasi di mana dua entiti berbeza dinamakan sama, anda perlu menghabiskan beberapa jam untuk memisahkan semua kes penggunaannya dan memahami entiti mana yang dimaksudkan dalam setiap kes tertentu. Tanpa pemisahan sedemikian, analisis biasa, dan oleh itu pengubahsuaian kod yang bermakna, adalah mustahil pada dasarnya. Dan situasi sedemikian berlaku lebih kerap daripada yang dijangkakan. 6.3.
Teknik 3. “Occam’s razor”. Kami tidak mencipta entiti yang boleh kami lakukan tanpanya.
Seperti yang telah disebutkan dalam perenggan 5.4., mana-mana bahagian kod, sebarang objek, fungsi atau pembolehubah yang anda cipta, pada masa hadapan, semasa proses sokongan, akan memerlukan pembayaran dalam bentuk masa dan perhatian anda (atau orang lain).
Jelas pembolehubah meningkatJumlah adalah entiti tambahan, kerana penerangan tentang objek yang disimpannya (jumlah + 1) mencirikan objek yang diberikan jauh lebih baik dan lebih tepat daripada nama pembolehubah. Oleh itu, kod itu hendaklah ditulis semula seperti berikut ("sebaris" pembolehubah):
Jika jumlah itu tidak digunakan di mana-mana lagi dalam kod, anda boleh pergi lebih jauh:
Sebaris pembolehubah yang tidak diperlukan ialah satu cara untuk menjadikan kod anda lebih pendek, lebih mudah dan lebih jelas.
Dalam kes ini, pembolehubah sebaris penerangan tidak mungkin memberi manfaat kepada kebolehbacaan, kerana pembolehubah ini digunakan untuk mewakili entiti tertentu daripada kawasan subjek, dan, oleh itu, kehadiran pembolehubah menyumbang kepada pendokumentasian kendiri kod, dan pembolehubah itu sendiri tidak berada di bawah pisau cukur Occam.
Keadaan langsung:
Saya fikir ia tidak sukar untuk menilai perbezaan kebolehbacaan.6.5.
Teknik 5. Segala yang boleh disembunyikan secara tertutup (dilindungi) hendaklah disembunyikan di situ. Enkapsulasi adalah segala-galanya kepada kami.
Saya menganggap tidak perlu untuk bercakap tentang faedah dan keperluan mengikuti prinsip enkapsulasi semasa menulis program dalam artikel ini.
Saya hanya ingin menekankan peranan enkapsulasi sebagai mekanisme untuk kod pendokumentasian sendiri. Pertama sekali, enkapsulasi membolehkan anda menyerlahkan antara muka luaran kelas dengan jelas dan menetapkan "titik masuk"nya, iaitu kaedah di mana pelaksanaan kod yang terkandung dalam kelas boleh bermula. Ini membolehkan orang yang mempelajari kod anda menjimatkan banyak masa dengan memfokuskan pada fungsi kelas dan mengabstraksikan butiran pelaksanaan. 6.6.
Teknik 6. (Generalisasi yang sebelumnya) Kami mengisytiharkan semua objek dalam skop yang paling sempit.
Prinsip mengehadkan skop setiap objek secara maksimum boleh diperluaskan lebih luas daripada enkapsulasi OOP biasa.
Jelas sekali, pengisytiharan pembolehubah someobj sedemikian menjadikannya sukar untuk memahami tujuannya, kerana pembaca kod anda akan mencari panggilan kepadanya di kawasan yang lebih luas daripada yang digunakan dan sebenarnya diperlukan.
Secara berasingan, saya ingin menyebut kes apabila teknik ini mungkin tidak berfungsi atau merugikannya. Ini adalah pembolehubah yang dimulakan di luar gelung. Sebagai contoh:
Jika mencipta objek melalui createSomeObj()- operasi yang mahal, memasukkannya ke dalam gelung boleh memberi kesan yang tidak menyenangkan pada prestasi program, walaupun ia meningkatkan kebolehbacaan.6.7.
Teknik 7. Kami memisahkan konteks statik dan dinamik dengan jelas. Kaedah yang tidak bergantung kepada keadaan objek mestilah statik.
Kekeliruan atau kekurangan pemisahan antara konteks statik dan dinamik bukanlah yang paling teruk, tetapi kejahatan yang sangat biasa. 6.8.
Teknik 8. Kami cuba untuk tidak memisahkan pengisytiharan dan permulaan objek.
Teknik ini membolehkan anda menggabungkan pengisytiharan nama objek dengan penerangan segera tentang objek itu. Ini adalah contoh yang jelas untuk mengikuti prinsip dokumentasi diri.
c:
// mendapatkan koleksi "somestrings" entah bagaimana ... Koleksi
Jika kita menggunakan Java 8, kita boleh menulisnya sedikit lebih pendek:
Nah, patut disebut kes apabila anda entah bagaimana perlu memisahkan pengisytiharan dan permulaan pembolehubah. Ini adalah kes menggunakan pembolehubah dalam blok akhirnya Dan tangkap(contohnya, untuk mengeluarkan beberapa sumber). Tiada apa yang perlu dilakukan di sini kecuali mengisytiharkan pembolehubah sebelum ini cubalah, dan mulakan di dalam blok cubalah.6.9.
Teknik 9. Kami menggunakan pendekatan deklaratif dan alat pengaturcaraan berfungsi untuk menunjukkan, bukannya menyembunyikan, intipati apa yang sedang berlaku.
Prinsip ini boleh digambarkan melalui contoh daripada perenggan sebelumnya, di mana kami menggunakan emulasi pendekatan berfungsi di Jawa untuk menjadikan kod kami lebih jelas.
c:
Nah, contoh menggunakan pendekatan berfungsi yang membunuh kebolehbacaan... Mari kita selamatkan saraf kita kali ini dan lakukan tanpa mereka.6.10.
Teknik 10. Kami menulis komen hanya jika tanpanya ia tidak jelas apa yang berlaku.
Seperti yang dinyatakan di atas, prinsip kod pendokumentasian sendiri adalah bertentangan dengan mendokumentasikan menggunakan ulasan. Saya ingin menerangkan secara ringkas mengapa komen sangat buruk:
Nah, komen diperlukan dalam kes di mana tidak mungkin untuk menulis kod yang baik untuk satu sebab atau yang lain. Itu. Ia harus ditulis untuk menerangkan bahagian kod yang sukar dibaca tanpanya. Malangnya, ini berlaku secara kerap dalam kehidupan sebenar, walaupun ia hanya boleh dianggap sebagai kompromi yang tidak dapat dielakkan. 7. Kesimpulan falsafah.
Setelah selesai mempersembahkan teknik dan teknik asas yang boleh anda gunakan untuk menjadikan kod anda lebih cantik, anda sekali lagi harus merumuskan dengan jelas: tiada satu pun daripada teknik tersebut adalah panduan tanpa syarat untuk bertindak. Sebarang teknik hanyalah cara yang mungkin untuk mencapai matlamat tertentu.
Terdapat juga kes apabila tiada penyelesaian yang jelas baik untuk masalah tertentu, atau penyelesaian ini tidak boleh dilaksanakan atas beberapa sebab (contohnya, pelanggan tidak mahu menerima perubahan yang berpotensi berbahaya dalam kod, walaupun ia menyumbang kepada peningkatan keseluruhan dalam kualiti).
Oleh itu, ia sentiasa penting untuk memberi perhatian kepada reka bentuk kod dan mengulas pada bahagian kompleks kod.Pendekatan prosedur
Sebagai contoh:
$c = $a % $b;
$e + $d;
echo round($e);
?>
Pendekatan fungsional
Selain itu, setiap fungsi akan mempunyai skop pembolehubahnya sendiri. Iaitu, pembolehubah "hidup di dalamnya" tidak akan pernah bocor di luar dan pembolehubah yang digunakan di luar fungsi juga tidak akan berakhir dalam fungsi itu sendiri.
Dengan mentakrifkan fungsi, anda sendiri boleh menentukan pembolehubah mana yang harus dimasukkan ke dalam fungsi dan apa yang harus dikembalikan, iaitu, anda mengawal proses ini dengan ketat.
fungsi getPrice($price, $weight) (
$harga_hasil * $berat;
pulangkan $hasil_harga;
}
//kembali semua pemberat
fungsi getWeights() (
tatasusunan kembali (5, 12, 14, 16, 22, 135, 150, 200, 254, 300, 400);
}
$menimbang semua buah
foreach ($buah sebagai $buah) (
foreach ($berat sebagai $berat) (
echo $buah["nama"] . " " . $berat. "kos kg". getPrice($buah["harga"], $berat) . "gosok.
";
}
}
?>
Saya melalui semua buah-buahan dan dengan setiap pencarian saya melalui semua berat. Ia boleh dilakukan sebaliknya.
Sumber pada pastebin http://pastebin.com/07QTBihX
awam $buah-buahan;
timbangan awam;
$ini->buah = $buah;
$this->weights = $weights;
}
$harga_hasil = $harga * $berat;
pulangkan $hasil_harga;
}
//isih semua buah
foreach ($ini->buah sebagai $buah) (
// lelaran melalui semua pemberat bagi setiap buah
foreach ($ini->berat sebagai $berat) (
echo $buah["nama"] . " " . $berat. "kos kg". self::getPrice($fruit["price"], $weight) . "gosok.
";
}
}
}
}
$fruiting->setData($fruits, array(5, 12, 14, 16, 22, 135, 150, 200, 254, 300, 400));
$fruiting->getResult();
?>Alat untuk membuat bar navigasi
Dan
mencipta senarai bertitik tumpu dan
Mari buat model navigasi mendatar
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
Dan kini secara menegak. Saya kata menegak!
Sub-item dalam menu: senarai juntai bawah
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
