Mengapa masih ada sensitivitas case dalam beberapa bahasa pemrograman?

Saya tidak melihat ada gunanya sensitivitas case dalam bahasa pemrograman, selain dari kode yang membingungkan.

Mengapa menerapkan ini dalam bahasa pemrograman?

Memperbarui:

Sepertinya seseorang yang Anda kenal membuat pernyataan tentang ini .

Sementara lipat case cukup sepele dalam bahasa Inggris, itu jauh lebih sedikit dalam beberapa bahasa lain. Jika seorang programmer Jerman menggunakan ßnama variabel, apa yang akan Anda pertimbangkan setara huruf besar? Hanya FYI, "ß" hanya digunakan dalam huruf kecil. OTOH, "ss" adalah setara - apakah Anda menganggap kompiler wajib mencocokkannya? Saat Anda masuk ke Unicode, Anda akan mendapatkan masalah yang lebih menarik, seperti karakter dengan tanda diakritik yang sudah dikomposisikan sebelum digabungkan dengan menggabungkan diakritik. Kemudian Anda sampai pada beberapa naskah Arab, dengan tiga bentuk terpisah dari banyak surat, bukan hanya dua.

Pada zaman kegelapan, sebagian besar bahasa pemrograman tidak peka terhadap huruf besar-kecil karena kebutuhan. Sebagai contoh, Pascal dimulai pada mainframe Data Kontrol, yang hanya menggunakan enam bit per karakter (64 kode, total). Sebagian besar mesin seperti itu menggunakan set karakter "CDC Scientific", yang hanya berisi karakter huruf besar. Anda dapat beralih ke rangkaian karakter lain, tetapi sebagian besar memiliki huruf besar atau huruf kecil, tetapi tidak keduanya - tetapi menggunakan kode yang sama untuk keduanya. Hal yang sama berlaku untuk kode Baudot kuno dan standar yang dianggap seperti itu pada hari-hari awal COBOL, FORTRAN, BASIC, dll. Pada saat lebih banyak perangkat keras yang mampu tersedia secara luas, kepekaan case-nya sudah tertanam dengan sangat teliti sehingga mengubah itu tidak mungkin .

Seiring waktu, kesulitan nyata dari ketidakpekaan kasus menjadi lebih jelas, dan perancang bahasa sebagian besar telah memutuskan ("menyadari" mungkin akan menjadi istilah yang lebih akurat) bahwa ketika / jika orang benar-benar menginginkan ketidakpekaan kasus, bahwa itu lebih baik ditangani oleh alat bantu tambahan dari pada bahasa itu sendiri.

Setidaknya IMO, kompiler harus mengambil input persis seperti yang disajikan, bukan memutuskan bahwa "Anda menulis ini, tapi saya akan menganggap Anda benar-benar berarti sesuatu yang lain." Jika Anda ingin terjemahan terjadi, Anda lebih baik melakukannya secara terpisah, dengan alat yang dibangun untuk mengatasinya dengan baik.

Mengapa ada yang INGIN peka terhadap kasus? Dalam skenario apa berguna untuk dapat merujuk ke variabel tunggal seperti VARIABLEdi satu tempat, Variabledi tempat lain, dan variabledi tempat ketiga? Ketidakpekaan case menjengkelkan. Saya lebih suka mendapatkan kesalahan kompiler ketika saya tidak sengaja mengetik VAriablealih- Variablealih membiarkan case-typos seperti itu masuk ke dalam kode saya.

Kesimpulannya, banyak bahasa pemrograman memiliki sensitivitas huruf besar bukan hanya karena alasan historis / inersia tetapi karena ketidakpekaan huruf adalah ide yang buruk.

Dalam Java case sensitivitas TIDAK digunakan untuk memberikan lebih banyak opsi dalam kode, tetapi lebih untuk makna semantik yang sangat jelas dan konsisten. Kelas Lihat Seperti Ini. benda LihatLikeThis. methodsLookLikeThis (). STATIC_VARIABLES_LOOK_LIKE_THIS. Kelas. Dengan kacamata dalam, lihat seperti ini. Ini TIDAK memberikan kebebasan yang lebih besar: itu memungkinkan Anda untuk mengemas beberapa informasi secara ringkas ke dalam apa yang merupakan bahasa yang terlalu bertele-tele.

Saya pikir dalam bahasa yang diketik secara statis secara statis dengan banyak kompiler dan dukungan IDE, sensitivitas huruf adalah cara yang bagus untuk mengkomunikasikan informasi (misalnya, Java). Dengan bahasa seperti Ruby, ketidakpekaan huruf besar kemungkinan akan menyebabkan hasil LEBIH BANYAK yang tak terduga, meskipun saya akan terbuka untuk mencoba Ruby yang tidak peka terhadap huruf besar-kecil.

Saya pikir sensitivitas case dengan sistem yang ketat tidak mengaburkan kode tetapi sebenarnya membuatnya lebih jelas. Pertimbangkan kemungkinan kode Java:

      joe blah = new hUf();

itu cukup jelas, tetapi bagaimana dengan:

      hUf.WTF();

Di Java apa adanya, Anda akan secara otomatis tahu apa ini. Dalam Java case-insensitive, ini ambigu, jadi Anda harus menggunakan beberapa mekanisme lain untuk membedakan kelas dari instance dari paket dari metode. Dan mekanisme itu mungkin akan membuat Anda muntah dengan betapa buruknya itu :)

Saya tidak berpikir itu "diimplementasikan" sebanyak "diizinkan." Sensitivitas huruf adalah keadaan standar perbandingan string; dibutuhkan kerja ekstra untuk insinyur kompiler untuk membuat bahasa tidak sensitif, karena Anda perlu menambahkan kode tambahan untuk melakukan perbandingan tidak sensitif-huruf dan mempertahankan nama token asli untuk kesalahan dan pelaporan peringatan yang benar.

Itu hampir pasti mengapa berakhir di C; mereka ingin membuat bahasa sederhana yang mudah diimplementasikan untuk kompiler, dengan mengorbankan kegunaan. Adapun mengapa itu di bahasa modern? Karena itu dalam C, tentu saja, jadi itu harus menjadi cara yang tepat untuk melakukannya! </ Mode sarkasme>

Jika tidak ada yang lain, ini menyederhanakan penguraian dan memungkinkan Anda lebih banyak kombinasi untuk nama variabel / kelas.

Dengan penguraian case-insensitive, Anda akan diharuskan untuk menggunakan pengidentifikasi unik, karena 'myClass' dan 'MyClass' akan menjadi hal yang sama. Sebagai alternatif, Anda harus menambahkan lapisan kompleksitas ke parser Anda untuk memastikan Anda dapat menentukan pengidentifikasi yang digunakan berdasarkan konteks.

Pertimbangkan kasus seperti ini:

XmlWriter xmlWriter = new XmlWriter();
xmlWriter.Write("blah");

Misalkan kelas XmlWriter juga memiliki metode statis yang disebut "Tulis". Apakah Anda menyebutnya pada instance atau di kelas, jika tidak ada case-sensitivitas yang diterapkan di sini?

Saya suka sensitivitas huruf jika tanpa alasan lain selain membuat kode lebih mendokumentasikan diri:

this is a CONSTANT
this is a ClassName
this is a methodName
this is a local variablename

Saya biasanya memprogram dengan Python, tetapi kembali pada hari C # saya, saya merasa sangat nyaman untuk memberi nama instance kelas yang sama dengan kelas, tetapi huruf kecil (atau unta) (seperti yang orang lain katakan):

Thing thing = new Thing();

Menggunakan bahasa yang case-sensitive membutuhkan beberapa konvensi lain untuk ini, yaitu, semacam sigil seperti:

Thing oThing = new Thing()
Thing instanceOfThing = new Thing()

Yang merupakan "hal buruk".

Saya juga merasa nyaman untuk grep (case-sensitive) untuk menemukan referensi ke kelas vs penggunaan variabel. Dengan bahasa yang tidak peka huruf besar kecilnya, ini akan menjadi tidak mudah. Sama untuk pencarian & ganti.

Terakhir, sebagai seorang programmer, ketika saya melihat kata-kata dengan kasus yang berbeda, saya tahu bahwa itu adalah hal yang berbeda ... Saya jarang memiliki bug di mana kasus variabel salah, bahkan dalam bahasa skrip dinamis, di mana kompiler akan membantu.

Orang memperhatikan bentuk kata sebelum mereka benar-benar membacanya. Sensitivitas case menjaga bentuk simbol konsisten di seluruh kode. Saya juga setuju dengan yang di atas yang menyatakan bahwa konvensi yang berbeda menunjukkan jenis simbol yang berbeda. Sensitivitas dan sensitifitas kasus keduanya dapat disalahgunakan. Pemrogram yang buruk akan selalu menghasilkan kode yang buruk ... mereka akan menemukan jalan.

Ambil bahasa sebagai contoh. Mengapa kita memulai kalimat dan menamai benda dengan huruf kapital ... Apakah itu juga karena unix?

Saya pikir untuk lanaguage yang diketik secara statis seperti C # dan Java, itu tidak benar-benar menambah nilai. Karena dalam kebanyakan kasus, Anda memiliki IDE yang akan memperbaiki ketidaksesuaian case secara otomatis untuk Anda, jadi pada akhirnya, jika saya mengetik "VAriable" secara tidak sengaja, IDE saya akan memperbaiki secara otomatis untuk " Variabel "untuk saya. Tambahkan ke MyClass myClass;konvensi gaya dan Anda dapat melihat bahwa sensitivitas case tidak selalu merupakan hal yang buruk.

Untuk bahasa yang diketik secara dinamis, mungkin ada lebih banyak argumen, karena lebih sulit bagi IDE untuk menebak koreksi otomatis, tetapi dalam kasus bahasa yang diketik secara dinamis, Anda sudah punya banyak hal yang perlu dikhawatirkan (dalam hal kesalahan ketik) bahwa menggunakan konvensi casing yang konsisten tidak akan menambah beban yang jauh lebih banyak.

Jadi ya, sementara tidak ada alasan nyata bahasa tidak bisa tidak peka terhadap huruf besar-kecil, juga tidak ada alasan nyata mengapa mereka harus memilih keduanya.

Artikel dari Scott Hanselman tentang "SignOn" vs "Signon" adalah tentang perbandingan string, dan tidak ada hubungannya dengan bahasa pemrograman. Saya setuju bahwa string yang diketikkan oleh pengguna harus selalu dibandingkan dengan case-insensitive, tapi saya pikir itu adalah ballgame yang berbeda dengan pengidentifikasi dalam bahasa pemrograman.

Ketika suatu bahasa peka terhadap huruf besar-kecil, saya memanfaatkannya untuk mereproduksi penggunaan kasus konvensional dalam matematika dan sains. Berikut adalah daftar (tidak berarti lengkap) dari beberapa konvensi kasus:

• Dalam teori probabilitas, huruf kecil fbiasanya mewakili fungsi kerapatan probabilitas (pdf), sedangkan huruf besar Fmewakili fungsi distribusi kumulatif yang sesuai (cdf).
• Juga dalam teori probabilitas, huruf besar menunjukkan variabel acak X, dan huruf kecil yang sesuai menunjukkan realisasi mereka x, seperti dalam $ Pr [X = x] \ leq 0,05 $.
• Dalam aljabar linier, huruf besar biasanya digunakan untuk merujuk ke matriks sedangkan huruf kecil umumnya digunakan untuk merujuk ke angka, misalnya, $ A = [a_ {ij}] $.
• Simbol satuan ditulis dalam huruf kecil (misalnya, m untuk meter) kecuali untuk liter (L) dan unit-unit tersebut berasal dari nama seseorang (W untuk Watt, Pa untuk Pascal, N untuk Newton, dan sebagainya).
• Simbol awalan yang berarti satu juta atau lebih dikapitalisasi (M untuk mega (jutaan)), dan yang kurang dari satu juta adalah huruf kecil (m untuk mili (ribuan)).

Saya baru saja mengira itu karena Unix dan C - tapi itu semacam masalah ayam dan telur yang hanya bisa dijawab dengan baik oleh kakek tua.

Saya menggunakan alasan bahwa Ayam dalam "Kelinci Paskah Datang ke Kota" digunakan ketika ditanya apakah mereka datang sebelum Telur. Karena ada ayam di Bahtera Nuh, ayam lebih dulu. Oleh karena itu, karena GCC berjalan pada Unix, Unix datang pertama, karena itu karena Unix sangat peduli pada kasus, C dan semua varian dan turunannya, ya apa pun yang memaksakan kurung kurawal, peduli pada kasus.

Mungkin ada hubungan antara kurung kurawal dan sensitivitas case juga.

Selain jawaban luar biasa yang diberikan sejauh ini, saya ingin menunjukkan bahwa sensitivitas huruf memberi Anda juga "ruang nama" tambahan. Misalnya Perl memiliki beberapa blok khusus seperti BEGINdan ENDyang berjalan pada waktu yang berbeda dari kode normal (BEGIN pada waktu kompilasi, AKHIR setelah program normal dihentikan), dan menjadikannya sebagai huruf besar membuat semuanya menonjol, dan berarti huruf kecil varian bukan kata yang dipesan.

Seseorang dapat melangkah lebih jauh dan memesan semua huruf besar untuk penggunaan di masa depan oleh bahasa, dan tidak membahayakan programmer normal, yang biasanya TIDAK BERTEMU DALAM KODE MEREKA.

"Peka huruf besar kecil" selalu lebih baik bagi orang teknis untuk mengurangi ambiguitas. Ambil nama file sebagai contoh. Berurusan dengan nama file Windows lebih banyak masalah daripada nama file Unix karena nama file di Windows adalah case-sensitive sedangkan nama file di Unix adalah case-sensitive.

Kembali ke pemrograman. Untuk nama kelas, nama metode, nama variabel, sebagian besar bahasa tidak menerapkan aturan gaya penamaan. Terkadang demi kesederhanaan untuk melakukan "refleksi", kita dapat menggunakan nama "Case case" untuk mengikat ke sumber data lain tanpa konversi, atau menangani masalah dengan nama yang sama tetapi dalam kasus yang berbeda.

Saya terkejut dengan kata-kata kasar ini. Sekarang tidak ada yang ingin Anda menggunakan garis bawah atau m_dalam nama bidang di C #, saya baru saja menggunakan kasing unta, dan jika nama bidang sama dengan nama properti publik, hanya saja nama properti publiknya adalah huruf Pascal dan bidang dukungan adalah kasus unta, saya pikir, "jadilah itu" - itulah yang tampaknya diinginkan oleh komunitas pemrograman. Sejauh ini belum ada masalah.

Terutama beberapa programmer berasal dari hari-hari awal BASIC, di mana nama variabel hanya bisa 2 karakter.

Jadi, ketika bisa sejumlah karakter, mereka menjadi sangat senang. Dan seiring dengan sensitivitas huruf - karena mereka tidak ingin juga peduli untuk SomeNamemenjadi sama secara tidak sengaja SOMENAMEdan menyebabkan bug karena hal-hal seperti ini.