Go语言笔记--数据类型

深藏阁楼爱情的钟 2022-03-17 00:23 308阅读 0赞

# 1.Go基本类型 #

1）布尔型：bool
          长度：1字节
          取值范围：true,false
          注意事项：不可以用数字代表true或false
    2）整型：int/uint
        根据运行平台可能位32或64位
    3）8位整型：int8/uint8
        长度：1字节
        取值范围：-128~127/0~255
    4）字节型：byte(uint8别名)
    5）16位整型：int16/uint16
        长度：2字节
        取值范围：-2^63/2~2^64/2-1/0~2^64-1
    6）浮点型：float32/float64
        长度：4/8字节
        小数位：精确到7/15小数位
    7）复数：complex64/complex128
        长度：8/16字节
    8）足够保存指针的32位或64位整数型：uintptr
    9）其他值类型：
        array、struct、string
    10）引用类型：
        slice、map、chan
    11）接口类型：interface
    12）函数类型：func

# 2.类型零值 #

零值并不等于空值，而是当变量被声明位某种类型后的默认值，通常情况下值类型默认为0，bool为false，string为空字符串

# 3.类型别名 #

将类型名设置位其他名称，例如：

package main
    
    
    import "fmt"
    
    
    type (
        byte int8
        runt int32
        文本   string
    )
    
    
    func main() {
        var b 文本
        b = "这是中文"
        fmt.Println(b)
    }
    
    输出：
    API server listening at: 127.0.0.1:33342
    这是中文

# 4.单个变量的声明与赋值 #

1）变量的声明格式：var <变量名称> <变量类型>

2）变量的赋值格式：<变量名称> = <表达式>

3）声明的同时赋值：var <变量名称> \[变量类型\] = <表达式>

例如：

var a int //变量的声明
    a = 123 //变量的赋值
    
    //变量声明的同时赋值
    var b int = 321
    //上行的格式可省略变量类型，又系统推断
    var c = 321
    //变量声明与赋值的最简写法
    d := 456

# 5.多个变量的声明与赋值 #

1）全局变量的声明可用var()的方式进行简写

2）全局变量的声明与赋值不可以省略var，但可以使用并行方式

3）所有变量都可以使用类型推断

4）局部变量不可以使用var()的方式简写，只能使用并行方式

例如：

//多个变量的声明
    var a, b, c, d int
    //多个变量的赋值
    a, b, c, d = 1, 2, 3, 4
    //多个变量声明的同时赋值
    var e, f, g, h int = 1, 2, 3, 4
    //省略变量类型，由系统推断
    var i, j, k, l = 1, 2, 3, 4
    //多个变量声明与赋值的最简写法
    i, m, n, o := 1, 2, 3, 4

# 6.变量的类型转换 #

1）Go中不存在隐式转换，所有类型转换必须显式声明

2）转换只能发生再两种相互兼容的类型之间

3）类型转换的格式：<ValueA> \[:\] = <TypeOfValueA>(<ValueB>)

例如：

//再相互兼容的两种类型直接进行转换
    var a float32 = 1.1
    b := int(a)
    
    //以下表达式无法编译通过，转换错误
    var c bool = true
    d := int(c)

# 代码实例 #

package main
    
    import "fmt"
    
    //定义包内变量，在函数外部则不可以使用冒号 即 "aa := 3",必须是 var aa = 3
    var aa int = 3
    
    //不赋初值使用变量则是零值
    func variableZeroValue() {
    	var a int
    	var s string
    	fmt.Printf("%d %q\n", a, s)
    }
    
    //赋初值定义变量
    func variableInitialValue() {
    	var a, b int = 3, 4
    	var s string = "hello"
    	fmt.Println(a, b, s)
    }
    
    //自动识别变量类型
    func variableTypeDeduction() {
    	var a, b, c, s = 3, 4, true, "hello beijing"
    	fmt.Println(a, b, c, s)
    }
    
    //使用冒号定义变量并初始化
    func variableShorter() {
    	a, b, c, s := 3, 4, true, "hello beijing"
    	fmt.Println(a, b, c, s)
    	//再次修改则不需要使用冒号了
    	b = 9
    	fmt.Println(a, b, c, s)
    }
    
    func main() {
    	fmt.Println("hello golang")
    	variableZeroValue()
    	variableInitialValue()
    	variableShorter()
    
    	fmt.Println(aa)
    }
    
    
    
    执行结果：
    API server listening at: 127.0.0.1:15229
    hello golang
    0 ""
    3 4 hello
    3 4 true hello beijing
    3 9 true hello beijing
    3

# 类型强制转换代码实例 #

package main
    
    import (
    	"fmt"
    	"math"
    )
    
    //类型强制转换
    func triangle() {
    	var a, b int = 3, 4
    	var c int
    	c = int(math.Sqrt(float64(a*a + b*b)))
    	fmt.Println(c)
    }
    
    func main() {
    	triangle()
    }
    
    执行结果：
    API server listening at: 127.0.0.1:2780
    5

# 复数代码实例 #

package main
    
    import (
    	"fmt"
    	"math"
    	"math/cmplx"
    )
    
    //获取复数绝对值
    func myAbs() {
    	c := 3 + 4i
    	fmt.Println(cmplx.Abs(c))
    }
    
    //欧拉公式
    func euler() {
    	fmt.Println(cmplx.Exp(1i*math.Pi) + 1)
    	fmt.Printf("%3f\n", cmplx.Exp(1i*math.Pi)+1)
    }
    
    func main() {
    	myAbs()
    	euler()
    }
    
    执行结果：
    API server listening at: 127.0.0.1:44233
    5
    (0+1.2246467991473515e-16i)
    (0.000000+0.000000i)

# 字符串示例 #

package main
    
    import (
    	"fmt"
    	"unicode/utf8"
    )
    
    func main() {
    	s := "hello北京天安门！" //UTF-8编码，在够语言中每个汉字占用3个字节
    	fmt.Println(s)
    
    	for _, b := range []byte(s) {
    		fmt.Printf("%X ", b)
    	}
    	fmt.Println()
    
    	//打印十六进制
    	for i, ch := range s { //在这里ch就是rune类型
    		fmt.Printf("(%d %X) ", i, ch)
    	}
    
    	fmt.Println()
    	//使用utf-8可以获取到正确的字符数
    	fmt.Println("rune count:", utf8.RuneCountInString(s))
    
    	//打印每个字的索引，可以看出到汉字部分每个括号条3个字节
    	bytes := []byte(s)
    	for len(bytes) > 0 {
    		ch, size := utf8.DecodeRune(bytes)
    		bytes = bytes[size:]
    		fmt.Printf("%c ", ch)
    	}
    	fmt.Println()
    
    	//每个字符的显示位置
    	for i, ch := range []rune(s) {
    		fmt.Printf("(%d %c)", i, ch)
    	}
    
    	fmt.Println()
    }
    输出：
    API server listening at: 127.0.0.1:28744
    hello北京天安门！
    68 65 6C 6C 6F E5 8C 97 E4 BA AC E5 A4 A9 E5 AE 89 E9 97 A8 EF BC 81 
    (0 68) (1 65) (2 6C) (3 6C) (4 6F) (5 5317) (8 4EAC) (11 5929) (14 5B89) (17 95E8) (20 FF01) 
    rune count: 11
    h e l l o 北 京 天 安 门 ！ 
    (0 h)(1 e)(2 l)(3 l)(4 o)(5 北)(6 京)(7 天)(8 安)(9 门)(10 ！)

练习：

package main
    
    import (
    	"fmt"
    )
    
    //值传递
    func swap(a, b int) {
    	b, a = a, b
    }
    
    //指针传递
    func pswap(a, b *int) {
    	*b, *a = *a, *b
    }
    
    //实现交换，等价于指针传递
    func pswap2(a, b int) (int, int) {
    	return b, a
    }
    
    func main() {
    	a, b := 3, 4
    	swap(a, b)
    	fmt.Println(a, b)
    
    	c, d := 5, 6
    	pswap(&c, &d)
    	fmt.Println(c, d)
    
    	e, f := 7, 8
    	e, f = pswap2(e, f)
    	fmt.Println(e, f)
    }