go数据类型和类型转换

Go 语言是一种静态类型语言，它具有丰富的基本数据类型，同时也支持用户定义的结构体、接口等高级数据类型， Go 语言的一些基本数据类型：

整数类型：int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64
浮点数类型：float32, float64
复数类型：complex64, complex128
布尔类型：bool
字符串类型：string
字节类型：byte (uint8 的别名)
符文类型：rune (int32 的别名，用于表示 Unicode 字符)

go是一种强类型语言，变量在使用需要声明类型，但是在某些场景下，数据类型无法确认，需要使用reflect.TypeOf获取
比如：
遍历一个字符串的时候，遍历的每个元素是int32类型，不能直接打印

单引号表示byte类型或者rune类型，对应uint8和int32类型，默认rune
双引号表示字符串，即字符数组，所以遍历字符串得到int32类型的字符

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var a = 1
	fmt.Println(reflect.TypeOf(a))
	fmt.Println(reflect.TypeOf("a"))
	fmt.Println(reflect.TypeOf('a'))
	for _, x := range "abc" {
		fmt.Println(reflect.TypeOf(x), x, string(x))
	}
}

输出为：

int
string    
int32     
int32 97 a
int32 98 b
int32 99 c

类型转换

1.int<—>string && int<—>rune

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	var a = 69
	//string-->int
	ks, _ := strconv.Atoi("76")
	fmt.Println(ks, reflect.TypeOf(ks))
	//int-->string
	inta := strconv.Itoa(a)
	fmt.Println(inta, reflect.TypeOf(inta))
	//int-->string
	a = 10
	k := fmt.Sprintf("%d", a)
	fmt.Println(k, reflect.TypeOf(k))
	//int32-->int
	fmt.Println(int('a'))
	//int-->int32
	fmt.Println(strconv.QuoteRuneToASCII(97))
	char := fmt.Sprintf("%c", 98)
	fmt.Println(char, reflect.TypeOf(char))
	fmt.Println(string(rune(67)))
}
//76 int
//69 string
//10 string
//97
//'a'
//b string
//C  

2.复数类型和断言类型

package main

import (
    "fmt"
    "math"
)

func main() {
    // 复数类型转换
    var c complex64 = complex(3, 4)
    var d complex128 = complex128(c)

    // 类型断言：用于接口类型转换
    var val interface{} = 42
    convertedVal, ok := val.(int)
    if ok {
        fmt.Println("转换后的值:", convertedVal)
    } else {
        fmt.Println("无法转换")
    }

    // 类型转换函数：math 包中提供了一些类型转换的函数
    var floatNum float64 = 3.14
    var intNum int = int(math.Floor(floatNum))
    fmt.Println(intNum)
}

3.字符串<---->浮点数

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

func main() {
	// 字符串转浮点数
	str := "3.14"
	floatNum, err := strconv.ParseFloat(str, 64)
	if err != nil {
		fmt.Println("转换错误:", err)
	} else {
		fmt.Println("转换后的浮点数:", floatNum)
	}

	// 浮点数转字符串
	num := 3.14159
	strFloat := strconv.FormatFloat(num, 'f', -1, 64)
	fmt.Println("转换后的字符串:", strFloat)
	// 浮点数转字符串
	b := 3.1515
	fmt.Println(reflect.TypeOf(b))
	k2 := fmt.Sprintf("%.1f", b)
	fmt.Println(k2, reflect.TypeOf(k2))
}

在上面的示例中，使用了 strconv.ParseFloat() 函数将字符串转换为浮点数，其中第一个参数是要转换的字符串，第二个参数是转换后的浮点数的位数（64 表示使用 float64 类型），返回值中的第一个是转换后的浮点数，第二个是错误信息。

同样地，使用 strconv.FormatFloat() 函数将浮点数转换为字符串，其中第一个参数是要转换的浮点数，第二个参数表示要格式化的方式，第三个参数表示小数点位数（-1 表示自动选择），第四个参数表示要使用的浮点数类型。

4.整型<—>浮点数

package main

import (
	"fmt"
)

func main() {
	// 整型转浮点型
	intNum := 10
	floatNum := float64(intNum)
	fmt.Println("整型转浮点型:", floatNum)

	// 浮点型转整型（会丢失小数部分）
	floatNum2 := 3.14
	intNum2 := int(floatNum2)
	fmt.Println("浮点型转整型:", intNum2)

	// 浮点型转整型（取整数部分）
	floatNum3 := 3.999
	intNum3 := int(floatNum3)
	fmt.Println("浮点型转整型（取整数部分）:", intNum3)
}

在上面的示例中，float64(intNum) 将整型转换为浮点型，而 int(floatNum2) 将浮点型转换为整型，但会丢失小数部分。如果希望浮点型转换为整型时取整数部分，可以直接将浮点数赋给整型变量，Go 会自动将浮点数的小数部分截断。

5.字符串和 rune 的转换

package main

import (
	"fmt"
)

func main() {
	// 字符串转 rune 切片
	str := "Hello, 世界!"
	runeSlice := []rune(str)
	fmt.Printf("字符串 \"%s\" 转 rune 切片: %v\n", str, runeSlice)

	// rune 切片转字符串
	newStr := string(runeSlice)
	fmt.Printf("rune 切片 %v 转字符串: \"%s\"\n", runeSlice, newStr)
}

在上面的示例中，通过 []rune(str) 将字符串转换为 rune 切片，通过 string(runeSlice) 将 rune 切片转换为字符串。这里要注意，字符串是由多个 byte 组成的，而 rune 是 Unicode 字符，可以包含多个字节。

字符串遍历的时候使用string类型
方法1：

package main

import "fmt"

func main() {
    r := '你' // Unicode码点为0x4F60
    s := string([]rune{r})
    fmt.Println(s) // 输出：你
}

在上面的代码中，我们将rune类型的值'你'放入一个长度为1的切片中，然后将该切片转换为string类型，最终得到了字符串"你"。
方法2：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	for _, k := range "沃斯尼蝶" {
		tmp := fmt.Sprintf("%c", k)
		fmt.Println(tmp, reflect.TypeOf(tmp))
	}
}

我们首先定义了一个字符串变量str，然后使用[]rune将其转换为rune类型的切片runes。接着，我们使用range关键字遍历runes切片中的每个元素，并使用%c格式化符号将其打印出来。
6.rune 和整型的转换

package main

import (
	"fmt"
)

func main() {
	// rune 转整型
	r := 'A' // 单引号表示 rune
	rInt := int(r)
	fmt.Printf("rune '%c' 转整型: %d\n", r, rInt)

	// 整型转 rune
	i := 65
	iRune := rune(i)
	fmt.Printf("整型 %d 转 rune: '%c'\n", i, iRune)
}

在上面的示例中，‘A’ 是一个 rune，通过 int® 可以将 rune 转换为对应的整型。而整型 65 可以通过 rune(i) 转换为对应的 rune。