Apakah Anda menggunakan, StringUtils.EMPTY
bukan ""
?
Maksud saya baik sebagai nilai kembali atau jika Anda menetapkan nilai variabel String. Saya tidak bermaksud untuk perbandingan, karena di sana kami menggunakanStringUtils.isEmpty()
Jawaban:
Tentu saja tidak. Apakah menurut Anda "" tidak cukup jelas?
Konstanta pada dasarnya memiliki 3 kasus penggunaan:
Tidak ada yang berlaku di sini.
EMPTY
tersebut tidak memiliki arti yang belum dimiliki oleh string kosong itu sendiri. Terutama, itu tidak mendokumentasikan mengapa Anda memutuskan untuk menggunakan string kosong pada kasus tertentu itu. Ini tidak berbeda dengan menamai konstanta ONE
dan berpura-pura ada gunanya menggunakan konstanta itu alih-alih nilainya.
Saya menggunakan StringUtils.EMPTY
, untuk menyembunyikan literal dan juga untuk mengekspresikan yang return StringUtils.EMPTY
sepenuhnya diharapkan dan harus mengembalikan string kosong, ""
dapat mengarah pada asumsi yang ""
dapat dengan mudah diubah menjadi sesuatu yang lain dan ini mungkin hanya kesalahan. Saya pikir EMPTY
lebih ekspresif.
StringUtils.EMPTY
kurang ekspresif daripada ""
.
""
lebih ekspresif daripada menggunakan StringUtils.EMPTY
, dan apa yang Anda katakan tidak mengubah pikiran saya tentang itu. Saya hanya bisa percaya bahwa pengembang telah salah menulis literal string kosong sangat, sangat sesekali - tapi saya akan mengambil kejelasan literal string dari sekali dalam sejuta (dan mudah ditemukan dalam pengujian, mudah-mudahan ... ) bug, secara pribadi.
Tidak, gunakan saja ""
.
Secara literal ""
jelas seperti kristal. Tidak ada kesalahpahaman tentang apa yang dimaksud. Saya tidak tahu mengapa Anda membutuhkan konstanta kelas untuk itu. Saya hanya dapat berasumsi bahwa konstanta ini digunakan di seluruh paket yang berisi, StringUtils
bukan ""
. Itu tidak berarti Anda harus menggunakannya.
Jika ada batu di trotoar, Anda tidak perlu membuangnya.
Saya kagum pada berapa banyak orang yang dengan senang hati berasumsi bahwa "" memang sebuah string kosong, dan tidak (secara tidak sengaja?) Mengandung karakter Unicode yang tidak terlihat dan tidak memiliki spasi. Untuk cinta semua yang baik dan layak, gunakan KOSONG kapan pun Anda bisa.
Saya akan menambahkan dua sen saya di sini karena saya tidak melihat siapa pun berbicara tentang String
magang dan inisialisasi kelas:
String
literal di sumber Java diinternir, dibuat setiap ""
dan StringUtils.EMPTY
yang sama objekStringUtils.EMPTY
can inisialisasi StringUtils
kelas, karena ia mengakses anggota statisnya EMPTY
hanya jika tidak dideklarasikanfinal
(JLS khusus untuk hal itu). Namun, bersifat final, jadi tidak akan menginisialisasi kelas.org.apache.commons.lang3.StringUtils.EMPTY
Lihat jawaban terkait pada String interning dan inisialisasi Kelas , mengacu pada JLS 12.4.1 .
StringUtils
kelas.
Saya tidak terlalu suka menggunakannya, karena return "";
lebih pendek dari return StringUtils.EMPTY
.
Namun, satu keuntungan palsu menggunakannya adalah jika Anda mengetik return " ";
alih-alih return "";
, Anda mungkin mengalami perilaku yang berbeda (terkait apakah Anda menguji dengan benar String kosong atau tidak).
""
, saya tidak suka mengetik string literal yang sama lebih dari satu kali, bahkan terkadang hanya sekali. Saya lebih suka mendeklarasikan konstanta di Constants.java , tetapi tidak mengulanginya di semua tempat dalam kode sumber.
return "";
jelek, SAYA LEBIH HARUS menggunakan return StringUtil.EMPTY
(dideklarasikan di kelas saya sendiri StringUtil , BUKAN StringUtils Apache ).
Jika kelas Anda tidak menggunakan hal lain dari commons maka akan sangat disayangkan memiliki ketergantungan ini hanya untuk nilai ajaib ini.
Perancang StringUtils memanfaatkan banyak konstanta ini, dan ini adalah hal yang benar untuk dilakukan, tetapi itu tidak berarti Anda harus menggunakannya juga.
Sejujurnya, saya juga tidak melihat banyak gunanya. Jika Anda ingin membandingkan misalnya string kosong, gunakan sajaStringUtils.isNotEmpty(..)
StringUtils.isNotEmpty(..)
juga melakukan pemeriksaan null sehingga tidak persis sama dengan membandingkan dengan string kosong.
null
? sebagai argumen ke-2 equals
, tetapi hasilnya akan sama -false
isNotEmpty
adalah kebalikan dari "".equals(…)
, oleh karena itu, fakta bahwa itu akan memperlakukan null
seperti string kosong adalah berbeda untuk membandingkan dengan string kosong, "".equals("")
→ true
, "".equals(null)
→ false
, StringUtils.isNotEmpty("")
→ false
, StringUtils.isNotEmpty(null)
→ false
. Jika Anda hanya ingin tahu apakah suatu string kosong, gunakan string.isEmpty()
, yang memiliki perilaku yang benar dengan mengembalikan true
iff itu adalah string kosong dan melempar NullPointerException
jika string itu adalah null
…
Saya menemukan StringUtils.EMPTY
berguna dalam beberapa kasus untuk keterbacaan. Khususnya dengan:
Operator terner misalnya.
item.getId() != null ? item.getId() : StringUtils.EMPTY;
Juga dengan menggunakan konstanta, referensi ke StringUtils.EMPTY
dibuat. Sebaliknya jika Anda mencoba untuk membuat instance String literal ""
setiap kali JVM harus memeriksa apakah sudah ada di kumpulan String (yang kemungkinan besar akan terjadi, jadi tidak ada overhead pembuatan instance tambahan). Tentunya menggunakan StringUtils.EMPTY
menghindari kebutuhan untuk memeriksa kolam String?
StringUtils.EMPTY
konstanta diselesaikan pada waktu kompilasi.
StringUtil.EMPTY
adalah konstanta waktu kompilasi, referensi padanya akan dikompilasi ke bytecode yang sama persis seperti yang digunakan ""
secara langsung. Lebih jauh, saya tidak mengerti mengapa operator terner harus membuat perbedaan. Itu adalah ekspresi seperti yang lainnya. Alasan apa pun untuk menggunakan atau tidak menggunakan konstanta bernama juga berlaku untuk operator terner.
Tidak, karena saya memiliki lebih banyak untuk ditulis. Dan String kosong adalah plattform independent empty (di Java).
File.separator
lebih baik dari "/" atau "\".
Tapi lakukan sesukamu. Anda tidak bisa salah ketikreturn " ";
someString.isEmpty()
sebagai gantinya.
Ya, itu masuk akal. Ini mungkin bukan satu-satunya cara untuk pergi tetapi saya tidak melihat banyak cara untuk mengatakan ini "tidak masuk akal".
Menurutku:
It will still require changing everywhere if you don't define your own variable and use it in multiple places.
Anda akan mengubah string kosong menjadi string kosong lain?
StringUtils.EMPTY
. Itu memperjelas bahwa penggunaan String kosong dimaksudkan, dan bukan semacam kemalasan ("Oh, ini membutuhkan String, ayo teruskan""
"). Jika seseorang menemukan kode ini, dia akan berpikir dua kali sebelum membuat perubahan. Juga, jikaStringUtils.EMPTY
didefinisikan sebagai variabel Anda sendiri, sepertiMyClass.EMPTY
, membuat perubahan pada "representasi kekosongan itu" akan membutuhkan perubahan satu baris kode. Anda dapat, misalnya, mengubahnya menjadi"<empty>"
String kosong""
. Tapi, saya pikir ini sudah keterlaluan.