penukaran jenis golang ok

Bahasa Go (Golang) ialah bahasa pengaturcaraan sumber terbuka yang dipengaruhi oleh bahasa seperti C, Java dan Python Ia dibangunkan oleh Google dan digunakan untuk mencipta perisian yang cekap dan boleh dipercayai. Sesuatu program berkait rapat dengan bahasa di mana ia ditulis Seperti bahasa yang mengekspresikan emosi dan pemikiran, bahasa pengaturcaraan juga mempunyai ciri-ciri tersendiri. Penukaran jenis ialah konsep yang sangat penting dalam bahasa Go, kerana penukaran jenis digunakan dalam banyak situasi Artikel ini akan memperkenalkan pengetahuan yang berkaitan tentang penukaran jenis Golang.

1. Gambaran keseluruhan penukaran jenis

Penukaran jenis ialah proses menukar nilai satu jenis data kepada nilai jenis data yang lain. Dalam bahasa Go, jenis data dibahagikan kepada jenis data asas dan jenis komposit. Jenis data asas termasuk int, float, string, bool dan jenis lain. Jenis komposit termasuk tatasusunan, kepingan, kamus, struktur, antara muka dan fungsi. Dalam bahasa Go, nilai antara jenis yang berbeza tidak boleh dikendalikan dan dibandingkan secara langsung. Oleh itu, adalah perlu untuk menaip-menukar nilai antara jenis yang berbeza. Golang menyokong penukaran integer yang ditandatangani, integer tidak ditandatangani, nombor titik terapung, Boolean, rentetan dan jenis lain Sintaks penukaran jenis ialah: T(x), dengan T mewakili jenis yang akan ditukar dan x mewakili nilai yang akan ditukar. .

2. Penukaran jenis data asas

1 Penukaran jenis integer

Dalam bahasa Go, jenis integer termasuk integer yang ditandatangani dan integer yang tidak ditandatangani ialah int8 , int16, int32, int64, uint8, uint16, uint32 dan uint64. Antaranya, int8 dan uint8 dipanggil jenis bait, int16 dan uint16 dipanggil jenis integer pendek, int32 dan uint32 dipanggil jenis integer panjang, dan int64 dan uint64 dipanggil jenis integer panjang.

Anda perlu memberi perhatian kepada dua perkara berikut semasa menukar jenis integer:

• Jika julat nilai melebihi julat nilai jenis yang hendak ditukar semasa penukaran, ia akan melimpah, mengakibatkan dalam keputusan yang tidak tepat. Contohnya, menukar nilai yang lebih besar daripada julat int8 kepada jenis int8 akan menghasilkan nilai yang tidak tepat dalam julat [-128, 127]. Masalah limpahan dengan jenis integer perlu dielakkan.
• Hanya penukaran daripada jenis yang sama atau daripada jenis ketepatan rendah kepada jenis ketepatan tinggi adalah selamat. Sebagai contoh, menukar daripada int8 kepada int16 adalah selamat, tetapi menukar daripada int16 kepada int8 adalah tidak selamat kerana sesetengah data mungkin dipintas apabila menukar kepada int8, mengakibatkan keputusan yang tidak tepat.

Berikut ialah beberapa contoh penukaran jenis integer:

package main

import "fmt"

func main() {
    var a int32 = 100
    var b int64 = int64(a)   // int32转换成int64
    var c int8 = int8(a)     // int32转换成int8，可能溢出
    var d uint16 = uint16(a) // int32转换成uint16
    fmt.Println(b, c, d)
}

Hasil output ialah:

100 100 100

2. Penukaran jenis titik terapung

dalam Go Dalam bahasa, jenis nombor terapung termasuk float32 dan float64, dan satu-satunya jenis nombor titik terapung yang menyokong penukaran ialah float32 dan float64. Terdapat dua perkara yang perlu diberi perhatian apabila menukar jenis nombor titik terapung:

• Jika julat nilai terlalu besar atau terlalu kecil semasa penukaran, limpahan mungkin berlaku.
• hanya boleh ditukar daripada jenis ketepatan rendah kepada jenis ketepatan tinggi Penukaran daripada jenis ketepatan tinggi kepada jenis ketepatan rendah boleh mengakibatkan kehilangan ketepatan.

Berikut ialah contoh penukaran jenis titik terapung:

package main

import "fmt"

func main() {
    var a float32 = 3.1415926
    var b float64 = float64(a) // float32转换成float64
    fmt.Println(b)
}

Hasil output ialah:

3.1415927410125732

3 dalam Go Dalam bahasa, jenis Boolean hanya mempunyai dua nilai: benar dan salah, dan satu-satunya jenis yang menyokong penukaran ialah jenis int dan rentetan. Apabila menukar nilai Boolean kepada int, benar ditukar kepada 1 dan palsu ditukar kepada 0. Apabila menukar nilai Boolean kepada rentetan, benar ditukar kepada "benar" dan palsu ditukar kepada "salah".

Berikut ialah contoh penukaran jenis Boolean:

package main

import "fmt"

func main() {
    var a bool = true
    var b int = int(a)     // true转换成int，值为1
    var c string = string(a) // true转换成字符串，值为"true"
    fmt.Println(b, c)
}

Hasil output ialah:

1 true

4 Penukaran jenis rentetan

Dalam bahasa Go, Rentetan ialah tatasusunan (tidak berubah) yang terdiri daripada jujukan aksara dan satu-satunya jenis yang menyokong penukaran ialah jenis primitif. Penukaran rentetan boleh dicapai melalui pakej strconv. Apabila menukar integer kepada rentetan, anda boleh menggunakan fungsi strconv.Itoa() dan apabila menukar nombor titik terapung kepada rentetan, anda boleh menggunakan fungsi strconv.FormatFloat().

Berikut ialah contoh penukaran jenis rentetan:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var a int = 100
    var b string = strconv.Itoa(a) // 将整数转换成字符串
    var c float64 = 3.1415926
    var d string = strconv.FormatFloat(c, 'f', 6, 64) // 将浮点数转换成字符串，保留6位小数
    fmt.Println(b, d)
}

Hasil output ialah:

100 3.141593

3. Penukaran jenis komposit

1 penukaran

Dalam bahasa Go, tatasusunan ialah urutan panjang tetap yang terdiri daripada unsur-unsur jenis yang sama. Nilai boleh diberikan secara langsung antara tatasusunan, tetapi perlu diperhatikan bahawa saiz dan jenis tatasusunan mestilah sama, jika tidak ralat penyusunan akan berlaku.

Berikut ialah contoh penukaran jenis tatasusunan:

package main

import "fmt"

func main() {
    var a [3]int = [3]int{1, 2, 3}
    var b [3]int = a // 数组之间可以直接赋值
    fmt.Println(b)
}

Hasil output ialah:

[1 2 3]

2. Penukaran jenis kepingan

Dalam bahasa Go, slice Ia adalah struktur yang mengandungi penunjuk kepada tatasusunan, panjang dan kapasiti kepingan, dan merupakan jujukan panjang berubah-ubah. Nilai boleh diberikan secara langsung di antara kepingan, tetapi perlu diperhatikan bahawa jenis elemen kepingan mestilah sama.

Berikut ialah contoh penukaran jenis kepingan:

package main

import "fmt"

func main() {
    a := []int{1, 2, 3, 4}
    b := a // 切片之间可以直接赋值
    fmt.Println(b)
}

Hasil output ialah:

[1 2 3 4]

3 penukaran jenis kamus

Dalam bahasa Go, kamus Merupakan koleksi pasangan kunci-nilai. Nilai boleh diberikan secara langsung antara kamus, tetapi perlu diperhatikan bahawa jenis kunci dan nilai kamus mestilah sama.

Berikut ialah contoh penukaran jenis kamus:

package main

import "fmt"

func main() {
    a := map[string]int{"apple": 1, "banana": 2}
    b := a // 字典之间可以直接赋值
    fmt.Println(b)
}

Hasil output ialah:

map[apple:1 banana:2]

4. Ringkasan

Dalam bahasa Go, penukaran jenis ialah konsep yang sangat penting. Penukaran jenis boleh menukar nilai antara jenis yang berbeza untuk memenuhi keperluan program. Walau bagaimanapun, perlu diingatkan bahawa apabila melakukan penukaran jenis, adalah perlu untuk mengelakkan limpahan julat jenis data dan masalah kehilangan ketepatan, dan pada masa yang sama, adalah perlu untuk memastikan bahawa jenis yang ditukar adalah serasi dengan jenis sebelum penukaran. Penukaran jenis digunakan antara jenis data asas dan jenis data komposit Menguasai pengetahuan berkaitan penukaran jenis adalah sangat penting untuk pengaturcaraan Golang.

Atas ialah kandungan terperinci penukaran jenis golang ok. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!