Go学习第二章——变量与数据类型

Go变量与数据类型

- - [1 变量](#1 变量)
  - - [1.1 变量概念](#1.1 变量概念)
    - [1.2 变量的使用步骤](#1.2 变量的使用步骤)
    - [1.3 变量的注意事项](#1.3 变量的注意事项)
    - [1.4 "+"的使用](#1.4 "+"的使用)
  - [2 数据类型介绍](#2 数据类型介绍)
  - [3 整数类型](#3 整数类型)
  - - [3.1 有符号整数类型](#3.1 有符号整数类型)
    - [3.2 无符号整数类型](#3.2 无符号整数类型)
    - [3.3 其他整数类型](#3.3 其他整数类型)
    - [3.4 整型的使用细节](#3.4 整型的使用细节)
  - [4 小数类型/浮点型](#4 小数类型/浮点型)
  - - [4.1 浮点型的分类](#4.1 浮点型的分类)
    - [4.2 简单使用](#4.2 简单使用)
  - [5 字符类型](#5 字符类型)
  - - [5.1 字符类型的使用](#5.1 字符类型的使用)
    - [5.2 转义字符](#5.2 转义字符)
    - [5.3 字符使用的注意事项](#5.3 字符使用的注意事项)
  - [6 布尔类型](#6 布尔类型)
  - [7 字符串类型](#7 字符串类型)
  - - [7.1 基本使用](#7.1 基本使用)
    - [7.2 string使用注意事项](#7.2 string使用注意事项)
  - [8 基本数据类型的转换](#8 基本数据类型的转换)
  - - [8.1 基本使用](#8.1 基本使用)
    - [8.2 基本数据类型转化为string类型](#8.2 基本数据类型转化为string类型)
    - [8.3 string类型转化为基本数据类型](#8.3 string类型转化为基本数据类型)

1 变量

1.1 变量概念

变量相当于内存中一个数据存储空间的表示

1.2 变量的使用步骤

（1）声明变量（也叫：定义变量）

（2）非变量赋值

（3）使用变量

1.3 变量的注意事项

（1）变量表示内存中的一个存储区域

（2）该区域有自己的名称（变量名）和类型（数据类型）

（3）Golang变量使用的三种方式

第一种：声明后不赋值，使用默认值，例如：int数据类型默认值为 '0'

go 复制代码

func main() {
	// 声明不赋值，int数据类型默认值为 0
	var i int
	fmt.Println("i=", i)
}

第二种：根据值自行判断变量类型（类型推导，自动判断）

go 复制代码

func main() {
	// 根据自行判定变量类型（类型推导，自动判断）
	var num = 10.11
	fmt.Println("num=", num)
}

第三种：省略var，注意： = 左侧的变量不应该是已经声明过的，否则会导致编译错误

go 复制代码

func main() {
	// 第三种：省略var，等价于 var name string, name = "tom"
	num := "tom"
	fmt.Println("num=", num)
}

（4）多变量声明

一次性声明多个变量

go 复制代码

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）全局变量的声明

go 复制代码

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）该区域的数据值可以在同一数据类型范围内重复赋值（变化，修改）

go 复制代码

func main() {
	var i int
	i = 1
	i = 2
	i = 3
	fmt.Println(i)
	// i = 1.1 报错：数据类型不同
}

（7）变量在同一个作用域（在一个函数或者在代码块）内不能重名

go 复制代码

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 "+"的使用

当左右两边都是数值型时，做加法运算
当左右两边都是字符串时，做字符串拼接

go 复制代码

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 + 1 2^5 + 12^4 + 1 2^3 + 12^2 + 1 2^1 + 1*2^0

= 64 + 32 + 16 + 8 + 4 + 2 + 1

= 127

PS：-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类型

java 复制代码

func main() {
	var a = 1
	// fmt.Printf()可以用于做格式化输出
	fmt.Printf("a 的数据类型：%T", a)
    // 输出：a 的数据类型：int
}

如何在程序查看某个遍历的占用字节大小和数据类型（使用较多）

go 复制代码

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 简单使用

go 复制代码

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编码

go 复制代码

func main() {
	var a byte = 'a'
	var b byte = '0'
	fmt.Println("a = ", a, "，b = ", b)
	// 输出：a =  97 ，b =  48
}

ASCII码表：

左面是不可见字符右面是可见字符

如果我们需要输出对应字符，需要使用格式化输出

go 复制代码

func main() {
    var a byte = 'a'
    var b byte = '0'
    fmt.Printf("a = %c ，b = %c", a, b)
    // 输出：a = a ，b = 0
}

输出汉字的方式

go 复制代码

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个字节。
布尔类型适于逻辑运算，一般用于程序流程控制

go 复制代码

func main() {
	var n = false // 不允许使用 0,1
	fmt.Println("n =", n)
}

7 字符串类型

7.1 基本使用

字符串就是一串固定长度的字符连接起来的字符序列。

go 复制代码

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中字符串是不可变的

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 : 就是需要转换的变量

go 复制代码

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 代码演示：

go 复制代码

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)
}

输出：

cmd 复制代码

str1 type:string, str1 = 99
str2 type:string, str2 = 23.456000
str3 type:string, str3 = true
str4 type:string, str4 = 1101000

方式2 代码演示：

go 复制代码

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)
}

输出：

cmd 复制代码

str1 type:string, str1 = 99
str2 type:string, str2 = 23.456000
str3 type:string, str3 = true
str4 type:string, str4 = h

8.3 string类型转化为基本数据类型

go 复制代码

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)
}

输出为：

go 复制代码

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

例子：

go 复制代码

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指针，冲冲冲！！！