Apakah jenis data yang terdapat dalam bahasa go?

Jenis data bahasa Go ialah: 1. Jenis Boolean, nilainya hanya boleh menjadi benar atau palsu 2. Jenis angka, menyokong integer dan nombor titik terapung, dan menyokong nombor kompleks 3. Jenis rentetan , ialah urutan aksara yang disambungkan dengan rentetan aksara panjang tetap 5. Jenis susunan 7. Jenis saluran; jenis; 11. Jenis peta.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Jenis Data Bahasa Go

Dalam bahasa pengaturcaraan Go, jenis data digunakan untuk mengisytiharkan fungsi dan pembolehubah.

Kemunculan jenis data adalah untuk membahagikan data kepada data dengan saiz memori yang berbeza yang diperlukan Semasa pengaturcaraan, anda perlu memohon memori besar apabila anda perlu menggunakan data besar, supaya anda boleh menggunakan sepenuhnya ingatan.

Bahasa Go mempunyai jenis data berikut mengikut kategori:

Nombor siri

Jenis dan perihalan

1

序号	类型和描述
1	布尔型 布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true。
2	数字类型 整型 int 和浮点型 float32、float64，Go 语言支持整型和浮点型数字，并且支持复数，其中位的运算采用补码。
3	字符串类型: 字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
4	派生类型: 包括： (a) 指针类型（Pointer） (b) 数组类型 (c) 结构化类型(struct) (d) Channel 类型 (e) 函数类型 (f) 切片类型 (g) 接口类型（interface） (h) Map 类型

Boolean

Boolean The nilai jenis hanya boleh menjadi malar benar atau salah. Contoh mudah: var b bool = benar.

2

Jenis nombor

Jenis integer dan jenis titik terapung float32, float64, bahasa Go menyokong jenis integer dan Nombor titik terapung dan nombor kompleks disokong, dan operasi bit menggunakan kod pelengkap.

3

Jenis rentetan:

Rentetan ialah jujukan aksara yang disambungkan dengan panjang aksara yang tetap. Rentetan Go disatukan daripada bait tunggal. Bait rentetan bahasa Go menggunakan pengekodan UTF-8 untuk mengenal pasti teks Unicode.

4

Jenis terbitan:

Termasuk:

(a) Jenis penunjuk (Penunjuk)

• (b) Jenis tatasusunan

int8、int16、int32、int64

(c) Jenis struktur (struktur)

uint8、uint16、uint32、uint64

(d) Jenis saluran

(e) Jenis fungsi

uint8 对应 byte 型
int16 对应 C 语言中的 short 型
int64 对应 C 语言中的 long 型

(f) Jenis Slice

类型	描述
int8	有符号 8位整型 (-128 到 127)
int16	有符号 16位整型 (-32768 到 32767)
int32	有符号 32位整型 (-2147483648 到 2147483647)
int64	有符号 64位整型 (-9223372036854775808 到 9223372036854775807)
uint8	无符号 8位整型 (0 到 255)
uint16	无符号 16位整型 (0 到 65535)
uint32	无符号 32位整型 (0 到 4294967295)
uint64	无符号 64位整型 (0 到 18446744073709551615)

(g) Jenis antara muka (antara muka)

类型	描述
int	32位操作系统上就是int32，64位操作系统上就是int64
uint	32位操作系统上就是uint32，64位操作系统上就是uint64
uintptr	无符号整型，用于存放一个指针

(h) Jenis peta

Terdapat jenis data yang kaya dalam bahasa Go Selain integer asas, jenis titik terapung, jenis Boolean dan rentetan, terdapat juga tatasusunan, kepingan dan struktur. , fungsi, peta, saluran, dsb. 1.1>Integer . - tiada Perbandingan integer simbolik dan bahasa C 1.2 Penerangan integer 1.3 Jenis integer khas

1.4.注意

1.在使用 int 和 uint 类型时，不能假定它是 32 位或 64 位的整型，而是考虑 int 和 uint 可能在不同平台上的差异
2.获取对象的长度的内建 len() 函数返回的长度可以根据不同平台的字节长度进行变化
3.实际使用中，切片或 map 的元素数量等都可以用 int 来表示
4.在涉及到二进制传输，读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用 int 和 uint

1.5.数字字面量语法

• Number literals syntax

• Go1.13 版本之后引入了 数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字

• 内存地址是以十六进制数进行保存的

v := 0b00101101， 代表二进制的 101101，相当于十进制的 45
v := 0o377，代表八进制的 377，相当于十进制的 255
v := 0x1p-2，代表十六进制的 1 除以 2²，也就是 0.25

• 允许用下划线 _ 来分隔数字

v := 123_456 表示 v 的值等于 123456。

• 可以借助 fmt 函数来将一个整数以不同进制形式展示

package main

import "fmt"

func main() {
    // 定义十进制数
    var a int = 10
    fmt.Printf("%d \n", a) // 占位符 %d 表示使用十进制显示为 10
    fmt.Printf("%b \n", a) // 占位符 %b 表示使用二进制显示为 1010

    // 定义八进制数，需要以 0 开头
    var b int = 077
    fmt.Printf("%o \n", b) // 占位符 %o 表示使用八进制显示为 77

    // 定义十六进制数，需要以 0x 开头
    var c int = 0xff
    fmt.Printf("%x \n", c) // 占位符 %x 表示使用十六进制显示为 ff，小写字母显示
    fmt.Printf("%X \n", c) // 占位符 %X 表示使用十六进制显示为 FF，大写字母显示
}

2.浮点型

• Go 语言支持两种浮点型数：float32 和 float64 ，这两种浮点型数据格式遵循 IEEE 754 标准

float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32
float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64
打印浮点数时，可以使用 fmt 包配合 %f

• 实例演示：

package main
import (
    "fmt"
    "math"
)
func main() {
    fmt.Printf("%f\n", math.Pi)
    fmt.Printf("%.2f\n", math.Pi)
}

3.复数

• complex64 和 complex128
• 复数有实部和虚部，complex64 的实部和虚部为 32 位，complex128 的实部和虚部为 64 位

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

4.布尔值

• Go 语言中以 bool 类型进行声明布尔型数据

1.布尔型数据只有 true 和 false 两个值,布尔类型变量的默认值为 false。
2.Go 语言中不允许将整型强制转换为布尔型.
3.布尔型无法参与数值运算，也无法与其他类型进行转换

5.字符串

• Go 语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64 等）一样
• Go 语言字符串使用 UTF-8 编码,可以在 Go 语言的源码中直接添加非 ASCII 码字符

5.1.定义一个字符串类型的变量

• 使用 双引号 定义 单行字符串 变量

• 使用 反引号 定义 多行字符串 变量

• 使用 单引号 定义 单个字符 变量

• 实例演示

package main

import "fmt"

func main() {
    // 使用 双引号 定义 单行字符串 变量
    s1 := "hello" //定义英文字符串
    s2 := "你好"    // 可以识别非 ASCII 码，默认支持 utf-8 编码

    // 使用 反引号 定义 多行字符串 变量
    s3 := `
11111
22222   // 多行字符串里的双斜杠也表示注释
33333
`

    // 使用 单引号 定义 单个字符 变量
    s4 := 'h'

    fmt.Println("\n单行字符串01", s1)
    fmt.Println("\n单行字符串02", s2)
    fmt.Println("\n多行字符串", s3)
    fmt.Println("\n字符定义", s4)
}

5.2.字符串转义

• Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等

转义符	含义
\r	回车符 （返回行首）
\n	换行符 （直接跳到下一行的同列位置）
\t	制表符
'	单引号
"	双引号
\	反斜杠

5.3.字符串转义-实例演示

package main

import (
    "fmt"
)

func main() {
    // 转义符的使用
    fmt.Println("\n# 转义符的使用 str := \"c:\\go\"")
}

5.4.字符串操作

方法	方法说明
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作

5.5.字符串操作-实例演示

package main

import (
    "fmt"
    "strings"
)

// 字符串操作
func main() {
    // 字符串求长度
    s3 := "zhongguojueqi"
    fmt.Println("\n字符串-求长度: ", len(s3))
    
    // 字符串拼接
    s4 := "nihaoshijie"
    fmt.Println("\n字符串-拼接01: ", s3+s4)
    
    s5 := fmt.Sprintf("%s---%s", s3, s4)
    fmt.Println("\n字符串-拼接02: ", s5)
    
    // 字符串分割
    s6 := strings.Split(s3, "o")
    fmt.Println("\n字符串-分割: ", s6)
    
    // 字符串包含判断
    s7 := strings.Contains(s3, "o")
    fmt.Println("\n字符串-包含判断01: ", s7)
    fmt.Println("\n字符串-包含判断02: ", strings.Contains(s3, "o"))
    
    // 字符串前缀， 后缀判断
    fmt.Println("\n字符串-前缀判断: ", strings.HasPrefix(s3, "zhong"))
    fmt.Println("\n字符串-后缀判断: ", strings.HasSuffix(s3, "qi"))
    
    // 字符串索引查找
    fmt.Println("\n字符串-索引查找-第一个字符 o 的索引: ", strings.Index(s3, "o"))
    fmt.Println("\n字符串-索引查找-最后一个字符 o 的索引: ", strings.LastIndex(s3, "o"))
    
    // 字符串-join操作
    s8 := []string{"aaa", "bbb", "ccc", "ddd"}
    fmt.Println("\n字符串-join 操作: ", strings.Join(s8, " + "))
}

6.字符

6.1.定义一个字符变量

• 组成字符串的元素叫做 字符,使用单引号进行定义字符类型变量，字符串使用双引号定义
• 可以通过遍历或者单个获取字符串元素获得字符

func runeDemo01() { // 字符定义
    a := '中'         // 默认识别为 rune 类型的字符变量
    b := "中"         // 定义一个字符串
    var c byte = 'a' // 定义一个byte类型字符
    var d rune = 'a' // 定义一个rune类型字符
    fmt.Println(a, b)
    fmt.Printf("%v,%T\n", c, c)
    fmt.Printf("%v,%T\n", d, d)
}

6.2.字符类型有两种

6.2.1.uint8-类型字符

• go 语言中一般的英文数字字符使用 ASCII 码的一个字符，占据 8 位 bit 的内存空间，也就是常用的 byte 型

6.2.2.rune-类型字符

• go 语言中处理中文日文或者其他复合字符时，需要用到 rune 类型，rune 类型实际是一个 int32，代表一个 UTF-8 字符（Unicode编码）

7.字符串拓展

7.1.字符串遍历-方法1-使用循环依次取出字符串中的元素

// 字符串遍历-traversalString
package main

import (
    "fmt"
)

func traversalString01() {
    s := "hello世界"
    for i := 0; i < len(s); i++ { // 中英文使用 for循环加 len() 方法遍历循环，但遇到中文会有乱码
      fmt.Printf("%v(%c) ", s[i], s[i])
    }
    fmt.Println()
    fmt.Println([]byte(s))
}
-----------------------
104(h) 101(e) 108(l) 108(l) 111(o) 228(ä) 184(¸) 150() 231(ç) 149() 140()
-----------------------

7.2.字符串遍历-方法2-rune-类型遍历可以使用 for range 循环

package main

import (
    "fmt"
)

// 遍历字符串 traversalString
func traversalString02() {
    s := "hello世界"
    fmt.Println()
    for _, r := range s { // 按照 rune 类型遍历
        fmt.Printf("%v(%c) ", r, r)
    }
    fmt.Println()
    fmt.Println([]rune(s))

}
-----------------------
104(h) 101(e) 108(l) 108(l) 111(o) 19990(世) 30028(界)
-----------------------

• 结果分析：

1.因为 UTF8 编码下一个中文汉字由 3~4 个字节组成，所以我们不能简单的按照字节去遍历一个包含中文的字符串，否则就会出现上面输出中第一行的结果
2.字符串底层是一个 byte 数组，所以可以和 []byte 类型相互转换
3.字符串是不能修改的 字符串是由 byte 字节组成，所以字符串的长度是 byte 字节的长度
4.rune 类型用来表示 utf8 字符，一个 rune 字符由一个或多个 byte 组成。

7.3.字符串修改

• 字符串是固定值无法修改，如果要修改字符串，需要先将其转换成 []rune 或 []byte，完成后再转换为 string 类型。无论哪种转换，都会重新分配内存，并复制字节数组

func changeString() {
    s1 := "big"
    // 强制类型转换
    byteS1 := []byte(s1)
    byteS1[0] = 'p'
    fmt.Println(string(byteS1))

    s2 := "白萝卜"
    runeS2 := []rune(s2)
    runeS2[0] = '红'
    fmt.Println(string(runeS2))
}

8.类型转换

• Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用

8.1.类型转换-语法

T(表达式)

• 其中，T 表示要转换的类型，表达式包括变量、复杂算子和函数返回值等

8.1.类型转换-实例演示

func sqrtDemo() {
  var a, b = 3, 4
  var c int
  // math.Sqrt()接收的参数是float64类型，需要强制转换
  c = int(math.Sqrt(float64(a*a + b*b)))
  fmt.Println(c)
}

• 说明

计算直角三角形的斜边长时使用 math 包的 Sqrt() 函数，该函数接收的是 float64 类型的参数
而变量 a 和 b 都是 int 类型的，这个时候就需要将 a 和 b 强制类型转换为 float64 类型

【相关推荐：Go视频教程、编程教学】

Atas ialah kandungan terperinci Apakah jenis data yang terdapat dalam bahasa go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!