03【保姆级】-GO语言变量和数据类型
- 一、变量
-
- [1.1 变量的定义:](#1.1 变量的定义:)
- [1.2 变量的声明、初始化、赋值](#1.2 变量的声明、初始化、赋值)
- [1.3 变量使用的注意事项](#1.3 变量使用的注意事项)
- 插播-关于fmt.Printf格式打印%的作用
- [二、 变量的数据类型](#二、 变量的数据类型)
-
- 2.1整数的基本类型
-
- [2.1.1 有符号类型 int8/16/32/64](#2.1.1 有符号类型 int8/16/32/64)
- [2.1.2 无符号类型 int8/16/32/64](#2.1.2 无符号类型 int8/16/32/64)
- [2.1.3 整型类型 int、uint、rune、byte](#2.1.3 整型类型 int、uint、rune、byte)
- [2.1.4 整型的使用细节](#2.1.4 整型的使用细节)
- [2.2 浮点类型](#2.2 浮点类型)
-
- [2.2.1 小数类型分类](#2.2.1 小数类型分类)
- [2.3 字符类型](#2.3 字符类型)
-
- [2.3.1 基本介绍](#2.3.1 基本介绍)
- [2.3.2 字符使用细节](#2.3.2 字符使用细节)
- [2.4 布尔类型](#2.4 布尔类型)
-
- [2.4.1 基本概述](#2.4.1 基本概述)
- [2.5 String类型](#2.5 String类型)
-
- [2.5.1 基本概述](#2.5.1 基本概述)
- [2.5.2 String使用注意事项和细节](#2.5.2 String使用注意事项和细节)
- [2.6 基本数据类型的默认值](#2.6 基本数据类型的默认值)
- [2.7 基本数据类型的相互转换](#2.7 基本数据类型的相互转换)
- [2.8 转换的细节(重要)](#2.8 转换的细节(重要))
- [2.9 基本数据类型转String(重要)](#2.9 基本数据类型转String(重要))
-
- [2.9.1 fmt.Sprintf("%参数", 变量名)](#2.9.1 fmt.Sprintf("%参数", 变量名))
- [2.9.2 使用strconv包的函数](#2.9.2 使用strconv包的函数)
- [2.10 String类型转为基本类型](#2.10 String类型转为基本类型)
-
- [2.10.1 使用strconv包的函数](#2.10.1 使用strconv包的函数)
之前我学过C、Java、Python语言时总结的经验:
- 先建立整体框架,然后再去抠细节。
- 先Know how,然后know why。
- 先做出来,然后再去一点点研究,才会事半功倍。
- 适当的囫囵吞枣。因为死抠某个知识点很浪费时间的。
- 对于GO语言,切记遵守语法格式规则。(例如python语言、例如SpringBoot框架等)
解释:某些知识点,就是很难了解,那么先做出来,然后继续向前学习,可能在某个时间点我们就会恍然大悟。
一、变量
1.1 变量的定义:
- 任何高级程序语言写程序,变量都是程序的基本组成单位。
- 变量相当于内存中一个数据存储空间的表示,你可以把变量看做是一个房间的门牌号,通过门牌号我们可以找到房间,同样的道理,通过变量名可以访问到变量()
1.2 变量的声明、初始化、赋值
- 声明变量(定义变量)
基本语法: var 变量名 数据类型
var a int
- 变量赋值
在声明变量的时候,就给值
var a int = 1
var b = 300
- 使用变量
var a int
a = 100
例如下面的a/b/c都是变量
go
package main
import "fmt"
func main() {
var a int //声明变量
a = 10 //变量赋值
b := 20 //变量赋值
c := a + b //使用变量
fmt.Println(a) // 10
fmt.Println(b) // 20
fmt.Println(c) // 30
}
1.3 变量使用的注意事项
- 变量表示内存中的一个存储区域
- 该区域有自己的名称(变量名)和类型(数据类型)
所有代码会用磁盘中读取到内存中,进行运行。
那么变量,例如a = 10 。那么就会存储到内存中。
-
Golang变量使用的三种方式
- 第一种:指定变量类型,声明后若不赋值,使用默认值。
int类型默认为0
String类型默认为空
- 第二种:根据值自行判定变量类型(类型推导)
如果不指定类型,那么就会go语言类型推导。
var a = "abc" 在打印的时候就会输出string类型
- 第三种省略var,注意:=左侧的变量不应该是已经声明过的,否则会导致编译错误
两种方式:(方式一的两句话,等价于方式二)
> var name1 string
name1 = "zhangsan1" //方式一
name2 := "zhangsan2" //方式二
-
多变量声明
在编程中,有时我们需要一次性声明多个变量,Golang也提供这样的语法
go
形式一:
var a, a1, a2, a3 int
a = 10
a1 = 20
a2 = 30
a3 = 40
形式二:
var a1, a2, a3, name = 1, 2, 3, "zhangsan"
fmt.Println(a1,a12,a23,a4)
形式三:
a, b, c, d, name := 1, 2, 3, 4, "zhangsan"
fmt.Println(a,b,c,d,name)
关于全局变量:
go
var (
a = 1
b = 2
c = 3
d = 4
name = "zhangsan"
)
func main() {
fmt.Println(a, b, c, d, name)
}
- 该区域的数据值可以在同一类型范围内不断变化
- 变量在同一个作用域内不能重名
- 变量=变量名+值+数据类型,这一点请大家注意。
- Golang的变量如果没有赋初值,编译器会使用默认值,比如int默认值0 string默认值为空用
插播-关于fmt.Printf格式打印%的作用
参考的官网地址是:https://studygolang.com/pkgdoc
go
通用:
%v 值的默认格式表示
%+v 类似%v,但输出结构体时会添加字段名
%#v 值的Go语法表示
%T 值的类型的Go语法表示
%% 百分号
布尔值:
%t 单词true或false
整数:
%b 表示为二进制
%c 该值对应的unicode码值
%d 表示为十进制
%o 表示为八进制
%q 该值对应的单引号括起来的go语法字符字面值,必要时会采用安全的转义表示
%x 表示为十六进制,使用a-f
%X 表示为十六进制,使用A-F
%U 表示为Unicode格式:U+1234,等价于"U+%04X"
浮点数与复数的两个组分:
%b 无小数部分、二进制指数的科学计数法,如-123456p-78;参见strconv.FormatFloat
%e 科学计数法,如-1234.456e+78
%E 科学计数法,如-1234.456E+78
%f 有小数部分但无指数部分,如123.456
%F 等价于%f
%g 根据实际情况采用%e或%f格式(以获得更简洁、准确的输出)
%G 根据实际情况采用%E或%F格式(以获得更简洁、准确的输出)
字符串和[]byte:
%s 直接输出字符串或者[]byte
%q 该值对应的双引号括起来的go语法字符串字面值,必要时会采用安全的转义表示
%x 每个字节用两字符十六进制数表示(使用a-f)
%X 每个字节用两字符十六进制数表示(使用A-F)
指针:
%p 表示为十六进制,并加上前导的0x
二、 变量的数据类型
2.1整数的基本类型
简单的说,就是用于存放整数值的,比如 0,-1,2345 等等。
2.1.1 有符号类型 int8/16/32/64
** int8 范围是:-128 ~ 127**
2.1.2 无符号类型 int8/16/32/64
int 无符号类型:
2.1.3 整型类型 int、uint、rune、byte
2.1.4 整型的使用细节
- Golang 各整数类型分: 有符号和无符号,int uint 的大小和系统有关
- Golang 的整型默认声明为 int 型
- 如何在程序查看某个变量的字节大小和数据类型
go
import (
"fmt"
unsafe "unsafe"
)
var n1 = 100
fmt.Printf("n1 的类型是 %T ", n1) //n1 的类型是 int
var n2 int64 = 1
fmt.Printf("n1 的数据类型是 %T, n2 占用的字节数是%d", n2, unsafe.Sizeof(n2))
// n1 的数据类型是 int64, n2 占用的字节数是8
- olang 程序中整型变量在使用时,遵守保小不保大的原则,即:在保证程序正确运行下,尽量使用占用空间小的数据类型。[如: 年龄]
- bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。[二进制再详细说] 1byte = 8 bit
2.2 浮点类型
Golang的浮点类型可以表示一个小数,比如1.2 / 3333.11 / 3232.324等等
2.2.1 小数类型分类
- 关于浮点数在机器中存放形式的简单说明.浮点数=符号位+指数位+尾数位说明: 浮点数都是有符号的.
- 如果使用float32 可能造成精度损失。
开发过程中,推荐使用float64。 并且默认也是float64 .
Golang浮点类型有固定的范围和字段类型,不受具体操作系统的影响。
- 浮点型的存储分为三个部分:符号位+指数位+尾数位。 在存储过程中,精度会有丢失
2.3 字符类型
2.3.1 基本介绍
Golang 中没有专门的字符类型,如果要存储单个字符(字母),一般使用 byte 来保存。
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的,而 Go 的字符串不同,它是由字节组成的。
- 如果我们保存的字符在 ASCII 表的,比如[0-1,a-z,A-Z.]直接可以保存到 byte2)
- 如果我们保存的字符对应码值大于 255,这时我们可以考虑使用 int 类型保存3)
- 如果我们需要安装字符的方式输出,这时我们需要格式化输出,即 fmt.Printfr"%c",cl)...
go
var n2 int = '你'
fmt.Printf("n2 的数据类型是 %T, n2 占用的字节数是%d. \n", n2, unsafe.Sizeof(n2))
// n2 的数据类型是 int, n2 占用的字节数是8.
var c3 int = '你'
fmt.Printf("c3 = %c \n", c3) //c3 = 你
fmt.Printf("%c", c3) //你
2.3.2 字符使用细节
- 字符型 存储到 计算机中,需要将字符对应的码值 (整数) 找出来存储:字符--->对应码值---->二进制-->存储
读取:二进制----> 码值 ----> 字符 -> 读取 - 字符和码值的对应关系是通过字符编码表决定的(是规定好)
- Go 语言的编码都统一成了 utf-8。非常的方便,很统一,再也没有编码乱码的困扰了
2.4 布尔类型
2.4.1 基本概述
- 布尔类型也叫 bool类型,bool 类型数据只允许取值 true 和 false
- bool类型占1 个字节。
- bool 类型适于逻辑运算,一般用于程序流程控制
go
seg := true
fmt.Printf("%T \n", seg) //bool
fmt.Println("seg=", seg) //seg= true
if seg {
fmt.Println("如果是true, 我就打印")
} else {
fmt.Println("如果是false, 我就打印")
}
2.5 String类型
2.5.1 基本概述
字符串就是一串固定长度的字符 连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
go
var name string = "今年张三,英文ZhangSan,23岁了。"
fmt.Println(name)
2.5.2 String使用注意事项和细节
- Go语言的字符串的字节使用UTF-8编码标识Unicode文本,这样Golang统一使用Utf-8编码,中文乱码就不会出现了。
- 字符串一旦赋值后,字符串就不能单个字符修改了。在Go中字符串是不可变的。
go
var str = "hello"
str[0] = 'b' //这里就会报错了。字符串单个字符是不可变的。
可以直接从新赋值:
str ="word"
-
字符串的两种表示方式
-
双引号,会识别转义字符
-
反引号,以字符串的原生形式输出,包括换行和特殊字符,可以实现防止攻击、输出源代码等效果。
-
字符串拼接方式
go
str := "hello "
name := "zhangsan"
strName := str + name
fmt.Println(strName) //hello zhangsan
- 当一行字符串太长时,需要使用多行字符串,可以用"" + 进行绑定。 重点是:+ 号必须保持在上一行中。
go
str := "lisi " + "wangwu " + " zhaoliu " + " a" +
" b" + "c " +
"D"
fmt.Println(str) //lisi wangwu zhaoliu a bc D
2.6 基本数据类型的默认值
在Go中,数据类型都有一个默认值,当没有赋值时,就会保留默认值,在Go中,默认值又叫"零值"
2.7 基本数据类型的相互转换
Golang和java、C不同,在Go语言中,不同类型的变量之间赋值时需要显式转换 。 也就是说Golang中数据类型不能自动转换。
基本语法:
- 表达式T(v) 将值 v 转换为类型T
- T:就是数据类型,比如:int32 , int64 ,float32, float64等
- V:就是需要转换的变量
go
var n1 int = 100
var n2 float64 = float64(n1)
n2 += 0.905
var n3 int = int(n2)
fmt.Printf("n1=%v, n2=%v, n3=%v", n1, n2, n3)
// n1=100, n2=100.905, n3=100
2.8 转换的细节(重要)
- 在Go中,数据类型的转换可以是从 小范围 转换到 大范围。也可以从 大范围 转换成 小范围。
- 被转换的是变量存储的数据(既值) ,变量本身的数据类型并没有变化。
例如:
我们将 n1 float =1.23 转换成 n2 int = 100
那么分别打印 n1 =1.23. 打印n2 =100
var n1 float64 = 1.23
var n2 int = int(n1)
fmt.Printf("n1=%v, n2=%v", n1, n2)
// 打印结果:n1=1.23, n2=1
- 在转换结果中,比如将Int64转换成int8 ,编译时不会报错 ,只是转换的结果是按溢出处理,和我们希望的结果不一样。
go
var n1 int64 = 999999
var n2 int8 = int8(n1)
fmt.Printf("n1=%v, n2=%v", n1, n2)
// n1=999999, n2=63
2.9 基本数据类型转String(重要)
在程序开发中,我们经常需要将基本数据类型转成String类型。
或者String类型转换成基本数据类型。
2.9.1 fmt.Sprintf("%参数", 变量名)
方式一: fmt.Sprintf("%参数", 表达式)
- 参数需要和表达式的数据类型相匹配
- fmt.Sprintf() 会返回转换后的字符串
go
package main
import "fmt"
func main() {
var n1 int = 123
var n2 float64 = 1.23
var n3 byte = 'a'
var n4 bool = true
var str string
// %T 的意思是:该变量的类型
// %q 的意思是:打印变量的类型,并且用双引号,引起来。
str = fmt.Sprintf("%d", n1)
fmt.Printf("str的类型是:%T, Str等于%q\n", str, str)
str = fmt.Sprintf("%f", n2)
fmt.Printf("str的类型是%T,str等于:%q \n", str, str)
str = fmt.Sprintf("%c", n3)
fmt.Printf("str的类型是:%T,str等于%q \n", str, str)
str = fmt.Sprintf("%t", n4)
fmt.Printf("str的类型是%T,str等于%q \n", str, str)
}
str的类型是string, Str等于"123"
str的类型是string, str等于:"1.230000"
str的类型是:string str等于"a"
str的类型是string, str等于"true"
2.9.2 使用strconv包的函数
方式二:使用strconv包的函数
-
func FomatBool(b lool) String
-
func FomatInt(i int64, base int ) String
go
var num1 int = 123
var num2 float64 = 1.234
var num3 bool = true
var str string
fmt.Printf("num1的类型是:%T \n", num1)
str = strconv.FormatInt(int64(num1), 10)
fmt.Printf("str的类型是:%T,str的值是:%q \n", str, str)
//要转换的变量,
//'f':格式是:ddd.dddd。 一般使用的比较多
//精度(小数点后面几位),该float的位数,例如64/32
str = strconv.FormatFloat(num2, 'f', 2, 64)
fmt.Printf("str的类型是:%T,str的值是%q \n", str, str)
str = strconv.FormatBool(num3)
fmt.Sprintf("str的类型是:%T,str的值是%q", str, str)
num1的类型是:int
str的类型是:string,str的值是:"123"
str的类型是:string,str的值是"1.23"
Itoa 将int类型转为String类型:
var num1 int = 100
var str string = strconv.Itoa(num1)
fmt.Printf(str)
关于strconv.FormatFloat的参数说明:
2.10 String类型转为基本类型
2.10.1 使用strconv包的函数
func ParseBool
func ParseBool(str string) (value bool, err error)
返回字符串表示的bool值。它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE;否则返回错误。
go
var str string = "true"
var err error
var b bool
b, err = strconv.ParseBool(str)
fmt.Printf("b的类型是 %T,b的值是%v,b的错误结果是:%v \n", b, b, err)
func ParseInt
func ParseInt(s string, base int, bitSize int) (i int64, err error)
返回字符串表示的整数值,接受正负号。
base指定进制(2到36),如果base为0,则会从字符串前置判断,"0x"是16进制,"0"是8进制,否则是10进制;
bitSize指定结果必须能无溢出赋值的整数类型,0、8、16、32、64 分别代表 int、int8、int16、int32、int64;返回的err是*NumErr类型的,如果语法有误,err.Error = ErrSyntax;如果结果超出类型范围err.Error = ErrRange。
go
var str string = "123"
var i int64
// 要转的字符串,base:转成10进制,bitSize:转成64位
i, _ = strconv.ParseInt(str, 10, 0)
fmt.Printf("i的格式是:%T, i的值是:%v", i, i)
// i的格式是:int64, i的值是:123
- func ParseFloat
func ParseFloat(s string, bitSize int) (f float64, err error)
解析一个表示浮点数的字符串并返回其值。
如果s合乎语法规则,函数会返回最为接近s表示值的一个浮点数(使用IEEE754规范舍入)。bitSize指定了期望的接收类型,32是float32(返回值可以不改变精确值的赋值给float32),64是float64;返回值err是*NumErr类型的,语法有误的,err.Error=ErrSyntax;结果超出表示范围的,返回值f为±Inf,err.Error= ErrRange。
go
var str string = "1.2345"
var f float64
f, _ = strconv.ParseFloat(str, 64)
fmt.Printf("f的类型是%T, f的值是:%v", f, f)
// f的类型是float64, f的值是:1.2345