Apakah awalan jenis dan cakupan bermanfaat untuk konvensi penamaan?

Baru-baru ini memulai pekerjaan pertama saya sebagai pengembang perangkat lunak, saya sedikit terlempar untuk diberitahu bahwa saya tidak harus mengikuti konvensi penamaan dalam kode saya. Kode yang ditulis oleh kelompok-kelompok yang mengerjakan proyek lain yang lebih besar mengikuti konvensi penamaan, tetapi karena saya diminta untuk menulis aplikasi baru yang berdiri sendiri, perasaan bahwa itu tidak terlalu penting. Itu adalah kekhawatiran terakhir saya, jadi saya hanya mengambil konvensi yang ada dan menjalankannya.

int nTickCount  
bool bConnected  
object[] m_aItems  
fSum += fWeight * fValue  
class cManager  
enum etSystemStates  
etSystemStates eState   
cManager.cs

Tetapi apakah ini benar-benar bermanfaat? Saya merasa sulit untuk menilai efek bersih yang mengikuti konvensi penamaan seperti ini pada pemahaman dan deteksi kesalahan, tetapi, secara visual , itu hanya terlihat agak jelek. Plus, memiliki setiap kelas dan file dalam proyek yang disebut cSomething tampaknya cukup bodoh.

Saya tidak berada di bawah ilusi bahwa ini adalah masalah besar yang jauh jika dibandingkan dengan hal-hal yang membuat perbedaan nyata, seperti algoritma dan arsitektur yang Anda gunakan. Tetapi setiap konvensi yang memengaruhi setiap baris kode yang saya tulis sepertinya layak untuk diperbaiki.

Apa yang Anda temukan dari konvensi penamaan yang paling elegan dan efektif, jika perlu digunakan? Apakah ini menunjukkan tipe dan / atau cakupan?

Joel Spolsky menulis artikel tentang mengapa notasi Hongaria ada dan apa yang dimaksudkan untuk itu dapat membantu menjawab pertanyaan Anda.

Awalan seperti tbl untuk tabel basis data, int untuk bilangan bulat, dll. Umumnya tidak berguna - sepele untuk mencari tahu apa yang dari konteks atau dari alat pengembangan Anda dalam kasus tersebut. Sesuatu seperti imp untuk pengukuran kekaisaran dan bertemu untuk metrik jauh lebih masuk akal karena jika tidak, Anda hanya dapat melihat bahwa mereka adalah angka floating point.

area = width * height

terlihat sangat baik sementara

impArea = metWidth * impHeight

menunjukkan kepada Anda langsung bahwa ada sesuatu yang salah.

Secara pribadi saya hanya menggunakan nama variabel deskriptif. $ number_of_items jelas merupakan jumlah integer. $ input_file_handle, $ is_active dan $ encrypted_password memiliki tipe yang jelas baik dari segi tipe data bahasa dan tipe semantik.

Apa yang Anda gambarkan disebut notasi Hongaria . Ini pernah dianggap praktik terbaik, tetapi umumnya disukai sekarang.

Artikel Wikipedia berisi bagian tentang pro dan kontra.

Ya, awalan bisa bermanfaat, tetapi saya punya beberapa saran:

Jika seluruh tim Anda menggunakan konvensi yang sama, mereka menjadi jauh lebih berguna. Menggunakannya sendiri tidak terlalu membantu.

Dalam bahasa yang diketik dengan statis, jangan hanya menyalin tipe variabel. Misalnya "bSubscribed" adalah nama yang buruk untuk variabel boolean dalam C # atau Java, karena IDE Anda sudah tahu jenisnya. Di C di sisi lain, yang tidak memiliki tipe boolean, ini akan menjadi informasi yang berguna.

Di C # dan Java, Anda mungkin mempertimbangkan awalan untuk menunjukkan bahwa suatu objek mungkin nol. Atau string telah di-html. Atau itu mewakili ekspresi reguler, atau pernyataan sql. Atau array telah diurutkan. Gunakan imajinasimu.

Pada dasarnya ini adalah pertanyaan tentang bertanya pada diri sendiri apa yang ingin Anda beri nama variabel, dan itu sangat tergantung pada domain dan bahasa tempat Anda bekerja.

Ada beberapa "gaya" konvensi penamaan yang berbeda di luar sana, dan kebanyakan dari mereka memiliki nilai dalam membuat kode dapat dimengerti.

Yang JAUH lebih penting adalah: menggunakan nama deskriptif untuk variabel dan fungsi. Dalam contoh Anda dengan "jumlah", "berat" dan "nilai", Anda mungkin ingin memberikan nama yang lebih bermakna: "totalCost", "lumberWeight", "lumberValuePerOunce" (Saya membuat beberapa asumsi di sini)

Saya menemukan konvensi seperti nama variabel yang diawali dengan karakter menandakan tipe yang cukup mengganggu dalam kebanyakan bahasa modern.

Sebagian besar pengembang .NET mengikuti Pedoman Desain Microsoft ( http://msdn.microsoft.com/en-us/library/ms229042.aspx ), yang sangat mirip dengan Java (perbedaan utamanya adalah Microsoft mendukung Pascal Case untuk nama anggota, sementara Java nikmat Kasus unta).

Selain itu, saya akan mengatakan sampel kode Anda jauh lebih mudah dibaca karena kebisingan tambahan yang Anda tambahkan.

Saya menemukan bahwa, untuk sebagian besar, panduan gaya pengkodean Google cukup bagus. Karena Anda diberitahu bahwa Anda dapat menggunakan gaya apa pun yang Anda suka, saya pikir Anda harus mulai dengan melihat ini, dan memilih dan memilih dari itu.

Awalan nama variabel dengan tipe data (terutama tipe data primitif) meningkatkan kebisingan visual, serta risiko bahwa perubahan kecil jika tidak akan menjadi penggantian nama besar-besaran.

Kembali ke poin pertama, apakah "intStudentCount" benar-benar lebih jelas daripada misalnya "numberOfStudents"? Bukankah "invoiceLineItems" setidaknya informatif seperti "aobjItems". (Tipe data harus tentang arti data dalam domain masalah, bukan representasi tingkat rendah.)

Adapun poin kedua, apa yang terjadi ketika mis pemilihan int dini diganti dengan panjang atau ganda? Lebih buruk lagi, apa yang terjadi ketika kelas konkret di refactored menjadi antarmuka dengan beberapa kelas implementasi? Praktik apa pun yang menambah beban skenario perawatan realistis tampaknya dipertanyakan bagi saya.

Mungkin juga tergantung pada mengapa Anda mengawali nama, bukan apa yang Anda awali.

Sebagai contoh, saya cenderung menggunakan awalan 1-2 huruf untuk nama-nama kontrol pada formulir. Bukan karena saya tidak tahu bahwa kompiler akan dengan mudah menemukan kelas yang tepat untuk tombol (sebagai contoh), tetapi saya cenderung mendesain bentuk besar terlebih dahulu, kemudian menulis sebagian besar kode setelahnya.

Memiliki awalan bt untuk tombol-tombol membuatnya mudah untuk menemukan tombol yang tepat sesudahnya, daripada memiliki banyak nama yang disatukan.

Saya tidak menggunakan awalan untuk variabel penamaan, baik untuk jenis (yang umumnya tidak berguna pula), maupun untuk makna, konteks atau unit (yang merupakan ide asli di balik Notasi Hongaria).

Dalam pandangan saya, itu tergantung pada bahasa dan ukuran proyek. Saya tidak pernah benar-benar pergi sejauh menggunakan awalan ketik pada semua variabel saya, tetapi Anda ingin memberi nama mereka dengan cara yang jelas.

Dalam bahasa yang diketik secara statis, seperti yang Anda gunakan, semakin saya merasa nyaman dengan sistem jenisnya, Notasi Hongaria yang kurang penting menjadi. Jadi di Java atau C # dan terutama di Haskell saya bahkan tidak akan berpikir tentang menambahkan awalan-awalan itu, karena alat Anda dapat memberi tahu Anda jenis ekspresi apa pun yang diberikan, dan akan menangkap sebagian besar kesalahan yang dihasilkan dari kesalahpahaman suatu tipe.

Awalan sering masuk akal untuk objek, misalnya dalam bentuk di mana Anda mungkin memiliki 20 kotak teks yang memanggil mereka semua tbSomethingmasuk akal.

Namun, kebanyakan saya tidak menganggapnya berharga, terutama untuk tipe nilai.

Misalnya, misalkan Anda memiliki:

short shortValue = 0;
//stuff happens

Berbulan-bulan kemudian Anda menemukan Anda perlu mengubahnya - pendek tidak cukup besar. Sekarang kamu punya:

int shortValue = 0;
//stuff happens

Kecuali Anda sekarang juga mengubah nama variabel (lebih berisiko melanggar kode daripada mengubah jenis dalam kasus ini) Anda sekarang memiliki kode membingungkan.

Lebih baik Anda memiliki nama yang menggambarkan apa yang dimilikinya:

int loopCounter = 0;
//stuff happens

Jika nanti itu perlu diubah menjadi lama: tidak ada masalah.

Mungkin ada lebih banyak argumen untuk konvensi ini dalam bahasa yang diketik secara dinamis atau yang tanpa IDE.

Saya selalu cenderung menggunakan singkatan karakter 2 hingga 4 untuk tipe di depan variabel itu sendiri. Terkadang terasa membosankan, tetapi ketika Anda bekerja dengan tipe atau situasi data yang kompleks, itu menjadi bermanfaat. Saya pikir itu termasuk dalam kategori kasus unta yang lebih rendah.

Melihat contoh Anda di atas, akan sedikit diperlengkapi menjadi:

int intTickCount;
bool boolConnected;
object[] aobjItems;

Array selalu memiliki a di depan tipe untuk menunjuk array. Ini juga memungkinkan saya untuk mengelompokkan instance variabel yang sama secara bersamaan. Misalnya, saya bisa menggunakan ...

taStore.Fill(dtStore);

... yang menunjukkan bahwa Store StoreAdapter saya sedang mengisi StoreTable Data.

Saya selalu berusaha mematuhi prinsip dasar bahwa awalan dan / atau sufiks harus dimasukkan hanya ketika itu membuat kode lebih mudah dibaca (seperti dalam bahasa Inggris biasa).

Semakin sedikit samar, semakin baik ...

Mengapa memiliki metode seperti ini:

public boolean connect( String h, int p );

Ketika Anda dapat memiliki sesuatu seperti ini:

public boolean connect( String hostName, int port );

Selain itu, IDE saat ini benar-benar memiliki alat yang kuat untuk refactoring (Terutama Java) variabel, nama metode, kelas, dll ... Gagasan untuk mengatakan informasi maksimum dengan jumlah karakter paling sedikit hanya kuno.