Pemalar Go: Melangkaui Asas

Semasa saya mula-mula masuk ke Go, saya fikir pemalar adalah mudah dan terhad—hanya nilai tetap, tiada yang mewah. Tetapi apabila saya menyelidiki lebih mendalam, saya dapati ia agak serba boleh. Ya, ia adalah nilai tetap, tetapi Go mengendalikannya dengan cara yang fleksibel dan cekap. Ia cukup keren. Mari lihat maksudnya dengan beberapa contoh praktikal.

Kekal sebagai Nilai Bebas Jenis (Sehingga Ia Digunakan)

Dalam Go, pemalar selalunya dinyahtaip sehingga anda benar-benar menggunakannya. Mereka mempunyai jenis lalai tetapi boleh ditugaskan kepada pembolehubah jenis yang berbeza, selagi nilainya sesuai. Ini menjadikan mereka boleh menyesuaikan diri dengan cara yang luar biasa untuk bahasa yang ditaip secara statik.

Begini rupanya:

const x = 10
var i int = x
var f float64 = x
var b byte = x

Agak serupa dengan paradoks Schrödinger, x boleh menjadi int, float64 atau bahkan bait sehingga anda menetapkannya. Fleksibiliti sementara ini membolehkan x berfungsi dengan lancar dengan pelbagai jenis dalam kod anda. Tidak perlu casting, yang memastikan keadaan kemas.

Anda juga boleh mencampurkan pemalar pelbagai jenis dalam ungkapan dan Go akan mengetahui jenis terbaik untuk hasilnya:

const a = 1.5
const b = 2
const result = a * b // result is float64

Memandangkan a ialah nombor titik terapung, Go mempromosikan keseluruhan ungkapan kepada float64. Jadi anda tidak perlu risau tentang kehilangan ketepatan—Go mengendalikannya. Tetapi berhati-hati: jika anda cuba memberikan hasil kepada int, anda akan mendapat ralat. Go tidak membenarkan penukaran tersirat yang mungkin kehilangan data.

Penghadan

Fleksibiliti ini hanya berlaku jauh. Sebaik sahaja anda menetapkan pemalar kepada pembolehubah, jenis pembolehubah itu ditetapkan:

const y = 10
var z int = y       // z is an int
var k float64 = y   // y can still be used as float64

Tetapi jika anda mencuba ini:

const y = 10.5
var m int = y       // Error: constant 10.5 truncated to integer

Go akan membuang ralat kerana ia tidak akan menukar pemalar titik terapung secara automatik kepada integer tanpa hantaran eksplisit. Jadi, walaupun pemalar adalah fleksibel, ia tidak akan menukar jenis agar sesuai dengan pembolehubah yang tidak serasi.

Memahami Lalai Jenis

Apabila anda menggunakan pemalar yang tidak ditaip tanpa menyatakan jenis, mereka menganggap jenis lalai:

• Pemalar Integer Tidak Ditaip lalai kepada int.

• Pemalar Titik Terapung Tidak Ditaip lalai kepada float64.

• Pemalar Rune Tidak Ditaip lalai kepada rune (iaitu int32).

• Pemalar Kompleks Tidak Ditaip lalai kepada complex128.

• Pemalar Rentetan Tidak Ditaip lalai kepada rentetan.

• Pemalar Boolean Tidak Ditaip lalai kepada bool.

Berikut ialah jadual ringkas:

Penilaian dan Prestasi Masa Kompilasi

Go bukan sahaja menilai pemalar pada masa penyusunan—ia juga mengoptimumkan ungkapan malar. Ini bermakna anda boleh menggunakan pemalar dalam pengiraan, dan Go akan mengira hasilnya semasa penyusunan:

const x = 10
var i int = x
var f float64 = x
var b byte = x

Jadi c tidak dikira semula pada masa jalan; Go telah mengetahui bahawa ia adalah 520 pada masa penyusunan. Ini boleh meningkatkan prestasi, terutamanya dalam kod di mana kelajuan penting. Dengan menggunakan pemalar, Go mengendalikan pengiraan sekali, bukannya melakukannya setiap kali program anda dijalankan.

Malar dalam Kompilasi Bersyarat

Go tidak mempunyai prapemproses seperti beberapa bahasa lain, tetapi anda boleh menggunakan pemalar dalam pernyataan if untuk memasukkan atau mengecualikan kod pada masa penyusunan.

const a = 1.5
const b = 2
const result = a * b // result is float64

Apabila nyahpepijat palsu, pengkompil mengetahui keadaan jika tidak akan menjadi benar dan mungkin meninggalkan kod di dalam blok. Ini boleh menjadikan binari akhir anda lebih kecil. Sangat berguna, bukan?

Bekerja dengan Nombor Besar

Satu ciri hebat pemalar Go ialah ia menyokong bilangan yang sangat besar. Pemalar berangka yang tidak ditaip dalam Go mempunyai ketepatan "tak terhingga", terhad hanya oleh memori dan pengkompil.

const y = 10
var z int = y       // z is an int
var k float64 = y   // y can still be used as float64

Walaupun bigNum jauh lebih besar daripada mana-mana jenis angka terbina dalam seperti float64 atau int, Go membolehkan anda mentakrifkannya sebagai pemalar. Anda boleh melakukan pengiraan dengan nombor besar ini pada masa penyusunan:

const y = 10.5
var m int = y       // Error: constant 10.5 truncated to integer

Pemalar ditaip dengan iota

Jika anda telah menggunakan Go, anda mungkin pernah melihat sedikit pun untuk mencipta pemalar terhitung. Ia berguna kerana ia memberikan nilai tambahan secara automatik.

Anda juga boleh menggunakan ungkapan dalam pengisytiharan berterusan dengan iota untuk mencipta pemalar yang berkaitan.

const a = 100
const b = 5
const c = a * b + 20 // c is computed at compile time

Kod ini mentakrifkan pemalar untuk kilobait, megabait, gigabait dan terabait menggunakan peralihan bit. Ia dikira pada masa penyusunan. Ia adalah cara yang kemas untuk menjana satu siri pemalar yang berkaitan.

Saya dapati iota sangat membantu untuk perkara sebegini. Memandangkan Go tidak mempunyai jenis enum terbina dalam, anda boleh mensimulasikan enum dengan berkesan menggunakan pengecam iota dan jenis tersuai.

Malar dengan Operasi dan Anjakan Bitwise

Pemalar boleh menggunakan operasi dan anjakan bitwise, malah menghasilkan nilai yang lebih besar daripada mana-mana jenis terbina dalam.

const debug = false

func main() {
    if debug {
        fmt.Println("Debugging enabled")
    }
    // The above block might be removed by the compiler if debug is false
}

Di sini, shiftedValue menjadi angka yang sangat besar kerana jumlah peralihan yang besar. Nilai ini terlalu besar untuk jenis integer standard tetapi sah sebagai pemalar sehingga anda cuba menetapkannya:

const bigNum = 1e1000 // This is a valid constant

Ini menunjukkan bahawa pemalar boleh mewakili nilai yang anda tidak boleh simpan dalam pembolehubah, membenarkan pengiraan masa penyusunan dengan nombor yang sangat besar.

Penghadan dengan Pemalar

Walaupun pemalar Go adalah fleksibel, terdapat beberapa perkara yang mereka tidak boleh lakukan.

Pemalar Tidak Boleh Dirujuk oleh Penunjuk

Pemalar tidak mempunyai alamat memori semasa masa jalan. Jadi anda tidak boleh mengambil alamat pemalar atau menggunakan penuding kepadanya.

const x = 10
var i int = x
var f float64 = x
var b byte = x

Malar dengan Ditaip Penunjuk tiada

Walaupun nol boleh ditugaskan kepada pembolehubah penuding, hirisan, peta, saluran dan jenis fungsi, anda tidak boleh membuat pemalar yang memegang penuding nol ditaip.

const a = 1.5
const b = 2
const result = a * b // result is float64

Ini menambah kepada sifat tidak berubah dan masa penyusunan pemalar dalam Go.

Panggilan Fungsi dalam Perisytiharan Malar

Hanya fungsi terbina dalam tertentu boleh digunakan dalam ungkapan malar, seperti len, cap, real, imag dan kompleks.

const y = 10
var z int = y       // z is an int
var k float64 = y   // y can still be used as float64

Ini kerana, fungsi terbina dalam tersebut boleh digunakan

Jenis Komposit dan Pemalar

Pemalar tidak boleh mewakili secara langsung jenis komposit seperti kepingan, peta atau struktur. Tetapi anda boleh menggunakan pemalar untuk memulakannya.

const y = 10.5
var m int = y       // Error: constant 10.5 truncated to integer

Kod di atas tidak berfungsi kerana anda tidak boleh mengisytiharkan kepingan sebagai pemalar. Walau bagaimanapun, anda boleh menggunakan pemalar di dalam kepingan boleh ubah:

const a = 100
const b = 5
const c = a * b + 20 // c is computed at compile time

Hanya ingat, jenis seperti kepingan itu sendiri bukanlah pemalar—anda tidak boleh mengisytiharkannya sebagai satu. Unsur-unsur di dalamnya boleh menjadi pemalar.

Penukaran Eksplisit Apabila Diperlukan

Jika pemalar yang tidak ditaip tidak boleh ditetapkan secara langsung disebabkan jenis tidak padan atau kemungkinan kehilangan ketepatan, anda perlu menggunakan penukaran jenis eksplisit.

const debug = false

func main() {
    if debug {
        fmt.Println("Debugging enabled")
    }
    // The above block might be removed by the compiler if debug is false
}

Membungkus

Saya harap ini memberi anda idea yang lebih baik tentang constans. Ia bukan sahaja nilai tetap yang mudah; tetapi juga ciri fleksibel yang boleh menjadikan kod anda lebih ekspresif dan cekap.

Saya masih baru untuk berkongsi pengalaman saya dalam Go & saya tidak sabar-sabar untuk belajar dan menambah baik. Jika anda mendapati siaran ini berharga atau mempunyai cadangan tentang cara saya boleh menjadikannya lebih baik, sila siarkan dalam ulasan.

Siaran Reddit pertama saya pada 'Sokongan UTF-8 Go: Satu Had Menarik' (tidak memerlukan log masuk) yang mencetuskan perhatian yang cukup.

Mengharap maklum balas anda.

Atas ialah kandungan terperinci Pemalar Go: Melangkaui Asas. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!