Go笔记(一):基本数据类型
前言
Go官方编程指南:https://golang.google.cn/doc/tutorial/
![0](https://img2023.cnblogs.com/blog/1680081/202304/1680081-20230410171214254-596578699.png)
选择中文阅读go的官方文档。
![0](https://img2023.cnblogs.com/blog/1680081/202304/1680081-20230410171214165-389328111.png)
查看官方提供的go的包的函数使用,即API(application program interface)应用程序接口,就是go的各个包的各个函数:https://golang.google.cn/doc/tutorial/getting-started
![0](https://img2023.cnblogs.com/blog/1680081/202304/1680081-20230410171214036-960832403.png)
一、常量
1、语法格式
常量,编译阶段已经确定了值,程序在运行时无法改变常量的值。定义一个常量使用const关键字,语法格式如下:
const constantName [type] = value
const: 定义常量关键字;
constantName: 常量名称;
type: 常量类型;
value: 常量的值
2、示例代码
1 package main 2 3 import "fmt" 4 5 /** 6 声明单个变量:指定类型、类型推导 7 */ 8 func defineSingleConst() { 9 // 指定类型 10 const CONST01 int8 = 1 11 fmt.Printf("指定类型:CONST01: %v\n", CONST01) 12 13 // 类型推导 14 const CONST02 = 3.1415926 15 fmt.Printf("类型推导:CONST02: %v\n", CONST02) 16 } 17 18 /** 19 const同时声明多个变量,如果省略了值则表示和上面一行的值相同。 20 */ 21 func defineMultiConst() { 22 // 批量声明常量 23 const ( 24 W = 10 25 H = 20 26 ) 27 fmt.Printf("定义多常量:W: %v, H: %v\n", W, H) 28 29 // 省略了值则表示和上面一行的值相同。 30 const ( 31 PRICE01 = 20.00 32 PRICE02 = 30.00 33 //PRICE02 34 PRICE03 35 ) 36 fmt.Printf("PRICE01: %v, PRICE02: %v, PRICE03: %v\n", PRICE01, PRICE02, PRICE03) 37 } 38 39 /** 40 iota关键字,可被编译器修改的常量,默认值为0 41 每次调用常量值加1 42 遇到const关键字,会被重置为0 43 */ 44 func iotaKeys() { 45 // 默认值为0,每次调用加 1 46 const ( 47 x = iota 48 y = iota 49 z = iota 50 ) 51 fmt.Printf("x: %v, y: %v, z: %v\n", x, y, z) 52 fmt.Println("=================================================") 53 54 // 遇到const关键字,会被重置为0 55 // 使用 '_' 跳过某些值 56 const ( 57 a = iota 58 _ 59 c = iota 60 ) 61 fmt.Printf("a: %v, c: %v\n", a, c) 62 fmt.Println("=================================================") 63 64 // iota 声明使用中间插队的场景 65 const ( 66 q = iota 67 w = 200 68 s = iota 69 ) 70 fmt.Printf("q: %v, w: %v, s: %v\n", q, w, s) 71 } 72 73 74 func main() { 75 defineSingleConst() 76 defineMultiConst() 77 iotaKeys() 78 }
二、变量
1、语法格式
变量:内存中的一块存储区域,该区域中存储 变量名 、数据类型、变量值。定义一个变量使用 var 关键字。声明变量语法结构如下:
var varName [type]
var: 定义变量关键字;
varName: 变量名称;
type: 变量类型
2、示例代码
1 package main 2 3 import "fmt" 4 5 // ===== 全局变量的声明 ===== 6 // 方式一 7 var var10 = 10 8 var var11 = 6.8 9 var var12 = "jack" 10 // 方式二 11 var ( 12 var20 = 80 13 var21 = 5.20 14 var22 = "tom" 15 ) 16 17 // ===== 局部变量的声明 ===== 18 /** 19 声明单个变量 20 */ 21 func defineSingleLocalVar() { 22 // ===== 指定类型 ===== 23 // 声明变量 24 var var01 int 25 // 变量赋值 26 var01 = 3 27 // 使用变量 28 fmt.Println("声明单变量 -> var01 = ", var01) 29 30 // ===== 类型推导:根据值自行判断数据类型 ===== 31 var02 := 3.1415926 32 fmt.Println("声明单变量 -> var02 = ", var02) 33 34 // 变量不赋值,使用默认值 35 var y int 36 fmt.Println("声明单变量 -> y = ", y) 37 38 // 变量在同一作用域(在一个函数或者代码)内不能重名 39 //var var10 int = 3 40 41 // var 与 := 不能一起使用 42 //var x := 3 43 //fmt.Println("声明单变量 -> x = ", x) 44 45 } 46 47 /** 48 声明多个变量 49 */ 50 func defineMultiLocalVar() { 51 // 指定类型 52 var var01, var02 int 53 var01 = 4 54 var02 = 5 55 fmt.Printf("多局部变量声明方式一 -> var03 = %v, var03 = %v\n", var01, var02) 56 57 // 类型推导 58 var var03, var04, var05 = 4, "tom", 4.5 59 fmt.Println("多局部变量声明方式二 -> var03 = ", var03, ",var04 = ", var04, ",var05 = ", var05) 60 61 // 方式三:类型推导 62 var06, var07, var08 := 6, "tuoni", 7.8 63 fmt.Println("多局部变量声明方式三 -> var06 = ", var06, ",var07 = ", var07, ",var08 = ", var08) 64 } 65 66 /** 67 变量 68 */ 69 func main() { 70 fmt.Println("全局变量声明方式一 -> var10 = ", var10, ",var11 = ", var11, ",var12 = ", var12) 71 72 fmt.Println("全局变量声明方式二 -> var20 = ", var20, ",var21 = ", var21, ",var22 = ", var22) 73 74 defineSingleLocalVar() 75 defineMultiLocalVar() 76 }
3、变量使用注意事项
1、声明的变量不赋值,变量使用默认值;
2、变量在同一作用域(在一个函数或者代码)内不能重名
3、关键字 var 与 := 不能一起使用
三、数据类型
Go中的数据类型整体分为两大类型:基本数据类型、复杂数据类型。详情如下:
先介绍Go中的基本数据类型,复杂数据类型后面再做详细描述。
1、整型
整型,也被称为整数型。分为有符号整数、无符号整数。有符号整数:int8 [-2^7, (2^7) - 1]、int16、int32、int64。无符号整数:uint8[0, 2^7 - 1]、uint16、uint32、uint64。
Go语言中,不指定整型类型,默认为int类型,默认值为0,占8字节。验证代码如下:
1 package main 2 3 import ( 4 "fmt" 5 "unsafe" 6 ) 7 /** 8 变量占用字节的大小和数据类型 9 */ 10 func main() { 11 12 // 整型默认为int型,占8个字节 13 n := 10 14 fmt.Printf("n 的类型 %T ,n占用的字节数是 %d \n", n, unsafe.Sizeof(n)) 15 16 // 默认值为 0 17 var int01 int 18 fmt.Printf("int01 = %v \n", int01) 19 20 // 占1字节 21 var n1 int8 = 10 22 fmt.Printf("n1 的类型 %T ,n1占用的字节数是 %d \n", n1, unsafe.Sizeof(n1)) 23 24 // 占2字节 25 var n2 int16 = 10 26 fmt.Printf("n2 的类型 %T ,n2占用的字节数是 %d \n", n2, unsafe.Sizeof(n2)) 27 28 // 占4字节 29 var n3 int32 = 10 30 fmt.Printf("n3 的类型 %T ,n3占用的字节数是 %d \n", n3, unsafe.Sizeof(n3)) 31 32 // 占8字节 33 var n4 int64 = 10 34 fmt.Printf("n4 的类型 %T ,n4占用的字节数是 %d \n", n4, unsafe.Sizeof(n4)) 35 36 // 占1字节 37 var m1 uint8 = 10 38 fmt.Printf("m1 的类型 %T ,m1占用的字节数是 %d \n", m1, unsafe.Sizeof(m1)) 39 40 // 占2字节 41 var m2 uint16 = 10 42 fmt.Printf("m2 的类型 %T ,m2占用的字节数是 %d \n", m2, unsafe.Sizeof(m2)) 43 44 // 占4字节 45 var m3 uint32 = 10 46 fmt.Printf("m3 的类型 %T ,m3占用的字节数是 %d \n", m3, unsafe.Sizeof(m3)) 47 48 // 占8字节 49 var m4 uint64 = 10 50 fmt.Printf("m4 的类型 %T ,m4占用的字节数是 %d \n", m4, unsafe.Sizeof(m4)) 51 }
2、浮点型
浮点型:单精度 - float32、双精度 - float64。验证代码如下:
1 package main 2 3 import ( 4 "fmt" 5 "unsafe" 6 ) 7 8 /** 9 浮点型 10 */ 11 func main() { 12 // 浮点型默认为float型,8个字节 13 float := 3.14159 14 fmt.Printf("float 的类型 %T ,float占用的字节数是 %d \n", float, unsafe.Sizeof(float)) 15 16 // 4字节 17 var float01 float32 = 3.14159 18 fmt.Printf("float01 的类型 %T ,float01占用的字节数是 %d \n", float01, unsafe.Sizeof(float01)) 19 20 // 8字节 21 var float02 float64 = 3.14159 22 fmt.Printf("float02 的类型 %T ,float02占用的字节数是 %d \n", float02, unsafe.Sizeof(float02)) 23 24 // 默认值为 0.000000 25 var float04 float64 26 fmt.Printf("float04 = %f \n", float04) 27 }
Go语言中不指定浮点型类型,默认为float64类型,默认值为0.000000,占8个字节,float64位精度比float32精度的要准确。
3、布尔型
布尔型只有两个值:true 和 false。布尔型的默认值为false,占1个字节。常用在条件控制语句、逻辑表达式中。验证代码如下:
1 package main 2 3 import ( 4 "fmt" 5 "unsafe" 6 ) 7 8 /** 9 布尔数据类型 10 */ 11 func main() { 12 // 默认值为false 13 var bool01 bool 14 fmt.Printf("bool01: %v \n", bool01) 15 16 // 占 1 字节 17 bool02 := false 18 fmt.Printf("bool02: %v %T %d\n", bool02, bool02, unsafe.Sizeof(bool02)) 19 20 // 条件控制语句、逻辑表达式 21 count := 10 22 r := count >= 18 23 if r { 24 fmt.Println("===== 已成年 =====") 25 }else { 26 fmt.Println("===== 未成年 =====") 27 } 28 29 // 循环语句 30 for i := 0; i < count; i++ { 31 if i == count - 1 { 32 fmt.Printf("i = %v \n", i) 33 }else { 34 fmt.Printf("i = %v ", i) 35 } 36 } 37 }
4、byte类型
Go语言中,byte默认值为0,占用1个字节。byte与uint8等价,当要存储字符时,建议选用byte。验证代码如下:
1 package main 2 3 import ( 4 "fmt" 5 "unsafe" 6 ) 7 8 func main() { 9 // byte 默认值是 0 , 占用1个字节 10 var b byte 11 fmt.Printf("b 默认值 %v ,b占用的字节数是 %d \n", b, unsafe.Sizeof(b)) 12 13 // byte 类型不可以用类型推导,默认int类型 14 b01 := 1 15 fmt.Printf("b01 默认值 %T ,b01占用的字节数是 %d \n", b01, unsafe.Sizeof(b01)) 16 17 // 两个byte相加,类型变为uint8,可得出结论byte与uint8等价,当要存储字符时,建议byte 18 var b02 byte 19 b02 = 3 20 var b03 byte 21 b03 = b + b02 22 fmt.Printf("b03 默认值 %T ,b03占用的字节数是 %d \n", b03, unsafe.Sizeof(b03)) 23 24 }
5、字符串类型
Go语言中,string类型默认值为 空字符串,占16个字节,可通过双引号、反引号来创建字符串。注意:反引号不支持转义字符。验证代码如下:
1 package main 2 3 import ( 4 "bytes" 5 "fmt" 6 "strings" 7 "unsafe" 8 ) 9 10 // 字符串拼接 11 func stringBond() { 12 var str string = "hello " 13 var str1 = "world!" 14 // 拼接方式一 : + 15 fmt.Println("content: ", str+str1) 16 17 // 拼接方式二:Sprintf 18 content1 := fmt.Sprintf("%s%s", str, str1) 19 fmt.Printf("content1: %v\n", content1) 20 21 // 拼接方式三 : 数组 + join函数 22 content2 := strings.Join([]string{str, str1}, " ") 23 fmt.Printf("content2: %v\n", content2) 24 25 // 拼接方式四: buf.WriteString 26 var buf bytes.Buffer 27 buf.WriteString("hello") 28 buf.WriteString(" ") 29 buf.WriteString("world!") 30 fmt.Printf("buf: %v\n", buf.String()) 31 } 32 33 // 字符串截取 34 func stringCutout() { 35 str := "yfghchafydsaduaigdaiugkauekagdjasdyadiadhjaf" 36 start := 6 37 end := 14 38 39 // 获取字符串索引位置为start的原始字节 40 fmt.Println(str[start]) 41 // 获取字符串索引位置从 start 到 end - 1 的字符串 42 fmt.Println(str[start:end]) 43 // 获取字符串索引位置从 start 到 len(s) - 1 的字符串 44 fmt.Println(str[start:]) 45 // 获取字符串索引位置从 0 到 end - 1 的字符串 46 fmt.Println(str[:end]) 47 } 48 49 // 热点方法 50 func hotMethod() { 51 str := "hello world" 52 // 字符串长度 53 fmt.Printf("len(str): %v\n", len(str)) 54 // 字符串分割 55 fmt.Printf("strings.Split(str, \" \"): %v\n", strings.Split(str, " ")) 56 // 字符串包含 57 fmt.Printf("strings.Contains(str, \"lo\"): %v\n", strings.Contains(str, "lo")) 58 // 字符串前缀 59 fmt.Printf("strings.HasPrefix(\"he\"): %v\n", strings.HasPrefix(str, "he")) 60 // 字符串后缀 61 fmt.Printf("strings.HasSuffix(\"ld\"): %v\n", strings.HasSuffix(str, "ld")) 62 // 字符串索引 63 fmt.Printf("strings.Index(str, wo): %v\n", strings.Index(str, "wo")) 64 // 字符串字母小写转大写 65 fmt.Printf("strings.ToUpper(str): %v\n", strings.ToUpper(str)) 66 } 67 68 func main() { 69 70 // string类型默认值为 空字符串,占16个字节 71 var str string 72 fmt.Printf("str: %v, %d \n", str, unsafe.Sizeof(str)) 73 74 // 字符串可通过 双引号 、反引号创建,反引号创建的字符串不支持转义字符 75 var str01 = "hello world!\n" 76 var str02 = `hello world!\n` 77 var str03 = "hello world!" 78 fmt.Printf("%v, %v, %v", str01, str02, str03) 79 80 // 拼接 81 stringBond() 82 // 截取 83 stringCutout() 84 // 热点方法 85 hotMethod() 86 }