Inisialisasi string default: NULL atau Empty? [Tutup]

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

1. Menghindari penanganan kesalahan Jika nilainya tidak boleh nol, mengapa harus diatur ke NULLtempat pertama? Mungkin akan lebih baik untuk mengidentifikasi kesalahan di tempat itu terjadi daripada menutupinya melalui seluruh basis kode Anda?

2. 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 NULLaman? Apa yang terjadi jika Anda terus-menerus menggunakan String.Emptydan null terjadi untuk masuk ke sistem Anda, apakah Anda mulai menambahkan NULLcek?

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 nulldalam database-nya. Saya pikir prinsip-prinsip yang sama berlaku dalam pemrograman dan harus ada seseorang untuk menampar mereka yang terbalik yang menggunakan String.Emptydaripada NULLtidak mewakili nilai.

Pertanyaan-pertanyaan Terkait

• Di C #, apakah saya harus menggunakan string.Empty atau String.Empty atau ""?
• Apa perbedaan antara String.Empty dan ""
• String kosong atau kosong untuk mewakili tidak ada data di kolom tabel?

+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.

Menurut MSDN :

Dengan menginisialisasi string dengan Emptynilai alih-alih null, Anda dapat mengurangi peluang NullReferenceExceptionterjadinya.

Namun selalu menggunakan IsNullOrEmpty()adalah praktik yang baik.

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:

string name = null; // or String.Empty
if (condition)
{
  name = "foo";
}
else
{
  name = "bar";
}

return name;

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:

string name = null; // or String.Empty
if (condition)
{
  name = "foo";
}
else if (othercondition)
{
  name = "bar";
}

return name; //returns null when condition and othercondition are false

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

Untuk 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:

if (s == "value")

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 digunakan String.Compare? Haruskah saya membuat Enumdan menguraikannya?

Dari perspektif ini, seseorang dapat sampai pada filosofi kode yang cukup sederhana: Anda menghindari memeriksa konten string sedapat mungkin. Membandingkan string dengan String.Emptybenar-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:

string msg = Validate(item);
if (msg != null)
{
   DisplayErrorMessage(msg);
   return;
}

Saya tahu itu Validatetidak akan pernah kembali String.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.Emptydan kapan seharusnya artinya null.

(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.)

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). ")

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.

Sepertinya ini adalah kasus khusus dari http://en.wikipedia.org/wiki/Null_Object_pattern

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 ...

Saya selalu mendeklarasikan string dengan string.empty;

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?

Saya selalu menginisialisasi mereka sebagai NULL.

Saya selalu gunakan string.IsNullOrEmpty(someString)untuk memeriksa nilainya.

Sederhana.

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.

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.

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.

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.

String bukan tipe nilai, dan tidak akan pernah ;-)

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.