三、Golang 变量

zoukankan html css js c++ java

三、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 变量使用注意事项
- 变量表示内存中的一个存储区域
- 该区域有自己的名称(变量名)和类型(数据类型)
- Golang变量使用的三种方式
  
  第一种：指定变量类型，声明后若不赋值，使用默认值
  
  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) }
  
  第三种：省略var 注意： =左侧的变量不应该是已经声明过的，否则会导致编译错误
  
  package main import "fmt" func main(){ // 第三种：省略var 注意： =左侧的变量不应该是已经声明过的，否则会导致编译错误 // 下面的方式等价于 var name string name = "tom" // := 的 : 不等省略，否则就错误 name := "tom" fmt.Println("name=",name) }
- 多变量声明
  
  在编程中，有时我们需要一次声明多个变量，Golang也提供这样的语法
  
  package main import "fmt" func main(){ //演示golang如何一次声明多个变量 var n1,n2,n3 int fmt.Println("n1=",n1,"n2=",n2,"n3=",n3) }
  
  如何一次性声明多个全局变量(在go中函数外部定义的变量就是全局变量)
- 该区域的数据值可以在同一个类型范围内不断变化
  
  package main import "fmt" func main(){ var i int = 10 i = 30 i = 50 fmt.Println("i=",i) }
- 变量在同一个作用域内不能重名
- 变量 = 变量名+值+数据类型
- Golang的变量如果没有赋初值，编译器会使用默认值，比如int默认值0 string默认值为空串小数默认为0
程序中 + 号的使用
- 当左右两边都是数值型时，则做加法运算
- 当左右两边都是字符串，则做字符串拼接
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 浮点型使用细节
- Golang浮点型有固定的范围和字段长度，不受具体的OS影响
- Golang的浮点型默认声明为float64类型
  
  var num5 = 1.1 fmt.Printf("num5的数据类型是 %T ",num5)
- 浮点型常量有两种表示形式
  
  十进制数形式如：5.12 .521(必须有小数点)
  
  num6 := 5.12 num7 := .512 //=>0.512
  
  科学计数法形式如： 5.1221e3
  
  num8 := 5.1234e2 // 等价于 5.1234 * 10的2次方
- 通常情况下，应该使用 float64 因为它比 float32更精准(开发中，推荐使用 float64 )
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 = ' ' ：表示换行符
- 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
",str ,str)

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

	 str = fmt.Sprintf("%t",b)
	 fmt.Printf("str type %T str=%q
",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
",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）仍然通过首字母的大小来控制常量的访问范围
查看全文

相关阅读:
MySQL索引原理
 MyBatis执行流程的各阶段介绍
 实现单栈实现支持getMin的栈
 缓存LRU算法——使用HashMap和双向链表实现
 Hystrix资源隔离
 各种负载均衡策略-图解
 接口调用超时的实现原理
 Spring Bean生命周期的各阶段介绍
 TAR命令详解复习
 INT MOD

原文地址：https://www.cnblogs.com/jiaxiaozia/p/13034169.html

三、Golang 变量

3.1 为什么需要变量

3.1.1一个程序就是一个世界

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

3.2 变量介绍

3.2.1 变量的概念

3.2.2 变量的使用步骤

3.3 变量快速入门案例

3.4 变量使用注意事项

3.5 变量的数据类型

3.6 整数类型

3.6.1 基本介绍

3.6.2 整型的使用细节

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

3.7.1 基本介绍

3.7.2 小数类型分类

3.7.3 浮点型使用细节

3.8 字符类型(char)

3.8.1 基本介绍

3.8.2 字符类型使用细节

3.8.3 字符类型本质讨论

3.9 布尔类型(bool)

3.9.1 基本介绍

3.10 字符串类型(string)

3.10.1 基本介绍

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

3.11 基本数据默认值

3.11.1 基本介绍

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

3.12 基本数据类型的转换

3.12.1 介绍

3.12.2 基本语法

3.12.3 细节说明

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

3.13.1 介绍

3.13.2 基本类型转string类型

3.13.3 string 类型转基本数据类型

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

3.14 指针

3.14.1 基本介绍

3.14.2 指针案例

3.14.3 指针的使用细节

3.15 值类型和引用类型

3.15.1 值类型和引用类型说明

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

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

3.16.1 标识符概念

3.16.2 标识符的命名规则

3.16.3 标识符命名注意事项

3.17 系统保留关键字!

3.18 系统的预定义标识符

3.19 打印格式化

3.19 常量