Panduan Komprehensif untuk Menaip Penghantaran dan Penukaran dalam Go

Go, juga dikenali sebagai Golang, ialah bahasa yang ditaip secara statik. Ini bermakna jenis setiap pembolehubah diketahui pada masa penyusunan, memberikan keselamatan dan kebolehramalan dalam kod anda. Walau bagaimanapun, ini juga memerlukan sebarang penukaran daripada satu jenis kepada jenis yang lain adalah jelas dan disengajakan. Dalam artikel ini, kami akan meneroka pelbagai jenis penghantaran dan mekanisme penukaran yang tersedia dalam Go, daripada penukaran angka asas kepada antara muka dan penukaran penuding yang lebih kompleks.

1. Penukaran Jenis Asas

Go membenarkan penukaran antara jenis asas seperti integer, nombor titik terapung dan rentetan, tetapi penukaran ini mesti dilakukan secara eksplisit.

Jenis Numerik

Penukaran antara jenis angka yang berbeza adalah mudah tetapi mesti jelas:

var i int = 42
var f float64 = float64(i)  // int to float64
var u uint = uint(i)        // int to uint

Dalam contoh ini, kami menukar int kepada float64 dan kepada uint. Penukaran ini adalah eksplisit kerana Go tidak melakukan penukaran jenis automatik (tersirat).

Rentetan dan Slice Byte

Rentetan Go tidak boleh diubah, tetapi ia boleh ditukar kepada dan daripada kepingan bait ([]bait), yang boleh berubah:

var s string = "hello"
var b []byte = []byte(s)   // string to []byte
var s2 string = string(b)  // []byte to string

Begitu juga, anda boleh menukar antara rentetan dan hirisan rune ([]rune), dengan rune ialah alias jenis untuk int32:

var r []rune = []rune(s)   // string to []rune
var s3 string = string(r)  // []rune to string

2. Penukaran Jenis Tersuai

Dalam Go, anda boleh menentukan jenis anda sendiri berdasarkan yang sedia ada. Penukaran antara jenis tersuai dan jenis asasnya adalah jelas:

type MyInt int
var i int = 10
var mi MyInt = MyInt(i)   // int to MyInt
var i2 int = int(mi)      // MyInt to int

Penukaran eksplisit ini diperlukan untuk memastikan pengkompil boleh mengesahkan keselamatan kod anda.

3. Penukaran Penunjuk

Penunjuk dalam Go merujuk alamat memori pembolehubah. Anda boleh menukar antara nilai dan penudingnya:

var x int = 42
var p *int = &x     // int to *int (pointer to int)
var y int = *p      // *int to int (dereferencing)

4. Penukaran Jenis Antara Muka

Antara muka dalam Go digunakan untuk menentukan set kaedah. Anda boleh menukar antara jenis konkrit dan antara muka:

var a interface{} = 42    // int to interface{}
var b int = a.(int)       // interface{} to int (type assertion)

Jenis Penegasan

Sesuatu penegasan jenis menyediakan akses kepada nilai konkrit antara muka:

if v, ok := a.(int); ok {
    fmt.Println("a is an int:", v)
}

Taip Suis

Suis jenis membolehkan anda melakukan tindakan berbeza berdasarkan jenis antara muka dinamik:

switch v := a.(type) {
case int:
    fmt.Println("a is an int:", v)
case string:
    fmt.Println("a is a string:", v)
default:
    fmt.Println("a is of unknown type")
}

5. Penukaran Tidak Selamat

Pakej tidak selamat membolehkan anda memintas keselamatan jenis Go, membolehkan penukaran yang sebaliknya menyalahi undang-undang:

import "unsafe"

var i int = 42
var p *int = &i
var fp *float64 = (*float64)(unsafe.Pointer(p))  // *int to *float64

Amaran: Penukaran yang tidak selamat hendaklah digunakan dengan berhati-hati dan hanya apabila benar-benar perlu, kerana ia boleh membawa kepada tingkah laku yang tidak ditentukan.

6. Penukaran Jenis Saluran

Saluran ialah ciri berkuasa dalam Go, membenarkan komunikasi antara gorouti. Anda boleh menukar antara saluran dwiarah dan satu arah:

ch := make(chan int)
var sendOnlyChan chan<- int = ch  // bidirectional to send-only
var recvOnlyChan <-chan int = ch  // bidirectional to receive-only

7. Penukaran Struktur dan Tatasusunan

Penukaran antara struct atau tatasusunan dengan reka letak yang sama memerlukan penghantaran yang jelas:

type Point struct {
    X, Y int
}

type Coord struct {
    X, Y int
}

var p Point = Point{1, 2}
var c Coord = Coord(p)  // Convert Point to Coord (same field types)

8. Penukaran Slice

Slices ialah rujukan kepada tatasusunan dan semasa anda boleh menukar antara kepingan jenis yang sama, menukar antara jenis kepingan yang berbeza memerlukan penukaran yang jelas:

var a []int = []int{1, 2, 3}
var b []int = a[1:]  // Convert a slice to another slice of the same type

9. Penukaran Antara Muka Tiada

Nilai sifar dalam Go boleh diberikan kepada mana-mana jenis antara muka:

var x interface{} = nil
var y error = nil

10. Penukaran Jenis Fungsi

Fungsi Go boleh ditukar kepada jenis yang berbeza, dengan syarat tandatangannya serasi:

type FuncType func(int) int

func square(x int) int {
    return x * x
}

var f FuncType = FuncType(square)  // Convert function to FuncType

11. Penukaran Array-to-Slice

Anda boleh mencipta kepingan daripada tatasusunan, yang pada asasnya merujuk kepada tatasusunan:

var arr [5]int = [5]int{1, 2, 3, 4, 5}
var sl []int = arr[:]  // Convert array to slice

Kesimpulan

Jenis penghantaran dan penukaran dalam Go adalah jelas mengikut reka bentuk, menjadikan kod lebih selamat dan lebih mudah difahami. Dengan memerlukan penukaran eksplisit, Go membantu menghalang pepijat halus yang boleh timbul daripada paksaan jenis tersirat, biasa dalam beberapa bahasa pengaturcaraan lain. Memahami penukaran ini dan menggunakannya dengan betul adalah penting untuk menulis program Go yang mantap dan cekap.

Atas ialah kandungan terperinci Panduan Komprehensif untuk Menaip Penghantaran dan Penukaran dalam Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!