IDEA IntelliJ: Gaya pengekodan dan pemformatan kod

Bahasa pengaturcaraan sangat serupa dengan bahasa pertuturan. Cuma bezanya ia adalah bahasa khas yang tujuan utamanya adalah untuk memudahkan komunikasi dengan komputer untuk menerangkan kepada komputer apa yang kita mahu ia lakukan. Tetapi anda tidak boleh mengadakan perbualan peribadi dengan komputer. Apabila anda mula mempelajari bahasa pengaturcaraan, anda melihat buku atau beberapa sumber pendidikan seperti CodeGym. Dan sumber ini menunjukkan kepada anda kod yang difahami oleh komputer. Tetapi anda juga harus memahaminya semasa anda belajar tentang bahasa Jawa. Seperti mana-mana bahasa, beberapa konvensyen pemformatan telah diterima pakai dalam pengaturcaraan. Sebagai contoh, dalam masyarakat yang bersopan santun, MENULIS SEPERTI INI akan dianggap sebagai akhlak yang tidak baik. Dan di Jawa, memulakan nama kaedah dengan huruf besar adalah pelanggaran besar terhadap konvensyen pengekodan. Peraturan untuk kod Java diberikan dalam dokumen Konvensyen Kod untuk Bahasa Pengaturcaraan Java . Konvensyen pengekodan juga boleh mengawal butiran yang lebih kecil, seperti lekukan. Bayangkan mimpi ngeri yang akan dialami oleh kawalan versi jika lekukan tidak konsisten, sesetengah orang menggunakan tab dan orang lain menggunakan ruang. Bagaimanakah keadaan bagi seseorang yang perlu menyemak pembetulan dalam satu kaedah sahaja, tetapi mendapati keseluruhan fail berubah disebabkan perbezaan dalam ruang dan tab? Sudah tentu, seperti bahasa biasa, konvensyen mungkin berubah bergantung pada tempat bahasa digunakan. Sebagai contoh, dalam keluasan web yang luas, anda boleh menemui Panduan Gaya Google Java dan Panduan Gaya Java Twitter. Untuk semakan ini, kami memerlukan subjek ujian. Kami akan menggunakan sistem automasi binaan Gradle. Ia akan membolehkan kami bermula dengan cepat dengan mencipta projek baharu daripada templat. Gradle mempunyai pemalam yang hebat: Bina Init Plugin . Mari pergi ke direktori baharu dan jalankan arahan berikut di sana: gradle init --type java-application Selepas itu, mulakan IntelliJ IDEA. Jika anda melihat tetingkap dengan projek terbuka (iaitu anda melihat editor kod dan pokok projek), tutup projek ini menggunakan File -> Close Project. Sekarang dalam tetingkap alu-aluan, jalankan " Import Project" dan import projek baharu kami. Apabila mengimport, tetapkan Use autoimportkotak semak " ". Mari kita fikirkan sama ada kita boleh menggunakan alat pembangunan terkini untuk memudahkan kehidupan.

Pemformatan kod dalam IDEA

Selepas mengimport projek, tekan Ctrl+N dan pergi ke AppTestkelas. Ini ialah kelas ujian lalai. Ia kelihatan seperti ini:

 import org.junit.Test;
 import static org.junit.Assert.*;
 
 public class AppTest {
     @Test public void testAppHasAGreeting() {
         App classUnderTest = new App();
         assertNotNull("app should have a greeting", classUnderTest.getGreeting());
     }
 }

Apa yang segera menarik perhatian anda? Anotasi pada baris yang sama dengan pengisytiharan kaedah, yang kelihatan hodoh, bukan? Bagaimana untuk membetulkannya? IntelliJ IDEA mempunyai Codeentri menu " " untuk pelbagai manipulasi kod. Satu manipulasi sedemikian ialah " Reformat Code", yang boleh anda gunakan menggunakan Ctrl+L. Selepas anda melakukan ini, anotasi akan berada pada satu baris, dan pengisytiharan kaedah pada baris lain. Perlu diingat dengan segera bahawa operasi ini dilakukan pada kod yang dipilih pada masa ini . Jika tiada pemilihan, maka operasi pemformatan dilakukan pada segala-galanya. Sekarang mari tambah kaedah ujian baharu:

 @Test
 public void testSumOfOddNumbers() {
 	List<Integer> data = Arrays.asList(1, 4, 2, 3, 6, 7, 9);
 	Integer result = data.stream().filter(number -> number % 2 == 0).reduce((n1, n2) -> n1 + n2).get();
 	assertThat(result, is(12));
 }

Dan dua import:

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

Seperti yang anda lihat, operasi pada Strim adalah pada satu baris. Tetapi bagaimana jika kita ingin memastikan bahawa panggilan kaedah berantai sentiasa dibahagikan kepada baris baharu pada setiap pengendali tempoh? Kami boleh melakukan ini secara manual. Tetapi ingat bahawa kita mahu segala-galanya berlaku secara automatik. Sesungguhnya, kami pasti akan melupakan langkah manual dari semasa ke semasa, dan kemudian kami akan berakhir dengan pemformatan yang berbeza di mana-mana, dan itu tidak baik. Jadi kita perlu mengedit peraturan yang IDEA gunakan untuk pemformatan. pilihFile -> Settingsdalam menu IDEA (atau tekan Ctrl+Alt+S). Masukkan "Gaya kod" dalam medan carian dalam tetingkap tetapan. Dalam bahagian "Gaya kod", anda boleh menentukan tetapan untuk lebih banyak bahasa daripada Java sahaja. Tetapi Java adalah apa yang kami minati sekarang. Seperti yang anda lihat, tetapan dibahagikan kepada beberapa tab. Ciri yang sangat berguna ialah contoh operasi ditunjukkan di bahagian kanan tetingkap: Tangkapan skrin menunjukkan bahawa kita boleh menetapkan "Panggilan kaedah berantai" kepada "selalu balut", iaitu sentiasa memisahkan panggilan kaedah berantai ke dalam talian berasingan. Sekarang klik butang pemformatan sekali lagi dalam kelas ujian dan kami melihat bahawa ia benar-benar berfungsi! Tetapi kadangkala anda perlu memformatkan beberapa kod di luar peraturan pemformatan standard. Sediakan pemformatan seperti berikut: Untuk mengelakkan pemformatan, dalam bahagian "Gaya Kod", dayakan penanda pemformat: Sekarang kita boleh menukar kelas ujian kami supaya kodnya tidak diformatkan semula:

 @Test
 public void testSumOfOddNumbers() {
 	List<Integer> data = Arrays.asList(1, 4, 2, 3, 6, 7, 9);
 	// @formatter:off
 	Integer result = data.stream().filter(number -> number % 2 == 0)
                              .reduce((n1, n2) -> n1 + n2)
                              .get();
 	assertThat(result, is(12));
 	// @formatter:on
 }

Anda mungkin perasan bahawa apabila anda menekan Tab, IDEA mentafsirkannya sebagai ruang (ini ialah tingkah laku lalai). Tetapi anda boleh menukar ini dalam Code Stylebahagian " ": Seperti yang anda lihat, terdapat banyak tetapan di sana. Anda boleh membaca butiran lanjut tentang Code styletetapan " " di sini: " Bantuan IDEA: Gaya Kod ". Terdapat satu lagi ciri pemformatan penting: memformat import. Operasi ini dijalankan secara berasingan dan dipanggil " Optimize Imports". Ia terletak di bawah Code -> Optimize Imports(Ctrl+Alt+O). Mengoptimumkan import mengalih keluar import yang tidak perlu dan mengatur import dalam susunan yang betul mengikut tetapan dalam Importstab " " pada Code Styletetapan " " untuk Java. Apatah lagi, jika anda mahu pemformatan ini berlaku secara automatik, ada berita baik:pemalam Save Actions .

Mengedarkan tetapan dalam arahan

Kami melihat di atas bahawa anda boleh menyesuaikan gaya pemformatan anda mengikut kehendak anda. Tetapi bagaimana anda menggunakan gaya ini dalam satu pasukan? Sangat mudah. Terdapat beberapa pilihan. Yang paling mudah ialah menyimpan skema gaya kod. Buka tetapan IDEA menggunakan File -> Settings(atau tekan Ctrl+Alt+S). Dalam Code Stylebahagian " ", kita boleh melihat "Skim". Ini adalah skema pemformatan kami. Secara lalai, skema "Lalai" digunakan dan dilabelkan "IDE", yang bermaksud bahawa tetapan ini hanya digunakan pada IDE kami — ia tidak menjejaskan orang lain. Untuk membuat skema "tersuai", gunakan butang di sebelah kanan untuk membuat salinan dan beri nama, contohnya: CodeGym Kemudian kita boleh mengimport atau mengeksport tetapan: Pilihan lain ialah mengimport tetapan IDEA: Pilihan ketiga ialah Repositori Tetapan. Untuk menggunakan Repositori Tetapan, lihat dokumentasi Bantuan IntelliJ IDEA untuk mendapatkan butiran lanjut di pautan berikut: Repositori Tetapan ". Bercakap tentang mendorong gaya bersatu pada pasukan, saya juga tidak boleh tidak menyebut sokongan yang baik untuk gaya daripada Eclipse IDE. Untuk melakukan ini, anda perlu memasang pemalam berasingan: buka tetapan IDEA melalui Fail -> Tetapan (Ctrl+Alt+S) dan pergi ke bahagian "Pemalam". Untuk mencari pemalam baharu, klik butang " ". Browse RepositoriesKemudian cari pemalam Pemformat Kod Eclipse dalam tetingkap carian. Selepas memasangnya, anda perlu memulakan semula IDEA — ini adalah prosedur standard. Sekarang semuanya selesai. Terdapat bahagian baharu dalam tetapan IDEA: "Pemformat Kod Eclipse".. Ia akan kelihatan seperti ini:

Keperluan yang lebih ketat

Selain alat IDEA, anda juga boleh menggunakan pemalam automasi binaan untuk mengetatkan keperluan. Tidak ada cara anda boleh menyemak secara manual sama ada seseorang telah menggunakan pemformatan yang betul. Mungkin anda boleh dengan 5 orang dalam satu pasukan. Tetapi dengan 100 orang di sebuah syarikat, ia tidak realistik. Dan walaupun lima akan sukar untuk dikesan. Dan mengapa membuang masa anda untuk semua ini? Adalah lebih mudah untuk menghalang projek daripada dibina jika peraturan dilanggar. Sebenarnya, ini adalah topik berasingan yang dipanggil "Kod Periksa". Dalam artikel ini, saya hanya ingin menunjukkan kepada anda cara ia berfungsi. Salah satu pemalam Gradle yang paling popular (kerana ia membina projek kami, anda akan ingat) ialah pmd. Untuk mendayakannya, hanya pergi ke skrip binaan projek Gradle kami (fail build.gradle pada akar projek kami) dan tambah pmd padanya di sebelah pemalam yang lain:

 plugins {
     // Apply the java plugin to add support for Java
     id 'java'
     // Check source code
     id 'pmd'
     // Apply the application plugin to add support for building an application
     id 'application'
 }

Kini kita boleh memasukkan tetapan yang lebih terperinci di tempat yang sama:

 pmd {
     ignoreFailures = false
     pmdTest.enabled = true
     ruleSets = [
             'java-basic',
             'java-braces',
             'java-clone',
             'java-codesize',
             'java-comments',
             'java-controversial',
             'java-coupling',
             'java-design',
             'java-empty',
             'java-finalizers',
             'java-imports',
             'java-optimizations',
             'java-strictexception',
             'java-strings',
             'java-typeresolution',
             'java-unnecessary',
             'java-unusedcode'
     ]
 }

Malah projek kami rosak sekarang. Jalankan gradle builddan kami mendapat ralat. Perkara yang menarik ialah laporan dihasilkan semasa pembinaan. Dan jika terdapat ralat, kami mendapat mesej seperti ini:

 BUILD FAILED in 35s
 6 actionable tasks: 6 executed
 7 PMD rule violations were found. See the report at: file:///C:/_study/codestyle/build/reports/pmd/main.html

Pergi ke laporan, kita melihat sesuatu seperti ini: Selain itu, lajur " Problem" menyediakan pautan kepada penerangan masalah pada tapak web pemalam pmd. Contohnya, untuk headerCommentRequirement Requiredralat " ", pautan pergi ke sini: pmd — CommentRequired . Ralat ini adalah petunjuk bahawa kelas kami tidak mempunyai JavaDoc. Kita boleh menggunakan templat untuk mengkonfigurasi JavaDoc di atas kelas: Dan nyatakan kandungan untuk File Header: Selepas itu, kita boleh menukar ulasan di atas kelas App menjadi JavaDoc dan melihat bahawa ralat telah hilang dalam binaan baharu.

Garisan bawah

Gaya kod adalah penting untuk memaksimumkan produktiviti pada projek. Kod cantik yang ditulis mengikut peraturan dikongsi menjamin bahawa rakan sekerja anda akan lebih mudah dan cepat memahaminya dan tidak akan memberikan anda kritikan. Dengan alat pembangunan moden, tidaklah begitu sukar untuk mematuhi peraturan gaya. Saya harap ulasan ini telah membuktikan kepada anda bahawa ini adalah benar. Mengikuti tradisi, berikut ialah sedikit bahan tambahan mengenai topik:

• Video daripada JetBrainsTV: " Inspect Code (IntelliJ IDEA) "
• Semakan " Analisis Kod Dengan Pemalam Gradle "
• Kursus " Automatikkan Kualiti Kod "