三、Golang 变量 - Golang教程网

3.1 为什么需要变量

3.1.1一个程序就是一个世界

3.1.2变量是程序的基本组成单位

不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位

3.2 变量介绍

3.2.1 变量的概念

变量相当于内存中一个数据存储空间的表示，你可以把变量看作是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量(值)
变量是计算机语言中存储数据的抽象概念。变量的功能是存储数据。变量通过变量名访问。
变量的本质是计算机分配的一小块内存，专门用于存放指定数据，在程序运行过程中该数值可以发生改变。
变量的存储往往具有瞬时性，或者说是临时存储，当程序运行结束，存放该数据的内存就会释放，而该变量就会消失。
Go语言的变量名是由数字，字母，下划线组成，首个字符不能为数字。

3.2.2 变量的使用步骤

1）声明变量(定义变量)

未初始化的标准格式

var 变量名 变量类型

未初始化的批量格式

不用每行都用var 申明

var (

      a int

      b string

      c[]float32

      d func() bool

      e struct{

      x int

      y string

      }

)

未初始化变量的默认值

      整行和浮点型变量默认值： 0

      字符串默认值为空字符串

      布尔型默认值为false

      函数，指针变量初始值为nil

初始化变量的标准格式

      var 变量名 类型 = 表达式

初始化变量的编译器自动推断类型格式

      var 变量名 = 表达式

初始化变量的简短声明格式(短变量声明格式)

      变量名:= 表达式

      使用 := 赋值操作符，:=可以高效地创建一个新的变量，称之为初始化声明。

      声明语句省略了var关键字

      变量类型将由编译器自动推断

      这是声明变量的首选形式，但是它只能被用在函数体内，而不可以用于全局变量的声明与赋值

      该变量名必须是没有定义过的变量名，若定义过，将发生编译错误

      在多个短变量声明和赋值中，至少有一个新声明的变量出现在左侧中，那么即便有其他变量名可能是重复声明的，编译器也不会报错

变量多重赋值(多个变量同时赋值)

      Go语法中，变量初始化和变量赋值是两个不同的概念，Go语言的变量赋值与其他语言一样，但是Go提供了其他程序员期待已久的多重赋值功能，可以实现变量交换。多重赋值让Go语言比其他语言减少了代码量

匿名变量

      Go语言的函数可以返回多个值，而事实上我们并不是对所有的返回值都用得上，那么就可以使用匿名变量，使用"_"下划线替换即可

匿名变量不占用命名空间，不会分配内存

2）变量赋值

3）使用变量

3.3 变量快速入门案例

看一个案例：

package main

import "fmt"
func main(){
	// 定义变量、声明变量
	var i int 
	// 给 i 赋值
	 i = 10
	// 使用变量
	fmt.Println("i=",i)
}

3.4 变量使用注意事项

package main

import "fmt"
func main(){
	// 第一种：指定变量类型，声明后若不赋值，使用默认值
	// int 的默认值是0 
	var i int
	fmt.Println("i=",i)
}

package main

import "fmt"
func main(){
	// 第二种：根据值自行判定变量类型(类型推导)
	var  num = 10.11
	fmt.Println("num=",num)
}

package main

import "fmt"
func main(){
	// 第三种：省略var  注意： =左侧的变量不应该是已经声明过的，否则会导致编译错误
	// 下面的方式等价于  var name string  name = "tom"
	// := 的  :  不等省略，否则就错误
	name := "tom"
	 fmt.Println("name=",name)
}

package main

import "fmt"
func main(){
	//演示golang如何一次声明多个变量
	 var n1,n2,n3 int
    fmt.Println("n1=",n1,"n2=",n2,"n3=",n3)
}

package main

import "fmt"

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

程序中 + 号的使用

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

3.5 变量的数据类型

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间

3.6 整数类型

3.6.1 基本介绍

简单的说，就是用于存放整数值的，比如：0 1 2 3

3.6.2 整型的使用细节

Golang各整数类型分：有符号和无符号，int unit 的大小和系统有关
Golang的整型默认声明为 int型
如何在程序中查看某个变量的字节大小和数据类型(使用比较多)
Golang程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量使用占空间小的数据类型
bit：计算机中的最小存储单位，byte:计算机中基本存储单元，

3.7 小数类型/浮点型(int)

3.7.1 基本介绍

小数类型就是用于存放小数的，比如1.2 0.123 0.35525

3.7.2 小数类型分类

对上图的说明：

1）关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位

说明：浮点数都是有符号的

2）尾数部分不能丢失，造成精度损失 -123.000001233

说明：float64 的精度比 float32 的要准确

说明：如果我们要保存一个精度搞的数，则应该选用 float64

3）浮点型的存储分为三部分：符号位 + 指数位 + 尾数位在存储过程中，精度会有丢失

3.7.3 浮点型使用细节

var num5 = 1.1
fmt.Printf("num5的数据类型是 %T \n",num5)

num6 := 5.12
num7 := .512  //=>0.512

num8 := 5.1234e2   // 等价于  5.1234 * 10的2次方

3.8 字符类型(char)

3.8.1 基本介绍

Golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用byte来保存

字符串就是一窜固定长度的字符连接起来的字符序列，Go字符串是单个字节连接起来的，也就是对于传统的字符串组成的。而Go的字符不同，它是由字节组成的[官方将 string 归属到基本数据类型：https://tour.go-zh.org/basics/11]

func main(){
    var c1 byte = 'a'
    var c2 byte = '0'  //字符的0
    
    //当我们直接输出byte值，就是输出了的对应的字符的码值
    
    fmt.PrintIn("c1=",c1)
    fmt.PrintIn("c2=",c2)
   	//如果我们希望输出对应字符，需要使用格式化输出
    fmt.Printf("c1=%c  c2=%c",c1,c2)
    
    //var c3 byte = '北' //overflow溢出
    var c3 int = '北'  //overflow溢出
    fmt.Printf("c3=%c c3对应码值=%d",c3,c3)
}

对上面代码说明

1）如果我们保存的字符在ASCII表的比如[0-1,a-z,A-Z]直接可以保存到byte

2)如果我们保存的字符对应码值大于 255这时我们可以考虑使用int类型保存

3）如果我们需要按照字符的方式输出，这时我们需要格式化输出，即 fmt.Printf("%c",c1)

3.8.2 字符类型使用细节

字符常量是用单引号('')括起来的单个字符，例如：var c1 byte = 'a'
Go中允许使用转义字符 ' \ '来将其后的字符变为特殊字符类型常量，例如： var c3 char = '\n' \n：表示换行符
Go语言的字符使用UTF-8编码
- 英文字母 1个字节
- 汉子 3个字节
在Go中，字符懂得本质是一个整数，直接输出时，是该字符对应的UTF-8编码的码值
可以直接给某个变量赋一个数字，然后按格式化输出时 %c，会输出该数字对应的unicode 字
字符类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码

3.8.3 字符类型本质讨论

字符类型存储到计算机中，需要将字符对应的码值(整数)找出来

存储：字符->对应码值->二进制->存储
读取：二进制->码值-> 字符->读取

字符和码值的对应关系是通过字符编码表决定的(是规定好的)

Go语言的编码都统一成了UTF-8，非常的方便，很统一，再也没有编码乱码的困扰了

3.9 布尔类型(bool)

3.9.1 基本介绍

布尔类型也叫bool类型。bool类型数据只允许取值true和false
bool类型占1个字节
boolean 类型适用于逻辑运算，一般用于程序流程控制，
- if条件控制语句
- for循环控制语句

package main

import (
 	"fmt"
    "unsafe"
)
func main(){
	var  b = false
	fmt.Println("b=",b)
    	//注意事项：
   	 	//1.bool类型占用存储空间是1个字节
    	fmt.Println("b 的占用空间 = ",unsafe.Sizeof(b) )
    	//2.bool类型只能取true或者false
}

3.10 字符串类型(string)

3.10.1 基本介绍

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

package main

import "fmt"
func main(){
	//string的基本使用
	var address string = "北京长城  110  hello world!"
	fmt.Println(address)
}

3.10.2 字符串注意事项和使用细节

Go语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用UTF-8编码，乱码问题不会再困扰程序员
字符串一旦赋值了，字符串就不能修改了，在Go中字符串是不可变的
字符串的两种表示形式
- 双引号，会识别转义字符
- 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击，输出源代码等效果
字符串拼接方式 拼接时要把 '+' 保留在上一行即可
当一行字符串太长时，需要使用到多行字符串

package main

import "fmt"
func main(){
	//string的拼接
	var str = "hello" + "world"
	str += " haha!"
	fmt.Println(str)
	//当一个拼接的操作很长时，可以分行写,但是注意，需要将+保留在上一行即可
	var str2 = "hello" + "world" + 
	"hello" + "world" + 
	"hello" + "world"
	fmt.Println(str2)
}

3.11 基本数据默认值

3.11.1 基本介绍

在go中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在go中，默认值又叫零值

3.11.2 基本数据类型的默认值如下

案例：

package main

import "fmt"
func main(){
	var a int    //0
	var b float32  //0
	var c float64  //0
	var isMarryied  bool   //false
	var name string   // ""
	//这里的  %v 表示按照变量的值输出
    fmt.Printf("a=%d,b=%v,c=%v,isMarried=%v,name=%v",a,b,c,isMarryied,name)
}

运行结果为：

a=0,b=0,c=0,isMarried=false,name=

3.12 基本数据类型的转换

3.12.1 介绍

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

3.12.2 基本语法

表达式T(v)，将值 v转换为类型T

T：就是数据类型，比如：int32，int64，float32等

v：就是需要转换的变量

案例：

package main

import "fmt"
func main(){
	var i int = 100
	//希望将 i => float
	var n1 float32 = float32(i)
	var n2 int8 = int8(i)
	fmt.Printf("i=%v n1=%v n2=%v",i,n1,n2)
}

3.12.3 细节说明

Go中，数据类型的转换可以是从表示范围小-->表示范围大,也可以范围大-->范围小
被转换的是变量存储的数据(即值)，变量本身的数据类型没有变化
在转换中，比如将int64转换成int8，编译时不会报错，只是转换的结构时按溢出处理，和我们希望的结果不一样，因此在转换时，需要考虑范围

3.13 基本数据类型和string的转换

3.13.1 介绍

在程序开发中我们经常需要将基本数据类型转换成string类型

或者将string类型转换成基本数据类型

3.13.2 基本类型转string类型

方式1：fmt.Sprintf("%参数",表达式) var str string

参数需要和表达式的数据类型相匹配
fmt.Sprintf() .. 会返回转换后的字符串

package main

import "fmt"
func main(){
	var num1 int = 99
	var num2 float64 = 23.456
	var b bool = true
	var myChar byte = 'h' 
	var str string  //空的string 

	//使用第一种方式转换，fmt.Sprintf方法
	 str = fmt.Sprintf("%d",num1)
	 fmt.Printf("str type %T str=%q\n",str ,str)

	 str = fmt.Sprintf("%f",num2)
	 fmt.Printf("str type %T str=%q\n",str ,str)

	 str = fmt.Sprintf("%t",b)
	 fmt.Printf("str type %T str=%q\n",str ,str)

	 str = fmt.Sprintf("%c",myChar)
	 fmt.Printf("str type %T str=%q",str ,str)
}

方式2：使用 strconv包的函数

3.13.3 string 类型转基本数据类型

使用时 strconv包的函数

说明：

note：因为返回的是int64或者float64 ,如希望要得到int32 float32等如下处理

var num5 int32
num5 = int32(num)

3.13.4 string转基本数据类型注意事项

在将string类型转换成基本数据类型时，要确保string类型能够赚长城有效的数据，比如我们可以把"123" 转成一个整数，但是不能把 "hello"转成一个整数，如果是这样做，Golang直接将其转成0，其他类型也是一样的道理：float=>0 bool=>false

var str4 sring = "hello"
var n3 int64 = 11
n3,_ = strconv.ParseInt(str4,10,64)
fmt.Printf("n3 type %T n3=%v\n",n3,n3 )

3.14 指针

3.14.1 基本介绍

基本数据类型，变量存的就是值，也叫值类型
获取变量的地址，用&，比如：var num int 获取num的地址：&num

分析一下基本数据类型咋内存的布局
指针类型，指针变量存的是一个地址，这个地址只想的空间存的才是值，比如：var ptr *int = &num

示例：

获取指针类型所指的值，使用：* 比如：var ptr *int，使用 *ptr 获取 ptr指向的值

举例说明：
- var num int =1
- var i =99
- var ptr *int = &i

3.14.2 指针案例

案例：

写一个程序，获取一个个int变量num的地址，并显示到终端
将num的地址赋给指针ptr，并通过ptr去修改num的值

原因解释：

课堂练习

3.14.3 指针的使用细节

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

3.15 值类型和引用类型

3.15.1 值类型和引用类型说明

值类型：基本数据类型int系列，float系列，bool，string，数组和结构体struct
引用类型：指针，slice切片，map，管道chan，interface等都是引用类型

3.15.2 值类型和引用类型使用特点：

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

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

内存的栈区和堆区示意图

3.16 标识符的命名规范 ( “重点” )

3.16.1 标识符概念

Golang 对各种变量，方法，函数等命名时使用的字符序列称之为标识符
凡是自救可以起名字的地方都叫标识符

3.16.2 标识符的命名规则

由26哥英文字母大小写，0-9，_组成
数字不可以开头
Golang中严格区分大小写
- var num int
- var Num int
说明：在Golang中，num和Num是两个不同的变量
标识符不能包含空格
下划线 ” “本身在Go中是一个特殊的标识符，称之为空标识符可。可以代表任何其他的标识符，但是它对应的值会被忽略(比如：忽略某个返回值)，所以仅能被作为占位符使用，不能作为标识符使用

 // _  是空标识符，用于占用

不能以系统 保留关键字 作为标识符(一共25个)，比如：break、if 等

3.16.3 标识符命名注意事项

包名：保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和标准库有冲突

变量名、函数名、变量名、采用驼峰法

// 示例:
var stuName string = 'tom'
var goodPrice float32 = '1234.5'

如果变量名，函数名、常量名首字母大写，则可以被其他的包访问，如果首字母小写，则智能在本包中使用(注：可以简答的理解成，首字母大写是公有的(public)，首字母小写是私有的(private) ，在golang中没有public private等关键字。

3.17 系统保留关键字!

3.18 系统的预定义标识符

3.19 打印格式化

通用

      %v 值的默认格式表示

      %+v 类似%v，但输出结构体时会添加字段名

      %#v 值的Go语法表示

      %T 值的类型的Go语法表示

布尔值

      %t 单词 true 或 false

整数

      %b 表示为二进制

      %c 该值对应的unicode码值

      %d 表示为十进制

      %8d 表示该整型长度是8，不足8则在数值前补空格。如果超出8，则以实际为准。

      %08d 数字长度是8，不足8位的，在数字前面补0。如果超出8，则以实际为准

      %o 表示为八进制

      %q 该数值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示

      %x 表示为十六进制，使用a-f

      %X 表示为十六进制，使用A-F

      %U 表示为Unicode格式，U+1234等价于"U+%04x" unicode

浮点数与复数的两个组分

      %b 无小数部分，二进制指数的科学计数法，如-123456p-78;参见strconv.FornatFloat

      %e (=%.6e)有6位小数部分的科学计数，如-1234.456e+78

      %E 科学计数法，如-123.456+78

      %f (=%.6f)有6位小数部分，如：123.456.12 float

      %F 等价于%f

      %g 根据实际情况采用%e或%f格式(以获得更简洁，准确的输出)

      %G 根据实际情况采用%E或%F格式(以获得更简洁，准确的输出)

3.19 常量

介绍

常量使用const修改
常量在定义的时候，必须初始化
常量不能修改
常量只能修饰bool、数值类型(int，float系列)、string类型
语法：const 变量名 [type] = value

常量使用注意事项

3）Golang中没有常量名，必须字母大写的规范比如：TAX_RATE

4）仍然通过首字母的大小来控制常量的访问范围