Saya selalu menginisialisasi string saya ke NULL, dengan pemikiran bahwa NULL berarti tidak adanya nilai dan "" atau String.Empty adalah nilai yang valid. Saya telah melihat lebih banyak contoh belakangan ini dari kode di mana String.Empty dianggap sebagai nilai default atau tidak mewakili nilai. Ini menurut saya aneh, dengan tipe nullable yang baru ditambahkan di c # sepertinya kami mengambil langkah mundur dengan string dengan tidak menggunakan NULL untuk mewakili 'No Value'.
Apa yang Anda gunakan sebagai penginisialisasi default dan mengapa?
Sunting: Berdasarkan jawaban saya lanjutkan pemikiran saya selanjutnya
Menghindari penanganan kesalahan Jika nilainya tidak boleh nol, mengapa harus diatur ke
NULL
tempat pertama? Mungkin akan lebih baik untuk mengidentifikasi kesalahan di tempat itu terjadi daripada menutupinya melalui seluruh basis kode Anda?Menghindari cek nol. Jika Anda bosan melakukan cek nol dalam kode, bukankah lebih baik mengabstraksi cek nol? Mungkin membungkus (atau memperpanjang!) Metode string untuk membuatnya
NULL
aman? Apa yang terjadi jika Anda terus-menerus menggunakanString.Empty
dan null terjadi untuk masuk ke sistem Anda, apakah Anda mulai menambahkanNULL
cek?
Mau tak mau aku kembali ke pendapat bahwa itu adalah kemalasan. Setiap DBA akan menampar Anda sembilan cara untuk konyol jika Anda menggunakan '' alih-alih null
dalam database-nya. Saya pikir prinsip-prinsip yang sama berlaku dalam pemrograman dan harus ada seseorang untuk menampar mereka yang terbalik yang menggunakan String.Empty
daripada NULL
tidak mewakili nilai.
Pertanyaan-pertanyaan Terkait
Jawaban:
+1 untuk membedakan antara "kosong" dan NULL. Saya setuju bahwa "kosong" berarti "valid, tetapi kosong" dan "NULL" berarti "tidak valid."
Jadi saya akan menjawab pertanyaan Anda seperti ini:
kosong ketika saya menginginkan nilai default yang valid yang mungkin atau tidak dapat diubah, misalnya, nama tengah pengguna.
NULL ketika itu adalah kesalahan jika kode berikutnya tidak menetapkan nilai secara eksplisit.
sumber
Menurut MSDN :
Namun selalu menggunakan
IsNullOrEmpty()
adalah praktik yang baik.sumber
Mengapa Anda ingin string Anda diinisialisasi sama sekali? Anda tidak harus menginisialisasi variabel ketika Anda mendeklarasikan variabel, dan IMO, Anda hanya harus melakukannya ketika nilai yang Anda tetapkan valid dalam konteks blok kode.
Saya sering melihat ini:
Tidak menginisialisasi ke nol akan sama efektifnya. Selain itu, paling sering Anda ingin nilai diberikan. Dengan menginisialisasi ke nol, Anda berpotensi kehilangan jalur kode yang tidak memberikan nilai. Seperti itu:
Ketika Anda tidak menginisialisasi ke nol, kompiler akan menghasilkan kesalahan yang mengatakan bahwa tidak semua jalur kode menetapkan nilai. Tentu saja, ini adalah contoh yang sangat sederhana ...
Matthijs
sumber
= null
) akan menghasilkan peringatan, untuk alasan persis yang Anda nyatakan - tidak masalah apakah nilai default sebuah string adalah nol. jika Anda tidak menjamin penugasan melalui setiap jalur kode, IDE (dan / atau saya kira kompiler yang mendasari [?]) akan menghasilkan peringatan. Meskipun peringatan tidak akan mencegah kompilasi, mereka masih ada - meninggalkan yang mudah dipecahkan dapat membantu mengaburkan yang lain yang mungkin membutuhkan perhatian programmername
kenull
(tidak ada peringatan), karena setiap jalur kode memberikan nilai untukname
- tidak perlu diinisialisasi sama sekaliUntuk sebagian besar perangkat lunak yang sebenarnya bukan perangkat lunak pemrosesan string, logika program tidak boleh bergantung pada konten variabel string. Setiap kali saya melihat sesuatu seperti ini di sebuah program:
Saya mendapat firasat buruk. Mengapa ada string literal dalam metode ini? Pengaturan apa
s
? Apakah ia tahu bahwa logika bergantung pada nilai string? Apakah ia tahu bahwa huruf kecil harus bekerja? Haruskah saya memperbaiki ini dengan mengubahnya untuk digunakanString.Compare
? Haruskah saya membuatEnum
dan menguraikannya?Dari perspektif ini, seseorang dapat sampai pada filosofi kode yang cukup sederhana: Anda menghindari memeriksa konten string sedapat mungkin. Membandingkan string dengan
String.Empty
benar-benar hanya kasus khusus membandingkannya dengan literal: itu sesuatu yang harus dihindari kecuali Anda benar-benar harus melakukannya.Mengetahui hal ini, saya tidak berkedip ketika melihat sesuatu seperti ini di basis kode kami:
Saya tahu itu
Validate
tidak akan pernah kembaliString.Empty
, karena kami menulis kode yang lebih baik dari itu.Tentu saja, seluruh dunia tidak berfungsi seperti ini. Ketika program Anda berurusan dengan input pengguna, database, file, dan sebagainya, Anda harus menjelaskan filosofi lain. Di sana, itu adalah tugas kode Anda untuk memaksakan ketertiban pada kekacauan. Bagian dari urutan itu adalah mengetahui kapan string kosong berarti
String.Empty
dan kapan seharusnya artinyanull
.(Hanya untuk memastikan saya tidak berbicara keluar dari pantat saya, saya hanya mencari basis kode kami untuk `String.IsNullOrEmpty '. Semua 54 kejadian itu adalah dalam metode yang memproses input pengguna, mengembalikan nilai dari skrip Python, memeriksa nilai yang diambil dari API eksternal, dll.)
sumber
Ini sebenarnya adalah lubang menganga dalam bahasa C #. Tidak ada cara untuk mendefinisikan string yang tidak bisa nol. Ini menyebabkan masalah sesederhana yang Anda gambarkan, yang memaksa pemrogram untuk membuat keputusan yang tidak harus mereka buat, karena dalam banyak kasus NULL dan String. Kekosongan berarti hal yang sama. Itu, pada gilirannya, nantinya dapat memaksa programmer lain harus menangani NULL dan String.Empty, yang menjengkelkan.
Masalah yang lebih besar adalah bahwa basis data memungkinkan Anda untuk mendefinisikan bidang yang memetakan ke string C #, tetapi bidang basis data dapat didefinisikan sebagai BUKAN NULL. Jadi, tidak ada cara untuk secara akurat mewakili, katakanlah, bidang varchar (100) TIDAK NULL dalam SQL Server menggunakan tipe C #.
Bahasa lain, seperti Spec #, bolehkan ini.
Menurut pendapat saya, ketidakmampuan C # untuk mendefinisikan sebuah string yang tidak mengizinkan null sama buruknya dengan ketidakmampuan sebelumnya untuk mendefinisikan sebuah int yang memungkinkan null.
Untuk sepenuhnya menjawab pertanyaan Anda: Saya selalu menggunakan string kosong untuk inisialisasi default karena lebih mirip dengan cara kerja tipe data database. (Sunting: Pernyataan ini sangat tidak jelas. Seharusnya berbunyi "Saya menggunakan string kosong untuk inisialisasi default ketika NULL adalah keadaan berlebihan, dengan cara yang sama saya mengatur kolom database sebagai BUKAN NULL jika NULL akan menjadi keadaan berlebihan. Demikian pula , banyak kolom DB saya diatur sebagai TIDAK NULL, jadi ketika saya membawanya ke string C #, string akan kosong atau memiliki nilai, tetapi tidak akan pernah menjadi NULL. Dengan kata lain, saya hanya menginisialisasi string ke NULL jika null memiliki arti yang berbeda dari arti String.Empty, dan saya menemukan case tersebut kurang umum (tetapi orang-orang di sini telah memberikan contoh yang sah dari case ini). ")
sumber
Tergantung.
Apakah Anda perlu mengetahui apakah nilainya hilang (apakah mungkin untuk tidak didefinisikan)?
Apakah string kosong nilai yang valid untuk penggunaan string itu?
Jika Anda menjawab "ya" untuk keduanya, maka Anda ingin menggunakan null. Kalau tidak, Anda tidak dapat membedakan antara "tidak ada nilai" dan "string kosong".
Jika Anda tidak perlu tahu apakah tidak ada nilai maka string kosong mungkin lebih aman, karena memungkinkan Anda untuk melewatkan cek nol di mana pun Anda menggunakannya.
sumber
Sepertinya ini adalah kasus khusus dari http://en.wikipedia.org/wiki/Null_Object_pattern
sumber
Saya juga mengaturnya ke "" atau null - Saya selalu memeriksa dengan menggunakan String.IsNullOrEmpty, jadi tidak masalah.
Tetapi geek dalam diri saya mengatakan saya harus mengaturnya ke nol sebelum saya memiliki nilai yang tepat untuk itu ...
sumber
Saya selalu mendeklarasikan string dengan string.empty;
sumber
Apakah mungkin ini merupakan teknik penghindaran kesalahan (disarankan atau tidak ..)? Karena "" masih berupa string, Anda dapat memanggil fungsi string di atasnya yang akan menghasilkan pengecualian jika "NULL?
sumber
Saya selalu menginisialisasi mereka sebagai
NULL
.Saya selalu gunakan
string.IsNullOrEmpty(someString)
untuk memeriksa nilainya.Sederhana.
sumber
Itu tergantung situasi. Dalam kebanyakan kasus saya menggunakan String.Empty karena saya tidak ingin melakukan pemeriksaan nol setiap kali saya mencoba menggunakan string. Itu membuat kode jauh lebih sederhana dan Anda cenderung memperkenalkan NullReferenceException yang tidak diinginkan.
Saya hanya mengatur string ke null ketika saya perlu tahu apakah sudah diatur atau belum dan di mana string kosong adalah sesuatu yang valid untuk mengaturnya. Dalam praktiknya, saya menemukan situasi ini jarang terjadi.
sumber
String kosong adalah nilai (sepotong teks yang, kebetulan, tidak mengandung huruf apa pun). Null menandakan tidak ada nilai.
Saya menginisialisasi variabel menjadi nol ketika saya ingin menunjukkan bahwa mereka tidak menunjuk atau mengandung nilai aktual - ketika tujuannya adalah untuk tidak ada nilai.
sumber
Mengulangi respons Tomalak, perlu diingat bahwa ketika Anda menetapkan variabel string ke nilai awal nol, variabel Anda tidak lagi menjadi objek string; sama dengan objek apa pun di C #. Jadi, jika Anda mencoba mengakses metode atau properti apa pun untuk variabel Anda dan Anda menganggap itu adalah objek string, Anda akan mendapatkan pengecualian NullReferenceException.
sumber
Null hanya boleh digunakan dalam kasus-kasus di mana nilai opsional. Jika nilainya tidak opsional (seperti 'Nama' atau 'Alamat'), maka nilainya tidak boleh nol. Ini berlaku untuk database serta POCO dan antarmuka pengguna. Null berarti "nilai ini opsional, dan saat ini tidak ada."
Jika bidang Anda bukan opsional, maka Anda harus menginisialisasi sebagai string kosong. Untuk menginisialisasi sebagai null akan menempatkan objek Anda ke keadaan tidak valid (tidak valid oleh model data Anda sendiri).
Secara pribadi saya lebih suka string agar tidak dapat nullable secara default, tetapi hanya nullable jika kita mendeklarasikan "string?". Meskipun mungkin ini tidak layak atau logis pada tingkat yang lebih dalam; tidak yakin.
sumber
String bukan tipe nilai, dan tidak akan pernah ;-)
sumber
Saya pikir tidak ada alasan untuk tidak menggunakan null untuk nilai yang belum ditetapkan (atau di tempat ini dalam aliran program tidak terjadi). Jika Anda ingin membedakan, ada == null. Jika Anda hanya ingin memeriksa nilai tertentu dan tidak peduli apakah itu nol atau sesuatu yang berbeda, String.Equals ("XXX", MyStringVar) tidak apa-apa.
sumber