Jenis Opaque
Abstraksi tanpa kos tambahan
Jenis Opaque ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.
Apakah Jenis Legap?
Jenis legap ialah ciri Scala 3 untuk mencipta abstraksi tanpa kos. Jenis ini memberikan jenis berbeza pada masa kompilasi, tetapi dikompilkan menjadi jenis asas tanpa pembungkusan masa jalan.
- Keselamatan jenis seperti kelas pembungkus.
- Tiada overhed peruntukan memori.
object Distances:
opaque type Meters = Double
object Main:
def main(args: Array[String]): Unit =
println("Opaque types compile to their underlying type")Mengisytiharkan Jenis Legap
Isytiharkan jenis legap di dalam objek atau kelas. Di luar skop itu, Meters dan Double dianggap sebagai jenis yang berbeza.
object Distances:
opaque type Meters = Double
def meters(d: Double): Meters = d
def toDouble(m: Meters): Double = m
object Main:
def main(args: Array[String]): Unit =
val d = Distances.meters(5.0)
println(Distances.toDouble(d))Sempadan Kelegapan
Di dalam skop takrifan, jenis legap dan jenis asasnya boleh saling ditukar. Di luar, hanya jenis legap yang kelihatan, jadi Anda tidak boleh tersilap menghantar Double mentah apabila Meters diperlukan.
object Distances:
opaque type Meters = Double
def apply(d: Double): Meters = d
def show(m: Meters): String = s"$m m"
object Main:
def main(args: Array[String]): Unit =
val m = Distances(10.0)
println(Distances.show(m))Menambah Kaedah Sambungan
Berikan tingkah laku kepada jenis legap dengan kaedah sambungan yang ditakrifkan dalam skop yang sama. Pemanggil mendapat operasi yang mudah tanpa mendedahkan jenis asas.
object Distances:
opaque type Meters = Double
def apply(d: Double): Meters = d
extension (m: Meters)
def +(other: Meters): Meters = m + other
def value: Double = m
object Main:
def main(args: Array[String]): Unit =
val total = Distances(3.0) + Distances(4.0)
println(total.value)Mencegah Kekeliruan Jenis
Kelebihan utamanya: dua jenis legap yang berasaskan jenis asas sama adalah tidak serasi. Meters tidak boleh dikelirukan dengan Kilometers walaupun kedua-duanya ialah Double.
object Units:
opaque type Meters = Double
opaque type Kilometers = Double
def m(d: Double): Meters = d
def km(d: Double): Kilometers = d
def toMeters(k: Kilometers): Meters = k * 1000
object Main:
def main(args: Array[String]): Unit =
val far = Units.km(2.0)
println(Units.toMeters(far))Jenis Legap dengan Had
Anda boleh memberikan jenis legap suatu had atas dengan <:. Ini mendedahkan sebahagian API awam sambil merahsiakan perwakilan tepatnya.
object Ids:
opaque type UserId <: Int = Int
def apply(i: Int): UserId = i
object Main:
def main(args: Array[String]): Unit =
val id = Ids(99)
println(id + 1)Pembinaan Pintar dengan Pengesahan
Gabungkan jenis legap dengan kilang yang melakukan pengesahan untuk memastikan nilai sentiasa sah. Pembina kekal peribadi; hanya kilang yang disahkan tersedia kepada umum.
object Ages:
opaque type Age = Int
def of(i: Int): Option[Age] =
if i >= 0 && i < 150 then Some(i) else None
extension (a: Age) def value: Int = a
object Main:
def main(args: Array[String]): Unit =
println(Ages.of(30).map(_.value))
println(Ages.of(-1))Kos Masa Jalan Sifar
Berbeza daripada pembalut kelas nilai atau kelas kes, jenis legap tidak mencipta objek semasa masa jalan. List Meters secara harfiahnya ialah senarai double dalam JVM, jadi tiada pembungkusan objek.
object Temps:
opaque type Celsius = Double
def c(d: Double): Celsius = d
extension (t: Celsius) def value: Double = t
object Main:
def main(args: Array[String]): Unit =
val readings = List(Temps.c(20.0), Temps.c(21.5))
println(readings.map(_.value).sum)Jenis Legap berbanding Alias Jenis
Alias type X = Y biasa adalah telus: X dan Y boleh saling menggantikan sepenuhnya di mana-mana. Jenis legap menyembunyikan kesamaan itu di luar skopnya, lalu memberikan keselamatan jenis sebenar.
object Demo:
type Name = String // transparent alias
opaque type Email = String // opaque
def email(s: String): Email = s
extension (e: Email) def raw: String = e
object Main:
def main(args: Array[String]): Unit =
val e = Demo.email("a@b.com")
println(e.raw)Jenis Legap berbanding Pembalut Kelas Kes
Pembalut kelas kes seperti case class Meters(value: Double) juga menambah keselamatan jenis, tetapi memperuntukkan sebuah objek. Jenis legap memberikan keselamatan yang sama dengan prestasi jenis mentah.
object Money:
opaque type Cents = Long
def cents(n: Long): Cents = n
extension (c: Cents)
def +(o: Cents): Cents = c + o
def value: Long = c
object Main:
def main(args: Array[String]): Unit =
val total = Money.cents(150) + Money.cents(50)
println(total.value)Bila Hendak Menggunakan Jenis Legap
Gunakan jenis legap apabila anda mahukan penaipan domain yang kukuh dalam laluan kritikal atau koleksi besar.
- Bezakan kuantiti (Meters berbanding Seconds).
- Paksa invarian yang telah disahkan.
- Elakkan overhed peruntukan pembalut.
object Geo:
opaque type Latitude = Double
def lat(d: Double): Option[Latitude] =
if d >= -90 && d <= 90 then Some(d) else None
extension (l: Latitude) def value: Double = l
object Main:
def main(args: Array[String]): Unit =
println(Geo.lat(41.0).map(_.value))Semakan Ringkas
Uji pemahaman anda tentang jenis legap.
Rumusan
Anda telah mempelajari jenis legap Scala 3.
opaque type X = Ymenyembunyikan kesamaan di luar skopnya.- Sediakan kilang dan kaedah
extensionuntuk API. - Jenis legap yang berbeza berasaskan asas yang sama tidak serasi.
- Had atas pilihan dengan
<:mendedahkan API separa. - Tiada kos masa jalan, tidak seperti pembalut kelas kes.
object Ids:
opaque type OrderId = String
def apply(s: String): OrderId = s
extension (o: OrderId) def raw: String = o
object Main:
def main(args: Array[String]): Unit =
val id = Ids("ORD-1")
println(id.raw)
Pelajari Scala dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 39
- Pelajaran
- 143
Soalan Lazim
Adakah pelajaran “Jenis Opaque” percuma?
Ya — teks penuh “Jenis Opaque” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Jenis Opaque”?
Abstraksi tanpa kos tambahan Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.
Berapa lamakah pelajaran “Jenis Opaque” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?
Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.