【Go】变量与数据类型

变量

变量表示内存中的一个存储区域&＃xff0c;该区域有自己的名称&＃xff08;变量名&＃xff09;和类型&＃xff08;数据类型&＃xff09;。

变量声明的方式

1. 指定变量类型。声明后若不赋值&＃xff0c;则使用指定数据类型的默认值

package mainimport "fmt"func main() {var num intfmt.Println("num &＃61;", num)
}

结果&＃xff1a;num &＃61; 0
int数据类型的默认值是0&＃xff0c;其他的稍后介绍

2. 根据初值自行判定变量类型&＃xff08;类型推导&＃xff09;

package mainimport "fmt"func main() {var num &＃61; 10.1fmt.Println("num &＃61;", num)
}

结果&＃xff1a;num &＃61; 10.1

3. 省略var关键字&＃xff0c;用:&＃61;声明并赋初值

package mainimport "fmt"func main() {num :&＃61; 10fmt.Println("num &＃61;", num)
}

结果&＃xff1a;num &＃61; 10

4. 局部多变量声明

package mainimport "fmt"func main() {// 一次声明多个变量var n1, n2, n3 intfmt.Println("n1 &＃61;", n1, "n2 &＃61;", n2, "n3 &＃61;", n3)// 一次声明多个变量并赋初值var a, name, b &＃61; 100, "张三", 300fmt.Println("a &＃61;", a, "name &＃61;", name, "b &＃61;", b)// 简写i, j :&＃61; 10, 20fmt.Println("i &＃61;", i, "j &＃61;", j)
}

结果&＃xff1a;

n1 &＃61; 0 n2 &＃61; 0 n3 &＃61; 0
a &＃61; 100 name &＃61; 张三 b &＃61; 300
i &＃61; 10 j &＃61; 20


5. 全局多变量声明

package mainimport "fmt"// 一次声明多个全局变量
var (a &＃61; 100b &＃61; 200name &＃61; "李四"
)func main() {fmt.Println("a &＃61;", a, "b &＃61;", b, "name &＃61;", name)
}

结果&＃xff1a;a &＃61; 100 b &＃61; 200 name &＃61; 李四

变量使用的注意事项

• 变量的值可以在同一类型和范围内不断变化
• 变量在同一作用域内不能重名
• 变量的三要素&＃xff1a;变量名、变量值、数据类型
• Go中的变量如果没有赋初值&＃xff0c;编译器会使用默认值。比如int型默认值为0&＃xff0c;string型默认值为空串

声明全局变量的坑

我们可以在函数内部使用变量声明的简写方式&＃xff0c;比如a :&＃61; 10&＃xff0c;但这条语句不能写在函数外部&＃xff0c;也就是全局&＃xff0c;因为这条语句相当于两条语句&＃xff1a;var a int与a &＃61; 10&＃xff0c;而在全局中是不允许有赋值语句的。

数据类型

Go的数据类型分为基本数据类型和派生/复杂数据类型。

• 基本数据类型&＃xff1a;
  • bool
  • string
  • int、int8、int16、int32、int64
  • uint、uint8、uint16、uint32、uint64、uintptr
  • byte&＃xff08;uint8的别名&＃xff09;
  • rune&＃xff08;int32的别名&＃xff0c;表示一个Unicode码点&＃xff09;
  • float32、float64
  • complex64、complex128
• 派生/复杂数据类型&＃xff1a;
  • 指针pointer
  • 数组array
  • 结构体struct
  • 管道channel
  • 函数function
  • 切片slice
  • 接口interface
  • map

整型类型的说明

整型类型的使用细节

• 整型分为有符号和无符号两种&＃xff0c;int和uint的大小与系统有关
• 当我们声明了一个变量且给变量赋了一个数字&＃xff0c;但是我们没有确定它的类型&＃xff0c;此时这个变量默认为int型

package mainimport "fmt"func main() {var a &＃61; 200// fmt.Printf用来做格式化输出// %T表示类型fmt.Printf("变量a的类型为%T", a)// 结果&＃xff1a;// 变量a的类型为int
}

• 查看某个变量的数据类型和其所占内存大小

package main// 一次导入多个包
import ("fmt""unsafe"
)func main() {var a &＃61; 200fmt.Printf("变量a的类型为%T\n", a)// unsafe.Sizeof用来获取变量所占内存大小&＃xff0c;单位&＃xff1a;字节fmt.Printf("变量a所占内存大小为%d个字节", unsafe.Sizeof(a))// 结果&＃xff1a;// 变量a的类型为int// 变量a所占内存大小为8个字节
}

• 在定义整型变量时&＃xff0c;遵循保小不保大的原则&＃xff0c;即&＃xff1a;在保证程序正确运行的情况下&＃xff0c;尽量使用占用空间小的数据类型&＃xff0c;比如【年龄】

package mainimport "fmt"func main() {// byte表示范围&＃xff1a;0~255var age byte &＃61; 20fmt.Printf("年龄是%d岁", age)// 年龄是20岁
}

浮点类型的说明

浮点类型的使用细节

• 浮点型有固定的范围和字段长度&＃xff0c;不受操作系统的影响
• 浮点型默认声明为float64
• 浮点型常量有两种表示形式&＃xff1a;十进制数表示、科学计数法表示

package mainimport "fmt"func main() {// 十进制数表示var a &＃61; 0.1var b &＃61; .2 // 小数点不能少// 科学计数法表示var c &＃61; 0.0314e2var d &＃61; 314e-2fmt.Println(a) // 0.1fmt.Println(b) // 0.2fmt.Println(c) // 3.14fmt.Println(d) // 3.14
}

• 浮点数在机器中的存放形式&＃xff1a;浮点数&＃61;符号位&＃43;指数位&＃43;尾数位&＃xff0c;这说明浮点数都是有符号的
• 尾数部分可能丢失&＃xff0c;从而造成精度损失

package mainimport "fmt"func main() {var a float32 &＃61; -1.00000019var b float64 &＃61; -1.00000019 //这里的&＃39;float64&＃39;应该省略&＃xff0c;因为它是默认的fmt.Println(a)//-1.0000002fmt.Println(b)//-1.00000019
}

• 通常情况下&＃xff0c;我们应该使用float64&＃xff0c;因为它比float32更精确

字符类型的说明

Go语言中没有专门的字符类型&＃xff0c;如果要存储单个字符&＃xff08;字母&＃xff09;&＃xff0c;一般使用byte来保存。

案例演示&＃xff1a;

package mainimport "fmt"func main() {var c1 &＃61; &＃39;我&＃39; // 相当于 var c1 rune &＃61; &＃39;我&＃39;&＃xff0c;这里最好省略&＃39;rune&＃39;var c2 &＃61; &＃39;爱&＃39; // 相当于 var c2 int32 &＃61; &＃39;爱&＃39;&＃xff0c;这里最好省略&＃39;int32&＃39;var c3 &＃61; &＃39;你&＃39;fmt.Printf("%c%c%c", c1, c2, c3) // 我爱你fmt.Println(c1, c2, c3) // 25105 29233 20320fmt.Printf("%T", c1) // int32
}

对上述代码的说明&＃xff1a;

• 如果我们保存的字符在ASCII表中&＃xff0c;则可以直接用byte类型来保存
• 如果我们保存的字符对应的UTF-8码值大于255&＃xff0c;这时我们可以考虑使用rune类型来保存
• 如果我们想按照字符的方式输出&＃xff0c;则需要用到格式化输出fmt.Printf("%c", c)

转义字符

字符类型的使用细节

• 字符常量是用单引号&＃39;&＃39;引起来的单个字符
• Go中允许使用转义字符\?来将其后的字符转变成特殊的字符常量
• Go语言的字符使用的是UTF-8编码&＃xff0c;在UTF-8编码中&＃xff0c;英文字母占1字节&＃xff0c;汉字占3字节
• 在Go中&＃xff0c;字符的本质是一个整数&＃xff0c;直接输出时&＃xff0c;输出的是该字符对应的UTF-8编码的码值
• 可以直接给某个变量赋一个数字&＃xff0c;然后用%c按格式化输出&＃xff0c;就会输出该数字对应的Unicode字符

package mainimport "fmt"func main() {var c1 &＃61; 20013var c2 &＃61; 22269fmt.Printf("%c%c", c1, c2) // 中国
}

• 字符类型是可以进行运算的&＃xff0c;相当于整数的运算

package mainimport "fmt"func main() {var c1 &＃61; &＃39;中&＃39;var c2 &＃61; &＃39;国&＃39;fmt.Println(c1 &＃43; c2) // 42282
}

• Go语言的编码都统一成了UTF-8&＃xff0c;非常地方便&＃xff0c;再也没有乱码的困扰了

布尔类型

• 布尔类型也叫bool类型&＃xff0c;布尔类型的数据只能取true或false
• bool类型占1个字节
• bool类型适用于逻辑运算&＃xff0c;一般用于程序流程控制

案例演示&＃xff1a;

package mainimport ("fmt""unsafe"
)func main() {var bo &＃61; truefmt.Println("变量bo占", unsafe.Sizeof(bo), "字节")// 变量bo占 1 字节
}

字符串类型的说明

字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的&＃xff0c;也就是说对于传统的字符串是由字符组成的&＃xff0c;而Go的字符串不同&＃xff0c;它是由字节组成的。Go的字符串的字节使用UTF-8编码表示Unicode文本。

案例演示&＃xff1a;

package mainimport ("fmt""unsafe"
)func main() {var str string &＃61; "你好&＃xff0c;世界" // string类型可以省略fmt.Println(str)fmt.Printf("string类型占%d个字节", unsafe.Sizeof(str))/*结果&＃xff1a;你好&＃xff0c;世界string类型占16个字节*/
}

字符串类型的使用细节

• 不可以通过下标来修改字符串中的某一个字符&＃xff0c;但可以通过下标来读取单个字节&＃xff0c;读取中文时结果为乱码&＃xff0c;因为一个汉字在UTF-8编码中占3个字节
• string类型占16个字节
• 字符串有两种表示形式&＃xff1a;双引号""&＃xff08;会识别转义字符&＃xff09;、反引号&＃96;&＃96;&＃xff08;以字符串的原生形式输出&＃xff0c;包括特殊字符&＃xff0c;可以实现防止攻击、输出源代码等效果&＃xff09;

package mainimport "fmt"func main() {var str &＃61; &＃96;
func main() {var str &＃61; "你好&＃xff0c;世界"fmt.Println(str)
}&＃96;fmt.Println(str)
}

结果&＃xff1a;

func main() { var str &＃61; "你好&＃xff0c;世界"fmt.Println(str)
}


• 字符串拼接时&＃xff0c;如果字符串太长&＃xff0c;而我们想换行再拼接&＃xff0c;此时需要注意拼接的&＃43;号必须在上面&＃xff0c;原因是Go会为每一行结尾处加上分号&＃xff0c;遇到&＃43;号就不会给它加分号

package mainimport "fmt"func main() {var str &＃61; "你好呀&＃xff0c;" &＃43; "今天过的" &＃43; "怎么样&＃xff0c;" &＃43; "有没有学习呢&＃xff1f;\n" &＃43;"今天过的不错&＃xff0c;" &＃43; "学习也搞了。"fmt.Println(str)
}

结果&＃xff1a;

你好呀&＃xff0c;今天过的怎么样&＃xff0c;有没有学习呢&＃xff1f;
今天过的不错&＃xff0c;学习也搞了。


基本数据类型的默认值

package mainimport "fmt"func main() {var n int // 整型var c byte // 整型var num float64var bo boolvar str string// %v表示按照变量的原值输出fmt.Printf("n&＃61;%v,c&＃61;%v,num&＃61;%v,bo&＃61;%v,str&＃61;%v", n, c, num, bo, str)// n&＃61;0,c&＃61;0,num&＃61;0,bo&＃61;false,str&＃61;
}

常用格式化动作

类型转换

数字类型之间的相互转换

Go和Java/C不同&＃xff0c;Go在不同类型的变量之间赋值时需要强制类型转换&＃xff0c;Go没有自动类型转换。

• 基本语法type(variable)。type表示类型&＃xff1b;variable表示变量
• 功能&＃xff1a;将指定变量的值转换为指定类型

package mainimport "fmt"func main() {var n1 int32 &＃61; 10var n2 &＃61; int8(n1)fmt.Printf("n2的类型为%T", n2)// n2的类型为int8
}

• 在类型转换时&＃xff0c;既可以将表示范围小的数据转换为表示范围大的&＃xff0c;也可以将大的转换为小的
• 被转换的是变量存储的值&＃xff0c;而不是转换变量本身的数据类型
• 当我们将范围大的数据转换为小的时&＃xff0c;编译不会报错&＃xff0c;只是转换的结果按溢出处理&＃xff0c;转换后会直接去除溢出的位数&＃xff0c;只保留指定类型的位数

package mainimport "fmt"func main() {var n1 int32 &＃61; 258 // 二进制表示&＃xff1a;1 0000 0010var n2 &＃61; int8(n1) // 转换后&＃xff1a;0000 0010fmt.Println(n2) // 2
}

• Go不允许给变量[赋值或运算的值]大于变量数据类型本身的范围&＃xff0c;否则编译器会报错

package mainimport "fmt"func main() {var n1 int32 &＃61; 10var n2, n3 int8n2 &＃61; int8(n1) &＃43; 127 // 编译能通过n3 &＃61; int8(n1) &＃43; 128 // 报错&＃xff1a;无法将常量 128 转换为类型 int8fmt.Println(n2, n3)
}

数字或布尔转字符串

• 方式一&＃xff1a;func Sprintf(format string, a ...interface{}) string
  Sprintf根据format参数生成格式化的字符串并返回该字符串

package mainimport "fmt"func main() {num1 :&＃61; 10num2 :&＃61; 10.5c :&＃61; &＃39;G&＃39;b :&＃61; truevar str stringstr &＃61; fmt.Sprintf("%d", num1)fmt.Printf("str的值为字符串%q\n", str)str &＃61; fmt.Sprintf("%f", num2)fmt.Printf("str的值为字符串%q\n", str)str &＃61; fmt.Sprintf("%c", c)fmt.Printf("str的值为字符串%q\n", str)str &＃61; fmt.Sprintf("%t", b)fmt.Printf("str的值为字符串%q\n", str)
}/*结果&＃xff1a;
str的值为字符串"10"
str的值为字符串"10.500000"
str的值为字符串"G"
str的值为字符串"true"
*/

• 方式二&＃xff1a;使用strconv包的函数
  

package mainimport ("fmt""strconv"
)func main() {num1 :&＃61; 10num2 :&＃61; 10.5b :&＃61; truevar str stringstr &＃61; strconv.FormatInt(int64(num1), 10)fmt.Printf("str的值为字符串%q\n", str)// &＃39;f&＃39;格式6&＃xff1a;表示小数位保留6位// 64&＃xff1a;表示这个小数是float64str &＃61; strconv.FormatFloat(num2, &＃39;f&＃39;, 6, 64)fmt.Printf("str的值为字符串%q\n", str)str &＃61; strconv.FormatBool(b)fmt.Printf("str的值为字符串%q\n", str)
}/*结果&＃xff1a;
str的值为字符串"10"
str的值为字符串"10.500000"
str的值为字符串"true"
*/

• 补充&＃xff1a;func Itoa(i int) string&＃xff0c;Itoa是FormatInt(i, 10) 的简写

package mainimport ("fmt""strconv"
)func main() {num :&＃61; 100var str stringstr &＃61; strconv.Itoa(num)fmt.Printf("str的值为字符串%q", str)// str的值为字符串"100"
}

字符串转数字或布尔

• 使用strconv包的函数
  

package mainimport ("fmt""strconv"
)func main() {str1 :&＃61; "10"var num1 int64// ParseInt函数返回两个值(i int64, err error)// 第一个值才是我们想要的&＃xff0c;但它是int64&＃xff0c;所以我们声明num时只能指定类型为int64// 下面这种写法表示num接受第一个返回值&＃xff0c;然后用&＃39;_&＃39;忽略第二个返回值num1, _ &＃61; strconv.ParseInt(str1, 10, 64)fmt.Printf("num1的值为%v\n", num1) // num1的值为10// ParseFloat函数返回两个值(f float64, err error)str2 :&＃61; "10.5"var num2 float64num2, _ &＃61; strconv.ParseFloat(str2, 64)fmt.Printf("num2的值为%v\n", num2) // num2的值为10.5// ParseBool函数返回两个值(value bool, err error)str3 :&＃61; "true"var bo boolbo, _ &＃61; strconv.ParseBool(str3)fmt.Printf("bo的值为%v\n", bo) // bo的值为true
}

• 字符串转数字或布尔时需要注意&＃xff1a;要确保字符串的值转换后依然是有效的数据&＃xff0c;比如我们可以把字符串"123"转换成一个整数&＃xff0c;但是我们不能把字符串"hello"转换成整数&＃xff0c;如果硬是要转&＃xff0c;Go会直接将其转换成目标类型的默认值

package mainimport ("fmt""strconv"
)func main() {str :&＃61; "hello"var num int64 &＃61; 100num, _ &＃61; strconv.ParseInt(str, 10, 64)fmt.Printf("num的值为%v\n", num) // num的值为0var bo &＃61; truebo, _ &＃61; strconv.ParseBool(str)fmt.Printf("bo的值为%v\n", bo) // bo的值为false
}