Go：变量

╰半橙微兮° 2023-03-13 12:29 16阅读 0赞

### 文章目录 ###

*  一、变量
 *   *  1.变量声明的方式
     *  2.多变量声明
     *  3.声明全局变量
 *  二、数据类型
 *   *  1.整数
     *  2.浮点
     *  3.字符
     *  4.布尔
     *  5.String
     *  6.基本数据类型的默认值
     *  7.基本数据类型的转换
     *  8.基本数据类型和String的转换
     *  9.指针
     *  10.值类型和引用类型
     *  11.标识符的命名规范

# 一、变量 #

> **变量相当于内存中一个数据存储空间的表示，变量是程序的基本组成单位。**

## 1.变量声明的方式 ##

1.  **先声明后赋值**

func main() { 
    	var i int
    	i = 10
    	fmt.Println("i = ", i)
    }

1.  **声明并赋值省略变量类型（类型推导）**

func main() { 
    	var i = 13.14
    	fmt.Println("i = ", i)
    }

1.  **省略var**

func main() { 
    	i := "jack"
    	fmt.Println("i = ", i)
    }

> Golang 的变量如果没有赋初值，编译器会使用默认值, 比如 int 默认值 0 string 默认值为空串， 小数默认为 0

## 2.多变量声明 ##

func main() { 
    	i, j := "jack", 11
    	fmt.Println("i = ", i, "; j = ", j)
    }

## 3.声明全局变量 ##

var n1 = 1
    var n2 = 2
    var (
    	m1 = 3
    	m2 = 4
    )
    
    func main() { 
    	fmt.Println("n1 = ", n1, "; n2 = ", n2, "; m1 = ", m1, "; m2 = ", m2)
    }

# 二、数据类型 #

![在这里插入图片描述][20200513201846932.png]

## 1.整数 ##

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>有无符号</th> 
   <th>占用存储空间</th> 
   <th>表数范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int8</td> 
   <td>有</td> 
   <td>1字节</td> 
   <td>-128 ~ 127</td> 
  </tr> 
  <tr> 
   <td>int16</td> 
   <td>有</td> 
   <td>2字节</td> 
   <td>- 2^15 ~ 2^15 -1</td> 
  </tr> 
  <tr> 
   <td>int32</td> 
   <td>有</td> 
   <td>4字节</td> 
   <td>- 2^31 ~ 2^31 -1</td> 
  </tr> 
  <tr> 
   <td>int64</td> 
   <td>有</td> 
   <td>8字节</td> 
   <td>- 2^63 ~ 2^63 -1</td> 
  </tr> 
  <tr> 
   <td>uint8</td> 
   <td>无</td> 
   <td>1字节</td> 
   <td>0 ~ 255</td> 
  </tr> 
  <tr> 
   <td>uint16</td> 
   <td>无</td> 
   <td>2字节</td> 
   <td>0 ~ 2^16 -1</td> 
  </tr> 
  <tr> 
   <td>uint32</td> 
   <td>无</td> 
   <td>4字节</td> 
   <td>0 ~ 2^32 -1</td> 
  </tr> 
  <tr> 
   <td>uint64</td> 
   <td>无</td> 
   <td>8字节</td> 
   <td>0 ~ 2^64 -1</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>有</td> 
   <td>32位系统4字节64位系统8字节</td> 
   <td>2^31 ~ 2^31 -1 ; 2^63 ~ 2^63 -1</td> 
  </tr> 
  <tr> 
   <td>uint</td> 
   <td>无</td> 
   <td>32位系统4字节64位系统8字节</td> 
   <td>0 ~ 2^32 -1 ; 0 ~ 2^64 -1</td> 
  </tr> 
  <tr> 
   <td>uint64</td> 
   <td>无</td> 
   <td>与int32一样</td> 
   <td>- 2^31 ~ 2^31 -1</td> 
  </tr> 
  <tr> 
   <td>uint64</td> 
   <td>无</td> 
   <td>与uint8等价</td> 
   <td>0 ~ 255</td> 
  </tr> 
 </tbody> 
</table>

**整型的使用细节：**

1.`Golang`各整数类型分：有符号和无符号，int uint 的大小和系统有关。  
2. `Golang` 的整型默认声明为 `int`型  
3. 查看某个变量的字节大小和数据类型：`unsafe.Sizeof`

func main() { 
    	var n1 int = 129
    	fmt.Println("n1 = ", n1,unsafe.Sizeof(n1))
    }

1.  `Go`程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占用空间小的数据类型

## 2.浮点 ##

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>占用存储空间</th> 
   <th>表数范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>单精度float32</td> 
   <td>4字节</td> 
   <td>-3.403E38 ~ 3.403E38</td> 
  </tr> 
  <tr> 
   <td>双精度float64</td> 
   <td>8字节</td> 
   <td>-1.798E308 ~ 1.798E30</td> 
  </tr> 
 </tbody> 
</table>

**浮点型使用细节：**

1.  `Go`浮点类型有固定的范围和字段长度，不受具体操作系统的影响。
2.  `Go`的浮点型默认声明为`float64`类型。
3.  浮点型常量有两种表示形式  
    十进制数形式：如：5.12  
    512 (必须有小数点） 科学计数法形式:如：5.1234e2
4.  通常情况下，应该使用`float64`，因为它比`float32`更精确

func main() { 
    	var n1 float32 = 123.0000001
    	var n2 float64 = 123.0000001
    	fmt.Println("n1 = ", n1, "n2 = ", n2)
    }

![在这里插入图片描述][20200514094516874.png]

## 3.字符 ##

`Go`中没有专门的字符类型，如果要存储单个字符(字母)，一般使用`byte`来保存。  
字符串就是一串固定长度的字符连接起来的字符序列`Go`的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而`Go`的字符串不同，它是由字节组成的。

func main() { 
    	var c1 byte = '0'
    	var c2 byte = 'a'
    	fmt.Println("c1 = ", c1, "c2 = ", c2)
    	fmt.Printf("c1=%c c2=%c\n", c1, c2)
    	var c3 int = '字'//使用byte会导致overflow溢出
    	fmt.Printf("c3=%c",  c3)
    }

![在这里插入图片描述][20200514095452732.png]  
对上面代码说明:

①如果我们保存的字符在`ASCII`表的,比如\[0-1, a-z,A-Z…\]直接可以保存到 byte  
②如果我们保存的字符对应码值大于255,这时我们可以考虑使用`int`类型保存  
③如果我们需要安装字符的方式输出，这时我们需要格式化输出，即 fmt.Printf(“%c”, c1)

**字符类型使用细节：**

1.  字符常量是用单引号(‘ ’)括起来的单个字符
2.  `Go`中允许使用转义字符 `'\’`来将其后的字符转变为特殊字符型常量。例如：`var c3 char =‘\n’`表示换行
3.  `Go`语言的字符使用`UTF-8`编 码，在`Go`中，字符的本质是一个整数，直接输出时，是该字符对应的`UTF-8`编码的码值。
4.  字符类型是可以进行运算的，相当于一个整数，因为它都对应有`Unicode`码

**字符类型本质探讨：**  
①字符型存储到计算机中，需要将字符对应的码值（整数）找出来  
存储：字符—>对应码值---->二进制–>存储  
读取：二进制----> 码值 ----> 字符 --> 读取  
②字符和码值的对应关系是通过字符编码表决定的  
③`Go`语言的编码都统一成了`utf-8`，再也没有编码乱码的困扰了

## 4.布尔 ##

*  布尔类型也叫`bool`类型，`bool`类型数据只允许取值`true`和`false`
 *  `bool`类型占 1 个字节、
 *  `bool`类型适于逻辑运算，一般用于程序流程控制

func main() { 
    	var b1 bool = true
    	var b2 = false
    	fmt.Println("b1=", b1, "b2=", b2)
    }

## 5.String ##

字符串就是一串固定长度的字符连接起来的字符序列。`Go`的字符串是由单个字节连接起来的。`Go`语言的字符串的字节使用`UTF-8`编码标识`Unicode`文本。

func main() { 
    	var str string = "hello go"
    	fmt.Println("str=", str)
    }

**string 使用注意事项和细节：**

1.  `Go`语言的字符串的字节使用`UTF-8`编码标识`Unicode`文本，这样`Go`统一使用`UTF-8`编码,中文乱码问题不会再困扰程序员
2.  字符串一旦赋值了，字符串就不能修改了，在Go 中字符串是不可变的。  
    ![在这里插入图片描述][20200514100914935.png]
3.  字符串的两种表示形式  
    ①双引号, 会识别转义字符  
    ②反引号" \` "，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果

## 6.基本数据类型的默认值 ##

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>整型</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>浮点型</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>字符串</td> 
   <td>“”</td> 
  </tr> 
  <tr> 
   <td>布尔型</td> 
   <td>false</td> 
  </tr> 
 </tbody> 
</table>

## 7.基本数据类型的转换 ##

`Go`和 `java` / `c`不同，`Go`在不同类型的变量之间赋值时需要显式转换。也就是说`Go`中数据类型不能自动转换

func main() { 
    	var i int32 = 100
    	var n1 float32 = float32(i)
    	var n2 int8 = int8(i)
    	var n3 int64 = int64(i)
    	fmt.Printf("i=%v n1=%v n2=%v n3=%v", i, n1, n2, n3)
    }

**基本数据类型相互转换的注意事项:**

1.  `Go`中，数据类型的转换可以是从表示范围小——>表示范围大，也可以范围大——>范围小
2.  被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化
3.  在转换中，比如将`int64`转成`int8`【-128—127】 ，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。

## 8.基本数据类型和String的转换 ##

在程序开发中，我们经常将基本数据类型转成`string`或者将`string`转成基本数据类型

**基本类型转string类型**

**①fmt.Sprintf("%参数", 表达式)**

func main() { 
    	var num int = 99
    	var num2 float64 = 13.13
    	var b = false
    	var char byte = 'a'
    	var str = ""
    
    	str = fmt.Sprintf("%d", num)
    	str = fmt.Sprintf("%f", num2)
    	str = fmt.Sprintf("%t", b)
    	str = fmt.Sprintf("%c", num)
    	str = fmt.Sprintf("%d", char)
    
    	fmt.Printf("c=%q", str)
    }

**②使用 strconv 包的函数**

func main() { 
    	//var num int = 99
    	//var num2 float64 = 13.13
    	var b = false
    	//var char byte = 'a'
    
    	//str := strconv.FormatInt(int64(num), 10)
    	//str := strconv.FormatFloat(num2, 'f', 10, 64)
    	str := strconv.FormatBool(b)
    	fmt.Printf("str = %q", str)
    }

**string类型转基本数据类型**

**使用时 strconv 包的函数:**

func main() { 
    
    	var b = "false"
    	//strconv.ParseXxx()函数会返回两个值：bool, error，第一个为我们想要的值
    	parseBool, e := strconv.ParseBool(b)
    	fmt.Println(parseBool, e)
    }

## 9.指针 ##

案例：

func main() { 
    	i := 1
    	fmt.Println("i的值为：", i)
    	//&+变量代表变量的地址
    	fmt.Println("i的地址为：", &i)
    	//ptr是一个指针变量
    	var ptr *int = &i
    	fmt.Println("ptr的值：", ptr)
    	fmt.Println("ptr的地址为：", &ptr)
    	//*+变量代表对应地址变量的值
    	fmt.Println("ptr指向的值为：", *ptr)
    
    	*ptr = 2
    	fmt.Println("经指针修改后的i的值为", i)
    }

![在这里插入图片描述][20200517182001730.png]  
**指针使用的细节：**

*  值类型都有对应的指针类型，形式为`*数据类型`，比如`int`对应的指针就是`*int`，`float32`对应的指针就是`*float32`
 *  值类型包括基本数据类型`int`系列、`float`系列、`bool`、`string`、数组、结构体struct

## 10.值类型和引用类型 ##

**值类型**

包括基本数据类型`int`系列, `float`系列, `bool`, `string` 、数组和结构体`struct`

变量直接存储值，内存通常在栈中分配

**引用类型**

包括指针、`slice`切片、`map`、管道`chan`、`interface`等都是引用类型

变量存储的是一个地址，这个地址对应的空间才真正存储数据(值)，内存通常在堆  
上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由`GC`来回收

**内存的栈区和堆区示意图**  
![在这里插入图片描述][20200517183509257.png]

## 11.标识符的命名规范 ##

`Go`对各种变量、方法、函数等命名时使用的字符序列称为标识符

**标识符的命名规则**

1.  由 26 个英文字母大小写，0-9 ，\_ 组成
2.  数字不可以开头
3.  `Go`中严格区分大小写
4.  标识符不能包含空格
5.  不能以系统保留关键字作为标识符（一共有 25 个），比如`break`，`if`等等…

**系统保留关键字**  
![在这里插入图片描述][20200517184354628.png]

[20200513201846932.png]: /images/20230312/ab27d7db769a48d8a66efa3ec07258df.png
[20200514094516874.png]: /images/20230312/ec45bf7bcfd64d6d8db2c57e826cf339.png
[20200514095452732.png]: /images/20230312/d7d217972193418989df4c9f7cbbe7ae.png
[20200514100914935.png]: https://img-blog.csdnimg.cn/20200514100914935.png
[20200517182001730.png]: https://img-blog.csdnimg.cn/20200517182001730.png
[20200517183509257.png]: https://img-blog.csdnimg.cn/20200517183509257.png
[20200517184354628.png]: https://img-blog.csdnimg.cn/20200517184354628.png