Go学习第二章——变量与数据类型
Go变量与数据类型
-
-
- 1 变量
-
- 1.1 变量概念
- 1.2 变量的使用步骤
- 1.3 变量的注意事项
- 1.4 "+"的使用
- 2 数据类型介绍
- 3 整数类型
-
- 3.1 有符号整数类型
- 3.2 无符号整数类型
- 3.3 其他整数类型
- 3.4 整型的使用细节
- 4 小数类型/浮点型
-
- 4.1 浮点型的分类
- 4.2 简单使用
- 5 字符类型
-
- 5.1 字符类型的使用
- 5.2 转义字符
- 5.3 字符使用的注意事项
- 6 布尔类型
- 7 字符串类型
-
- 7.1 基本使用
- 7.2 string使用注意事项
- 8 基本数据类型的转换
-
- 8.1 基本使用
- 8.2 基本数据类型转化为string类型
- 8.3 string类型转化为基本数据类型
-
1 变量
1.1 变量概念
变量相当于内存中一个数据存储空间的表示
1.2 变量的使用步骤
（1）声明变量（也叫：定义变量）
（2）非变量赋值
（3）使用变量
1.3 变量的注意事项
（1）变量表示内存中的一个存储区域
（2）该区域有自己的名称（变量名）和类型（数据类型）
（3）Golang变量使用的三种方式
- 第一种：声明后不赋值，使用默认值，例如：int数据类型默认值为 ‘0’
func main() {
// 声明不赋值，int数据类型默认值为 0
var i int
fmt.Println("i=", i)
}
- 第二种：根据值自行判断变量类型（类型推导，自动判断）
func main() {
// 根据自行判定变量类型（类型推导，自动判断）
var num = 10.11
fmt.Println("num=", num)
}
- 第三种：省略var，注意： = 左侧的变量不应该是已经声明过的，否则会导致编译错误
func main() {
// 第三种：省略var，等价于 var name string, name = "tom"
num := "tom"
fmt.Println("num=", num)
}
（4）多变量声明
一次性声明多个变量
func main() {
// 对应上面第一种方式
var a1, a2, a3 int
fmt.Println("a1=", a1, "a2=", a2, "a3=", a3)
// 对应上面第二种方式
var b1, b2, b3 = 100, "tom", 888
fmt.Println("b1=", b1, "b2=", b2, "b3=", b3)
// 对应上面第三种方式
c1, c2, c3 := 100, "tom", 888
fmt.Println("c1=", c1, "c2=", c2, "c3=", c3)
}
（5）全局变量的声明
package main
// 定义全局变量
var n1 = 100
var n2 = 200
var n3 = "Tom"
// 一次性声明
var (
n4 = 300
n5 = "Mary"
)
func main() {
// 注意：这里声明的变量和全局变量不能名字重复，
// var n1 = 1000
// 相当于把全局变量的n1值给修改
n1 = 1000
println("n1=", n1, "n2=", n2, "n3=", n3, "n4=", n4, "n5=", n5)
}
（6）该区域的数据值可以在同一数据类型范围内重复赋值（变化，修改）
func main() {
var i int
i = 1
i = 2
i = 3
fmt.Println(i)
// i = 1.1 报错：数据类型不同
}
（7）变量在同一个作用域（在一个函数或者在代码块）内不能重名
func main() {
var i int
i = 1
// var i int 报错：重名
// i := 2 报错：同上，因为这个是两个语句的合体
fmt.Println("i=", i)
}
（8）变量=变量名+值+数据类型，注意这是变量的三要素
（9）Golang的变量如果没有赋初值，编译器会使用默认值，比如int默认值 0 , string默认值 空串，小数默认值 0
1.4 "+"的使用
- 当左右两边都是数值型时，做加法运算
- 当左右两边都是字符串时，做字符串拼接
func main() {
var a, b = 1, 2
fmt.Println("a+b=", a+b)
var n1, n2 = "你", "好"
fmt.Println("n1+n2=", n1+n2)
}
2 数据类型介绍
每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间
下面是主要和常用的数据类型
不过少了rune（int32的别名，表示一个Unicode码，处理带中文的字符串）和complex64，128（复数数据类型）
区别于java，不使用short等来区分内存空间大小，例如：int8 占用8位，也就是1个byte
注意：
-
没有字符型char这种数据类型，使用byte存储时，只能存
字母,不能存单个汉字 -
string 在go语言属于基本数据类型
3 整数类型
简单的说，就是用于存放整数值的，比如10,-45,6712等等。
3.1 有符号整数类型
PS:127怎么算出来的？
01111111 -->二进制 —》转为十进制：
12^6 + 12^5 + 12^4 + 12^3 + 12^2 + 12^1 + 1*2^0
= 64 + 32 + 16 + 8 + 4 + 2 + 1
= 127PS：-128怎么算出来的？
10000000 —>二进制 —>一看就是个负数进行负数的二进制计算
减1：01111111
取反：10000000 —》得到一个正数 2^7 = 128
加负号：-128
3.2 无符号整数类型
表数范围的边界计算：
11111111= 2^7+127 = 128 + 127 = 255
00000000 = 0
3.3 其他整数类型
3.4 整型的使用细节
-
Golang各整数类型分为：有符号和无符号，int uint 的大小和系统有关
-
Golang的整数类型，默认声明为int类型
func main() {
var a = 1
// fmt.Printf()可以用于做格式化输出
fmt.Printf("a 的数据类型：%T", a)
// 输出：a 的数据类型：int
}
- 如何在程序查看某个遍历的占用字节大小和数据类型（使用较多）
func main() {
var n1 byte = 10
// fmt.Printf()可以用于做格式化输出
// unsafe.Sizeof(a) 是unsafe包的一个函数，可以返回n1变量占用的字节数
fmt.Printf("n1 的数据类型：%T ，n1占用的字节数是 %d ", n1, unsafe.Sizeof(n1))
// 输出：n1 的数据类型：uint8 ，n1占用的字节数是 1
}
- Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型。如：年龄，可以使用byte，就占用一个字节
- bit：计算机中的最小存储单位。byte：计算机中基本存储单元。一个byte = 8bit
4 小数类型/浮点型
简单的说，就是用于存放小数值的，比如3.14、0.28、-7.19等等。
4.1 浮点型的分类
PS: 底层存储空间和操作系统无关
PS：浮点类型底层存储：符号位+指数位+尾数位，所以尾数位只是存了 一个大概，很可能会出现精度的损失。
4.2 简单使用
func main() {
num1 := 5.12
num2 := 0.12
// 科学计数法的使用
num3 := 5.1234e2 // 5.1234 * 10的2次方
fmt.Println("num1=", num1, "num2=", num2, "num3=", num3)
// 输出：num1= 5.12 num2= 0.12 num3= 512.34
fmt.Printf("num3的数据类型： %T", num3)
// 输出：num3的数据类型： float64
}
注意：推荐使用float64
5 字符类型
5.1 字符类型的使用
- Golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用byte来保存。
- Golang中字符使用UTF-8编码
func main() {
var a byte = 'a'
var b byte = '0'
fmt.Println("a = ", a, "，b = ", b)
// 输出：a = 97 ，b = 48
}
ASCII码表：
左面是不可见字符 右面是可见字符
- 如果我们需要输出对应字符，需要使用格式化输出
func main() {
var a byte = 'a'
var b byte = '0'
fmt.Printf("a = %c ，b = %c", a, b)
// 输出：a = a ，b = 0
}
- 输出汉字的方式
func main() {
//var a byte = '北' // overflow溢出
var a int = '北'
fmt.Printf("a=%c，a对应码值=%d", a, a)
}
5.2 转义字符
\转义字符：将后面的字母表示为特殊含义
5.3 字符使用的注意事项
- 字符常量是用单引号
''括起来的单个字符 - Go语言的字符使用UTF-8编码
英文字母1个字节，汉字3个字节 - 字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码码值
- 格式化输出%C，会输出该数字对应的unicode字符
- 字符类型是可以进行运算的，相当于一个整数，因为它都对应有
Unicode码
PS：字符型 存储到 计算机中
- 存储：字符 -> 对应码值 -> 二进制 -> 存储
- 读取：二进制 -> 码值 -> 字符 -> 读取
PS：GO语言的编码都统一成了utf-8。非常的方便，很统一，再也没有编码乱码的困扰了。
6 布尔类型
- 布尔类型也叫bool类型，bool类型数据只允许取值
true和false - 布尔类型占1个字节。
- 布尔类型适于逻辑运算，一般用于程序流程控制
func main() {
var n = false // 不允许使用 0,1
fmt.Println("n =", n)
}
7 字符串类型
7.1 基本使用
字符串就是一串固定长度的字符连接起来的字符序列。
func main() {
var address string = "北京长城 110 hello world"
fmt.Println("address = " + address)
// 输出：address = 北京长城 110 hello world
}
7.2 string使用注意事项
- Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用UTF-8编码，
中文乱码问题不会再困扰程序员。 - 字符串一单赋值了，字符串就不能修改了：在Go中字符串是不可变的
func main() {
var address string = "北京长城 110 hello world"
// address[0] = '哈' // 报错！不能修改！
fmt.Println("address = ", address)
}
- 字符串的两种表示形式
- 双引号，会识别转义字符
- 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现
防止攻击、输出源代码等效果
8 基本数据类型的转换
8.1 基本使用
Go在不同类型的变量之间赋值时需要显式转换，并且只有显式转换(强制转换)。
语法：
表达式T(v)将值v转换为类型T
T : 就是数据类型
v : 就是需要转换的变量
func main() {
var n1 int32 = 100
// var n2 float32 = n1 报错
var n2 float32 = float32(n1)
fmt.Printf("n1 = %v n2 = %v ", n1, n2)
}
**注意：**转换的结果如果超出范围，就会按照溢出处理，不会编译错误，只是会和我们希望的结果不一样。
8.2 基本数据类型转化为string类型
在程序开发中，我们经常需要将基本数据类型转成string类型。或者将string类型转成基本数据类型。
基本类型转string类型的两种方式
方式1:fmt.Sprintf(“%参数”,表达式) —》 重点练习这个，推荐方式
方式2:使用strconv包的函数
方式1 代码演示：
import "fmt"
func main() {
var num1 int = 99
var str1 string = fmt.Sprintf("%d", num1)
fmt.Printf("str1 type:%T, str1 = %v", str1, str1)
fmt.Println()
var num2 float64 = 23.456
str2 := fmt.Sprintf("%f", num2)
fmt.Printf("str2 type:%T, str2 = %v", str2, str2)
fmt.Println()
var b bool = true
str3 := fmt.Sprintf("%t", b)
fmt.Printf("str3 type:%T, str3 = %v", str3, str3)
fmt.Println()
var myChar byte = 'h'
str4 := fmt.Sprintf("%b", myChar)
fmt.Printf("str4 type:%T, str4 = %v", str4, str4)
}
输出：
str1 type:string, str1 = 99
str2 type:string, str2 = 23.456000
str3 type:string, str3 = true
str4 type:string, str4 = 1101000
方式2 代码演示：
func main() {
var num1 int = 99
// 表示10进制
str1 := strconv.FormatInt(int64(num1), 10)
// str1 := strconv.Itoa(num1) 同上
fmt.Printf("str1 type:%T, str1 = %v\n", str1, str1)
var num2 float64 = 23.456
// 'f' 格式 10：表示小数位保留10位 64 表示是float64
str2 := strconv.FormatFloat(num2, 'f', 10, 64)
fmt.Printf("str2 type:%T, str2 = %v\n", str2, str2)
var b bool = true
str3 := strconv.FormatBool(b)
fmt.Printf("str3 type:%T, str3 = %v\n", str3, str3)
var myChar byte = 'h'
// str4 := strconv.FormatInt(int64(myChar), 2)
str4 := string(myChar)
fmt.Printf("str4 type:%T, str4 = %v\n", str4, str4)
}
输出：
str1 type:string, str1 = 99
str2 type:string, str2 = 23.456000
str3 type:string, str3 = true
str4 type:string, str4 = h
8.3 string类型转化为基本数据类型
func main() {
// 说明：num1, _ := strconv.ParseInt() 表示忽略第二个函数的返回值，使用下划线"_"
str1 := "99"
// num1, _ := strconv.Atoi(str1) // 与下面这个相同
num1, _ := strconv.ParseInt(str1, 10, 64) // 只能转化为int64，但是不能为int类型，int类型只能用上面这个
fmt.Printf("num1 type:%T, num1 = %v\n", num1, num1)
str2 := "23.456"
num2, _ := strconv.ParseFloat(str2, 64)
fmt.Printf("num2 type:%T, num2 = %v\n", num2, num2)
str3 := "true"
b, _ := strconv.ParseBool(str3)
fmt.Printf("b type:%T, b = %v\n", b, b)
str4 := "h"
// myChar2 := str4[0] 结果与下面这个相同
myChar := byte(str4[0])
fmt.Printf("myChar type:%T, myChar = %v\n", myChar, myChar)
}
输出为：
num1 type:int64, num1 = 99
num2 type:float64, num2 = 23.456
b type:bool, b = true
myChar type:uint8, myChar = 104
注意事项：
确保转换之间的数据类型没有问题，不然Golang不会报错，但是数据是当前数据类型的默认值
可以把“123”转为一个整数，但不能把“hello”转成一个整数，如果这样做，Golang直接将其转成默认值 0
例子：
func main() {
var str string = "hello"
var num int64
num, _ = strconv.ParseInt(str, 10, 64)
fmt.Printf("num type = %T, num value = %d \n", num, num)
// 输出为：num type = int64, num value = 0
}
Over！！！！下一步学习Go指针，冲冲冲！！！