Die Datentypen der Go-Sprache sind: 1. Boolescher Typ, der Wert kann nur eine Konstante wahr oder falsch sein; 2. Numerischer Typ, der Ganzzahlen und Gleitkommazahlen unterstützt; 3. String-Typ; , das ist eine Zeichenfolge, die durch Zeichen fester Länge verbunden ist; 5. Strukturierter Typ; . Kartentyp .
Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.
Datentypen der Go-Sprache
In der Programmiersprache Go werden Datentypen zum Deklarieren von Funktionen und Variablen verwendet.
Das Aufkommen von Datentypen besteht darin, Daten in Daten mit unterschiedlichen erforderlichen Speichergrößen aufzuteilen. Beim Programmieren müssen Sie nur dann großen Speicher beantragen, wenn Sie große Datenmengen verwenden müssen, damit Sie den Speicher vollständig nutzen können.
Go-Sprache hat die folgenden Datentypen nach Kategorie:
| Seriennummer |
Typ und Beschreibung |
| 1 |
Boolean
Der Wert von Boolean kann nur die Konstante wahr oder falsch sein. Ein einfaches Beispiel: var b bool = true. |
| 2 |
Zahlentyp
Ganzzahltyp int und Gleitkommatyp float32, float64, Die Go-Sprache unterstützt Ganzzahl- und Gleitkommazahlen sowie komplexe Zahlen, bei denen die Bitoperation Komplementcode verwendet. |
| 3 |
String-Typ:
Eine Zeichenfolge ist eine Zeichenfolge, die durch eine Reihe von Zeichen fester Länge verbunden ist. Die Zeichenfolgen von Go werden aus einzelnen Bytes verkettet. Die Bytes der Go-Sprachzeichenfolgen verwenden die UTF-8-Codierung, um Unicode-Text zu identifizieren. |
| 4 |
Abgeleitete Typen:
umfassen: |
Es gibt umfangreiche Datentypen in der Go-Sprache. Neben einfachen Ganzzahlen, Gleitkommatypen, booleschen Typen und Zeichenfolgen gibt es auch Arrays, Slices, Strukturen, Funktionen, Karten, Kanäle usw.
1. Ganzzahl
Ganzzahl
1.1. Ganzzahlen werden in zwei Kategorien unterteilt
unterteilt nach der belegten Speicherlänge
int8、int16、int32、int64
Nach dem Login kopieren
unterteilt danach, ob ein Plus- oder Minuszeichen vorhanden ist - vorzeichenlose Ganzzahl
-
uint8、uint16、uint32、uint64
Nach dem Login kopieren
Vergleich mit C-Sprache
uint8 对应 byte 型
int16 对应 C 语言中的 short 型
int64 对应 C 语言中的 long 型
Nach dem Login kopieren
1.2. Ganzzahlige Beschreibung
Typ
| Beschreibung |
|
int8
| Signiert 8- Bit-Ganzzahl (-1 28 bis 127) |
|
int16
| 16-Bit-Ganzzahl mit Vorzeichen (-32768 bis 32767) | Vorzeichenbehaftete 64-Bit-Ganzzahl ( -9223372036854775808 bis 9223372036854775807 ) |
uint8 | Vorzeichenlose 8-Bit-Ganzzahl (0 bis 255) |
uint16 | Vorzeichenlose 16-Bit-Ganzzahl (0 bis 6553. 5) |
uint32 | un vorzeichenbehafteter 32-Bit-Ganzzahltyp ( 0 bis 4294967295) |
uint64 | Vorzeichenloser 64-Bit-Ganzzahltyp (0 bis 18446744073709551615) |
| 1.3. Spezieller Ganzzahltyp |
| Typ | Beschreibung
int
Auf 32-Bit-Betriebssystemen ist es int32, auf 64-Bit-Betriebssystemen ist es int64
| uint | Auf 32-Bit-Betriebssystemen ist es uint32, auf 64-Bit-Betriebssystemen ist es uint64
uintptr| | Ganzzahltyp ohne Vorzeichen, der zum Speichern eines Zeigers verwendet wird |
1.4.注意
1.在使用 int 和 uint 类型时，不能假定它是 32 位或 64 位的整型，而是考虑 int 和 uint 可能在不同平台上的差异
2.获取对象的长度的内建 len() 函数返回的长度可以根据不同平台的字节长度进行变化
3.实际使用中，切片或 map 的元素数量等都可以用 int 来表示
4.在涉及到二进制传输，读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用 int 和 uint
Nach dem Login kopieren
1.5.数字字面量语法
v := 0b00101101， 代表二进制的 101101，相当于十进制的 45
v := 0o377，代表八进制的 377，相当于十进制的 255
v := 0x1p-2，代表十六进制的 1 除以 2²，也就是 0.25
Nach dem Login kopieren
v := 123_456 表示 v 的值等于 123456。
Nach dem Login kopieren
- 可以借助 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，大写字母显示
}Nach dem Login kopieren
2.浮点型
- Go 语言支持两种浮点型数：float32 和 float64 ，这两种浮点型数据格式遵循 IEEE 754 标准
float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32
float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64
打印浮点数时，可以使用 fmt 包配合 %f
Nach dem Login kopieren
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%f\n", math.Pi)
fmt.Printf("%.2f\n", math.Pi)
}Nach dem Login kopieren
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)
Nach dem Login kopieren
4.布尔值
1.布尔型数据只有 true 和 false 两个值,布尔类型变量的默认值为 false。
2.Go 语言中不允许将整型强制转换为布尔型.
3.布尔型无法参与数值运算，也无法与其他类型进行转换
Nach dem Login kopieren
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)
}Nach dem Login kopieren
5.2.字符串转义
- Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等
| 转义符 |
含义 |
| \r |
回车符 （返回行首） |
| \n |
换行符 （直接跳到下一行的同列位置） |
| \t |
制表符 |
| ' |
单引号 |
| " |
双引号 |
| \ |
反斜杠 |
5.3.字符串转义-实例演示
package main
import (
"fmt"
)
func main() {
// 转义符的使用
fmt.Println("\n# 转义符的使用 str := \"c:\\go\"")
}Nach dem Login kopieren
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, " + "))
}Nach dem Login kopieren
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)
}Nach dem Login kopieren
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()
-----------------------Nach dem Login kopieren
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(界)
-----------------------Nach dem Login kopieren
1.因为 UTF8 编码下一个中文汉字由 3~4 个字节组成，所以我们不能简单的按照字节去遍历一个包含中文的字符串，否则就会出现上面输出中第一行的结果
2.字符串底层是一个 byte 数组，所以可以和 []byte 类型相互转换
3.字符串是不能修改的 字符串是由 byte 字节组成，所以字符串的长度是 byte 字节的长度
4.rune 类型用来表示 utf8 字符，一个 rune 字符由一个或多个 byte 组成。
Nach dem Login kopieren
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))
}Nach dem Login kopieren
8.类型转换
- Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用
8.1.类型转换-语法
T(表达式)
Nach dem Login kopieren
- 其中，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)
}Nach dem Login kopieren
计算直角三角形的斜边长时使用 math 包的 Sqrt() 函数，该函数接收的是 float64 类型的参数
而变量 a 和 b 都是 int 类型的，这个时候就需要将 a 和 b 强制类型转换为 float64 类型
【相关推荐：Go视频教程、编程教学】
Das obige ist der detaillierte Inhalt vonWelche Datentypen gibt es in der Go-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
