Go语言数据类型

整形

整型范围

有符号整型：

• int8（-128 -> 127）
• int16（-32768 -> 32767）
• int32（-2,147,483,648 -> 2,147,483,647）
• int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）
• int

• • 在 32 位操作系统上使用 32 位（-2,147,483,648 -> 2,147,483,647） 2**32
  • 在 64 位操作系统上使用 64 位（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,80）2**64

无符号整数：

• uint8（0 -> 255）
• uint16（0 -> 65,535）
• uint32（0 -> 4,294,967,295）
• uint64（0 -> 18,446,744,073,709,551,615）
• uint

• • 在 32 位操作系统上使用32 位（0 -> 4,294,967,295） 2**32
  • 64 位操作系统上使用 64 位（0 -> 18,446,744,073,709,551,615） 2**64

不同整型可表示的数据范围不同，根据自己的需求来选择适合的类型。

整形间转换

var v1 int8 = 10
var v2 int16 = 18
v3 := int16(v1) + v2
fmt.Println(v3, reflect.TypeOf(v3))

>>> 输出
28 int16

整型与字符串的转换

// 整型转换为字符串类型
v1 := 19
result := strconv.Itoa(v1)
fmt.Println(result, reflect.TypeOf(result))
var v2 int8 = 17
data := strconv.Itoa(int(v2))
fmt.Println(data,reflect.TypeOf(data))



// 字符串转换为整型：转换后是int类型;可能存在错误
v1 := "666"
result, err := strconv.Atoi(v1)
if err == nil {
    fmt.Println("转换成功", result,reflect.TypeOf(result))
} else {
    fmt.Println("转换失败")
}

进制转换

• Go代码中：

• • 十进制，整型的方式存在。
  • 其他进制，是以字符串的形式存在。

• 整形，10进制数
• 

// 整型(十进制）转换为其他进制
	v1 := 12
	r1 := strconv.FormatInt(int64(v1), 2)
	fmt.Println(r1, reflect.TypeOf(r1))

>>> 输出
1100 string



// 其他进制(字符串)转换为10进制
	data := "1001000101"
	result, err := strconv.ParseInt(data, 2, 0)
	fmt.Print(result, err, reflect.TypeOf(result))

>>> 输出
581 <nil> int64


--------------------------------------------------------------------------------
//小练习
	//将十进制 14 用 转换成16进制的字符串
	v1 := strconv.FormatInt(14, 16)
	fmt.Println(v1)

	//将 2进制 "10011" 转换成 10进制的整型
	v2, _ := strconv.ParseInt("10011", 2, 0)
	fmt.Println(v2)

	//将 2进制 "10011" 转换成 16 进制的字符串
	v3, _ := strconv.ParseInt("10011", 2, 0)
	fmt.Println(strconv.FormatInt(v3, 16))

数组

在 go 语言中，数组定义了后就无法修改长度

package main

import (
	"fmt"
)

func main() {
	// 定义一个整数数组

	intcui := [6]int{1, 2, 3, 4, 5, 6}
	// 打印数组
	fmt.Println("数组", intcui)

	// 遍历整数数组并打印每个元素
	fmt.Println("遍历整数数组:")
	for i, num := range intcui {
		fmt.Printf("索引:%d, 元素:%d\n", i, num)
	}

	// 获取数组的长度
	length := len(intcui)
	fmt.Println("数组的长度:", length)

	// 查看数组中的元素
	fmt.Println("查看数组的第二个元素:", intcui[2])

	// 修改数组的元素
	intcui[2] = 66
	fmt.Print("修改后的元素", intcui[2])
}


>>> 输出
数组 [1 2 3 4 5 6]
遍历整数数组:
索引:0, 元素:1
索引:1, 元素:2
索引:2, 元素:3
索引:3, 元素:4
索引:4, 元素:5
索引:5, 元素:6
数组的长度: 6
查看数组的第二个元素: 3
修改后的元素66

切片

Go语言中，切片 slice 是一种动态数组的数据结构，可以随时添加或删除元素

所以切片是一个引用类型（因此更类似于 或者 Python 中的 list 类型）

package main

import "fmt"

func main() {
	// 创建&打印一个整数切片
	intSlice := []int{1, 2, 3, 4, 5, 6}
	fmt.Println(intSlice)

	// 遍历整数切片打印索引&元素
	for i, num := range intSlice {
		fmt.Printf("索引:%d,元素:%d\n", i, num)
	}

	//获取切片的长度
	length := len(intSlice)
	fmt.Printf("切片的长度为:%d", length)

	// 添加元素到切片末尾
	intSlice = append(intSlice, 7, 8, 9)
	fmt.Println("现在所有的元素是:", intSlice)

	// 删除切片中最后一位元素
	intSlice = intSlice[:len(intSlice)-1]
	fmt.Println("现在所有的元素是:", intSlice)

	// 创建一个新的切片，复制 intSlice 中的元素
	newSlice := make([]int, len(intSlice))
	copy(newSlice, intSlice)
	fmt.Println("newSlice切片的元素是:", newSlice)
}


>>> 输出
[1 2 3 4 5 6]
索引:0,元素:1
索引:1,元素:2
索引:2,元素:3
索引:3,元素:4
索引:4,元素:5
索引:5,元素:6
切片的长度为:6现在所有的元素是: [1 2 3 4 5 6 7 8 9]
现在所有的元素是: [1 2 3 4 5 6 7 8]
newSlice切片的元素是: [1 2 3 4 5 6 7 8]

字典

在 Go 语言中，map 是一种键值对的数据结构，可以用来存储键值对

map 是无序的，Go 语言中的map是引用类型，它的值可以被修改

package main

import (
	"fmt"
)

func main() {
	StringToint_1()
	StringToint_2()
}

func StringToint_1() {
	// 创建一个字符串到整数的map
	stringToint := make(map[string]int)
	stringToint["one"] = 1
	stringToint["two"] = 2
	stringToint["three"] = 3
	fmt.Println(stringToint)
}

func StringToint_2() {
	stringToInt := map[string]int{"one": 1, "two": 2, "three": 3}
	fmt.Println(stringToInt)

	// 查看map的长度
	fmt.Println(len(stringToInt))

	// 修改map的值
	stringToInt["one"] = 111
	fmt.Println("修改的后的值为", stringToInt["one"])

	// 删除map中的键值对
	delete(stringToInt, "one")
	fmt.Println("删除后的map值为", stringToInt)

	// 判断map中是否存在某个键 返回true/false
	_, prs := stringToInt["three"]
	fmt.Println(prs)
}


>>> 输出
map[one:1 three:3 two:2]
map[one:1 three:3 two:2]
3
修改的后的值为 111
删除后的map值为 map[three:3 two:2]
true