go语言基础
golang 数据类型
基本数据类型
数值型
整数型（int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64,byte）
浮点型（float32,float64）
字符型（没有单独的字符型，使用byte来保存单个字母字符）
布尔型（bool）
字符串（string）
派生数据类型/复杂数据类型
指针
数组
结构体
管道
函数
切片
接口
map
进制转换
整数类型介绍
简单说，就是用于存放整数值的，比如10，-45等等
有符号整数类型
类型 有无符号 占用存储空间 表示范围
int8 有 1字节 -2^7~2^7-1(-128~127)
int16 有 2字节 -2^15~2^15-1（-32768~32767）
int32 有 4字节 -2^31~2^31-1（-2147483648~2147483647）
int64 有 8字节 -2^63~2^63-1
ps 一个字节8位 第一位符号位 01111111 127
有符号整数类型
类型 有无符号 占用存储空间 表示范围
uint8 无 1字节 0~255
uint16 无 2字节 0~2^16-1
uint32 无 4字节 0~2^31-1
uint64 无 8字节 0~2^63-1
其他整数
类型 有无符号 占用存储空间 表示范围
int 有 32位系统4个字节/64位系统8字节 -2^31~2^31-1 -2^63~2^63-1
uint 无 32位系统4个字节/64位系统8字节 0~2^31-1 0~2^63-1
rune 有 等价int32 0~2^63-1
byte 无 等价uint8 0~255
golang 整数类型默认声明int 型
测试
package main
import (
"fmt"
"unsafe"
)
func main(){
//定义一个整型
var num1 int8 = 23
fmt.Println(num1)
/*
D:\golang>go run D:\golang\goproject\src\src01\demo3\main01.go
# command-line-arguments
goproject\src\src01\demo3\main01.go:5:18: cannot use 230 (untyped int constant) as int8 value in variable declaration (overflows)
*/
var num3 = 28
//printf 函数作用就是格式化
/*
%v 值的默认格式表示
%+v 类似%v，但输出结构体时会添加字段名
%#v 值的Go语法表示
%T 值的类型的Go语法表示
%% 百分号
*/
fmt.Printf("num3的类型：%T", num3)
fmt.Println()
fmt.Println(unsafe.Sizeof(num3))//unsafe 导包。显示字节数
}
执行结果
D:\golang>go run D:\golang\goproject\src\src01\demo3\main01.go 23 num3的类型：int 8
浮点类型
简单说就是用于存放小数值的，比如3.14、0、28
浮点类型种类
类型 存储字节 表示范围
flaot32 4字节 -3.403E38~3.403E38
flaot64 8字节 -1.798E38~1.798E308
底层存储空间与操作系统无关；浮点类型底层存储 符号位+ 指数位+尾数位。尾数位只是存储大概，可能会出现精度损失
测试
package main
import "fmt"
func main(){
//定义浮点类型
var num1 float32 = 3.14
fmt.Println(num1)
//正数负数都可以
var num2 float32 = -3.14
fmt.Println(num2)
//浮点数可以用十进制表示，也可以用科学计数法表示，E大小写都可以
var num3 float32 = 314E-2
fmt.Println(num3)
var num4 float32 = 314E+2
fmt.Println(num4)
var num5 float32 = 314e+2
fmt.Println(num5)
var num6 float32 = 314e+2
fmt.Println(num6)
//浮点数可能会有精度损失，建议使用float64
var num7 float32 = 256.000000916
fmt.Println(num7)
var num8 float64 = 256.000000916
fmt.Println(num8)
//golang里默认的浮点类型为float64
cx := 3.17
fmt.Printf("cx 对应的数据类型:%T",cx)
/* 3.14
-3.14
3.14
31400
31400
31400
256
256.000000916
cx 对应的数据类型:float64 */
}
执行结果
3.14 -3.14 3.14 31400 31400 31400 256 256.000000916 cx 对应的数据类型:float64
字符类型
package main
import "fmt"
func main(){
var c1 byte = 'a'
fmt.Println(c1) //定义字符类型的数据
var c2 byte = '6'
fmt.Println(c2)
var c3 byte = '('
fmt.Println(c3)
//字符类型本质上就是整数，也可以参与运算。输出时，会将对应的码值做一个输出
//字符等是按照ASCII 码表
var c4 int = '中' //汉字字符对应的码值，底层对应的是Unicode码值，对应的码值为20013，byte类型溢出，能存储范围：可以用int
fmt.Println(c4) //总结 golang的字符对应使用的是UTF-8编码
var c5 byte = 'A'
fmt.Printf("c5对应的具体字符：%c",c5)
}
执行结果
PS D:\golang\goproject> go run src\src01\demo5\main.go # command-line-arguments src\src01\demo5\main.go:12:16: cannot use '中' (untyped rune constant 20013) as byte value in variable declaration (overflows) PS D:\golang\goproject> go run src\src01\demo5\main.go 97 54 40 20013 c5对应的具体字符：A
转义字符: 将后面字符表示特殊含义
转义字符 含义 unicode值
\b 退格 \u0008
\n 换行 \u000a
\r 回车 \u000d
\t 制表符 \u0009
\" 双引号 \u0022
\' 单引号 \u0027
\\ 反斜杠 \u005c
测试
package main
import "fmt"
func main(){
//连续转义字符
fmt.Println("aaaaaaa\nbbbbbbbbb")
//\b 退格
fmt.Println("aaaaaaaaaaa\bbbbbbbbbb")
//\r 回车 bbbbbbbbbaa
fmt.Println("aaaaaaaaaaa\rbbbbbbbbb")
//\t
fmt.Println("aaaaaaaaaaa\tbbbbbbbbb")
fmt.Println("aaaaaaaaa\tbbbbbbbbb")
}
执行
PS D:\golang\goproject> go run src\src01\demo6\mian.go aaaaaaa bbbbbbbbb aaaaaaaaaabbbbbbbbb bbbbbbbbbaa aaaaaaaaaaa bbbbbbbbb aaaaaaaaa bbbbbbbbb
布尔类型
布尔类型也叫bool类型，bool类型数据只允许取值true和false
布尔类型只占一个字节
布尔类型适于逻辑运算，一般用于流程控制
测试
package main
import "fmt"
func main() {
var flag01 bool = true
fmt.Println (flag01)
var flag02 bool = 5> 9
fmt.Println(flag02)
}
执行
PS D:\golang\goproject\src\src01> go run demo7\mian.go true false
字符串
package main
import "fmt"
func main(){
//定义
var s1 string = "你好我是亚马逊"
fmt.Println(s1)
//字符串是不可变的
var s2 string = "abc"
//s2[0] = 't'
fmt.Println(s2)
/* # command-line-arguments
demo8\mian.go:9:2: cannot assign to s2[0] (neither addressable nor a map index expression) */
//字符串的表示形式,如果字符串没有特殊字符，字符串表示形式用双引号
var s3 string = "as"
//如果字符串有特殊字符，字符串表示形式用反引号
var s4 string = `
package main //声明包，每个go文件必须有归属包
import "fmt" //导入工具包，使用
func main(){ // main 主函数
fmt.Println("你好")// 打印输出内容
var age = 10 +9
fmt.Println(age)
fmt.Println("qqqqqqqqqq",
"qqqqqqqqqqqq",
"qqqqqqqqqqqq",
"qqqqqqqqqqqq",
"qqqqqqqqqqqqq")
}
`
fmt.Println(s3)
fmt.Println()
fmt.Println(s4)
//字符串拼接
var s5 string = "abc" + "def"
s5 += "hijk"
fmt.Println(s5)
fmt.Println()
//当一个字符串拼接过长 注意+ 保留在上一行最后
var s6 string = "cx" + "xx" +
"ff" + "qq" +
"cd"
fmt.Println(s6)
}
执行结果
PS D:\golang\goproject\src\src01> go run demo8\mian.go
你好我是亚马逊
abc
as
package main //声明包，每个go文件必须有归属包
import "fmt" //导入工具包，使用
func main(){ // main 主函数
fmt.Println("你好")// 打印输出内容
var age = 10 +9
fmt.Println(age)
fmt.Println("qqqqqqqqqq",
"qqqqqqqqqqqq",
"qqqqqqqqqqqq",
"qqqqqqqqqqqq",
"qqqqqqqqqqqqq")
}
abcdefhijk
cxxxffqqcd
PS D:\golang\goproject\src\src01> go run demo8\mian.go
你好我是亚马逊
abc
as
package main //声明包，每个go文件必须有归属包
import "fmt" //导入工具包，使用
func main(){ // main 主函数
fmt.Println("你好")// 打印输出内容
var age = 10 +9
fmt.Println(age)
fmt.Println("qqqqqqqqqq",
"qqqqqqqqqqqq",
"qqqqqqqqqqqq",
"qqqqqqqqqqqq",
"qqqqqqqqqqqqq")
}
abcdefhijk
cxxxffqqcd
基本数据类型默认值
package main
import "fmt"
func main(){
var a int
var b float32
var c float64
var d bool
var e string
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(e)
}
执行结构
C:\Users\尘曦>go run D:\golang\goproject\src\src01\demo9\main.go
0
0
0
false
类型转换
1.go 在不同类型的变量之间赋值时需要显示转换，并且只有显示转换
语法
表达式T (V) 将V值转换为类型T
T : 就是数据转换类型
V : 就是需要转换变量
数值类型间转换
package main
import "fmt"
func main(){
//类型转换
var n1 int = 100
//var n2 float32 = n1//错误写法
//报错
//# command-line-arguments
//demo10\main.go:6:19: cannot use n1 (variable of type int) as float32 value in variable declarat
var n2 float32 = float32(n1) //正确写法
//执行结果
//PS D:\golang\goproject\src\src01> go run demo10\main.go
//100
fmt.Println(n2)
var n3 int64 = 888888
fmt.Println(n3)
var n4 int8 = int8(n3)//int64转为int8的时候编译不会出错的，但是会有数据的溢出
fmt.Println(n4)// 56
var n5 int32 = 12
//var n6 int64 = n5+30 //错误写法 = 左右数据类型
var n6 int64 = int64(n5)+30
fmt.Println(n6)
var n7 int64 = 12
var n8 int8 = int8(n7) + 127 //编译通过，结果可能会溢出；-117
//var n9 int8 = int8(n7) + 128 //编译不过溢出；demo10\main.go:25:27: 128 (untyped int constant) overflows int8
fmt.Println(n8)
//fmt.Println(n9)
}
执行结果
PS D:\golang\goproject\src\src01> go run demo10\main.go
100
888888
56
42
-117
字符串转换
基本数据类型和string 类型转换
在程序开发中，经常需要将基本数据类型转成string类型。或者将string类型转成基本数据类型
基本数据转string类型
方式
fmt.Sprintf("%参数",表达式)
package main
import "fmt"
func main(){
var n1 int = 19
var n2 float32 = 4.78
var n3 bool = false
var n4 byte = 'a'
var s1 string = fmt.Sprintf("%d",n1)// 整数：
/*
%b 表示为二进制
%c 该值对应的unicode码值
%d 表示为十进制
%o 表示为八进制
%q 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
%x 表示为十六进制，使用a-f
%X 表示为十六进制，使用A-F
%U 表示为Unicode格式：U+1234，等价于"U+%04X" */
fmt.Printf("s1对应类型是：%T, s1 = %v\n",s1 ,s1)//%v 值的默认格式表示;%T 值的类型的Go语法表示
var s2 string = fmt.Sprintf("%f",n2)//%f 有小数部分但无指数部分，如123.456
fmt.Printf("s2对应类型是：%T, s2 = %v\n",s2 ,s2)
var s16 string = fmt.Sprintf("%f",n2)//%f 有小数部分但无指数部分，如123.456
fmt.Printf("s16对应类型是：%T, s16 = %q\n",s16 ,s16)
var s3 string = fmt.Sprintf("%t",n3)//布尔值： %t 单词true或false
fmt.Printf("s3对应类型是：%T, s3 = %v\n",s3 ,s3)
var s4 string = fmt.Sprintf("%c",n4)//%c 该值对应的unicode码值
fmt.Printf("s4对应类型是：%T, s4 = %v\n",s4 ,s4)
}
/*
执行结果
PS D:\golang\goproject\src\src01> go run demo11\main.go
s1对应类型是：string, s1 = 19
s2对应类型是：string, s2 = 4.780000
s16对应类型是：string, s16 = "4.780000"
s3对应类型是：string, s3 = false
s4对应类型是：string, s4 = a
*/
方式2
使用strconv 包的函数
package main
import (
"fmt"
"strconv"
)
func main() {
var n1 int = 10
var s1 string = strconv.FormatInt(int64(n1),10)//参数。第一个参数必须转为int64类型，第二个参数指定字面值得进制形式为10 进制
fmt.Printf("s1对应类型是：%T, s1 = %v\n",s1 ,s1)
var n2 float32 = 4.78
var s2 string = strconv.FormatFloat(float64(n2),'f',9,32)//'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制）、'e'（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、'g'（指数很大时用'e'格式，否则'f'格式）、'G'（指数很大时用'E'格式，否则'f'格式）。控制精度（排除指数部分）;32表示给的小数类型
fmt.Printf("s2对应类型是：%T, s2 = %v\n",s2 ,s2)
var n3 bool = false
var s3 string = strconv.FormatBool(n3)
fmt.Printf("s3对应类型是：%T, s3 = %v\n",s3 ,s3)
// var n4 byte = 'a'
}
执行结果
PS D:\golang\goproject\src\src01> go run demo12\main.go
s1对应类型是：string, s1 = 10
s2对应类型是：string, s2 = 4.780000210
s3对应类型是：string, s3 = false
string 类型转基本数据类型
package main
import (
"fmt"
"strconv"
)
func main () {
//string ----> bool
var s1 string = "string"
var b bool
b,_ = strconv.ParseBool(s1)// 返回两个值
fmt.Printf("b的类型是：%T,b=%v\n",b,b)
var s2 string = "98"
var n1 int64
n1,_ = strconv.ParseInt(s2,10,64)//参数s2 表示字符串，10表示10进制，64表示转成的int64进制；指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64
fmt.Printf("n1的类型是：%T,b=%v\n",n1,n1)
var s3 string = "3.14"
var n3 float64
n3,_=strconv.ParseFloat(s3,64)//参数s3 表示字符串，64表示转为float64 ,指定了期望的接收类型，32是float32（返回值可以不改变精确值的赋值给float32），64是float64；返回值err是*NumErr类型的，语法有误的，err.Error=ErrSyntax；结果超出表示范围的，返回值f为±Inf，err.Error= ErrRange。
fmt.Printf("n3的类型是：%T,b=%v\n",n3,n3)
//注意，string向基本数据类型转换的时候一定要确保string类型一定要确保能够转成有效的基本数据类型，否则最后结果是对应类型的默认值
var s11 string = "golang"
var b1 bool
b1,_ = strconv.ParseBool(s11)
fmt.Printf("b1的类型是：%T,b=%v\n",b1,b1)
}
/*
执行结果
PS D:\golang\goproject\src\src01> go run demo13\mian.go
b的类型是：bool,b=false
n1的类型是：int64,b=98
n3的类型是：float64,b=3.14
b1的类型是：bool,b=false
*/
复杂数据类型指针
指针
基本数据类型和内存
C:\Users\尘曦>go run D:\golang\goproject\src\src01\demo14\main.go
0xc00000a0c8
指针变量
指针等于内存地址
总结
& 取内存结构
* 根据内存地址找到对应的值
package main
import (
"fmt"
)
func main(){
var age int = 18
//& + 变量就可以获取这个变量内存地址
fmt.Println(&age)//打印age 的内存地址
//执行结果
//C:\Users\尘曦>go run D:\golang\goproject\src\src01\demo14\main.go
//0xc00000a0c8
//定义一个指针变量
//var 代表声明一个变量
//ptr 指针变量的名字
//ptr 对应的类型是*int是一个指针类型（指向int类型的指针）
//&age 就是一个地址，是ptr变量具体的值
var ptr *int = &age
fmt.Println(ptr)
fmt.Println("ptr内存地址为:", &ptr)
//获取ptr这个指针指向的变量值
fmt.Println("ptr指向的数值为：",*ptr)
/*执行结果
C:\Users\尘曦>go run D:\golang\goproject\src\src01\demo14\main.go
0xc00000a0c8
0xc00000a0c8
ptr内存地址为: 0xc000052030
ptr指向的数值为： 18
*/
}
指针细节
通过指针修改变量的值
指针变量接收的一定是地址
指针变量的地址不可以跟变量类型不匹配
基本数据类型叫值类型，都有对应的指针类型，形式为*数据类型
测试
package main
import "fmt"
func main(){
var num int = 10
fmt.Println(num)
var ptr *int = &num
*ptr =20//通过指针修改变量的值
fmt.Println(num)
//指针变量接收的一定是地址
/* var ptr1 *int = num
执行结果
D:\golang\goproject\src\src01\demo15\main.go:10:19: cannot use num (variable of type int) as *int value in variable declaration
*/
/* 指针变量的地址不可以跟变量类型不匹配
var ptr1 *float32 = &num
fmt.Println(*ptr1)
执行结果
D:\golang\goproject\src\src01\demo15\main.go:14:22: cannot use &num (value of type *int) as *float32 value in variable declaration
*/
}
执行结果
C:\Users\尘曦>go run D:\golang\goproject\src\src01\demo15\main.go
10
20
标志符
标志符
标志符
变量，方法等，只要是其名字的地方，哪个名字就是标志符
标志符的定义规则
三个（组成部分），数字，字母，下划线；可以使用字符，但不建议
四个注意：不可以以数字开头要，严格区分大小写，不能包含空格，不可以使用go 语言的保留关键字
见名之意：增加可读性
下划线在go 语言是一个特殊符号，称为空标识符。可以代表任何其他的标识符，但是它对应的值会被忽略，所以仅能被作为占位符使用，不能单独使用
可以用如下，但是不建议 var int int = 90 （关键字不算保留字，但是也不建议使用）
长度无限制，但太长不建议
关键字
关键字就是程序员发明者规定的有特殊含义的单词，又叫保留字；go 里面一共有25个保留字
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
预定义标识符
append bool byte cap close complex
complex64 complex128 uint16 copy false float32
float64 imag int int8 int16 uint32
int32 int64 iota len make new
nil panic uint64 print println real
recover string true uint uint8 uintprt
草都可以从石头缝隙中长出来更可况你呢
浙公网安备 33010602011771号