「Go」Go语言变量和常量

不积跬步，无以至千里；不积小流，无以成江海。

码字不易，点赞再看。

变量和常量是编程中必不可少的部分。Go 语言是 静态类型 语言，由于编译时，编译器会 检查 变量的类型，所以要求所有的变量都要有 明确 的类型。

标识符与关键字

标识符

在编程语言中标识符就是程序员定义的具有特殊意义的词，比如变量名、常量名、函数名等等。 Go语言中标识符由字母数字和_(下划线）组成，并且 只能 以 字母 和 _ 开头。 举几个例子：abc, _, _123, a123。

关键字

关键字是指编程语言中预先定义好的具有特殊含义的标识符。

关键字和保留字都不建议用作变量名。

Go语言中有25个关键字：

<code>    
break
        
default
      
func
         
interface
    
select

    
case
         
defer
        
go
           
map
          
struct
    
chan
         
else
         
goto
         
package
      
switch
    
const
        
fallthrough
  
if
           
range
        
type
    
continue
     
for
          
import
       
return 
       
var
/<code>

此外，Go语言中还有37个保留字。

<code>Constants:    
true
  
false
  
iota
  
nil

   Types:    
int
  
int8
  
int16
  
int32
  
int64
  
uint
  
            
uint8
  
uint16
  
uint32
  
uint64
  
uintptr
            
float32
  
float64
  
complex128
  
complex64
 
            
bool
  
byte
   
rune
  
string
  error
            
Functions:   
make
  
len
  
cap
  
new
  
append
  
copy
  
close
 
            
delete
 
complex
  
real
  
imag
 
panic
  
recover
/<code>

变量

Go语言中的变量需要先声明后使用，并且Go语言的变量声明后 必须 使用。同一 作用域内 不支持 重复声明。 声明了类型，就约定了变量只能赋该类型的值。

标准声明

Go语言的变量声明格式为：

var 变量名 变量类型

变量声明以关键字 var 开头，变量类型放在变量的后面，行尾 无需 分号。 举个例子：

<code>
var
 name 
string
var
 age  
int
var
 isOk 
bool
/<code>

批量声明

声明多个变量，除了可以按照上面写成多行之外，go语言中还支持批量变量声明：

<code>
var
 (
    name 
string
    age 
int
    sex
)
/<code>

变量的初始化

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值比如:

1. 字符串变量的默认值为 空字符串
2. 整型 和 浮点型 变量的默认值为 0
3. 布尔型变量默认为 false
4. 切片、函数、指针变量的默认为 nil

我们也可在声明变量的时候为其指定初始值。变量初始化的标准格式如下：

var 变量名 类型 = 表达式

例如：

<code>
var
 name 
string
 = 
"王老师"

var
 age  
int
 = 
18

/<code>

或者一次初始化多个变量

<code>
var
 name, age = 
"王老师"
, 
18

/<code>

注意：

Go 中双引号 和 单引号是 不一样 的，这里要一定要使用双引号，表示字符串，而在单引号表示 rune 类型的字符

类型推导

有时候我们会将变量的类型 省略，这个时候编译器会根据等号右边的值来 推导 变量的类型完成初始化。

例如：

<code>
var
 name = 
"王老师"

var
 age  = 
18

/<code>

短变量声明

在函数 内部 ，可以使用更简略的 := 方式声明并初始化变量。

<code>
package
 main

import
 (
	
"fmt"
)
 
var
 m = 
100

func
 
main
() 
 {
	n := 
10
	m := 
200
  
	fmt.Println(m, n)
}

/<code>

匿名变量

匿名变量（anonymous variable），也称作占位符，或者空白标识符,通常我们用匿名接收必须接收，但是又不会用到的值。 匿名变量用一个 下划线 _ 表示，例如：

<code>
func
 
foo
()
 
(
int
, 
string
)
 {
	
return
 
18
, 
"王老师"
}
func
 
main
()
 {
	x, _ := foo()
	_, y := foo()
	fmt.Println(
"x="
, x)
	fmt.Println(
"y=" 
, y)
}
/<code>

匿名变量，优点有三：

• 不分配内存，不占用内存空间
• 不需要你为命名无用的变量名而纠结
• 多次声明不会有任何问题

注意：

函数外的每个语句都必须以 关键字开始（var、const、func等） := 不能使用在函数外。 _ 多用于占位，表示忽略值。

常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把 var 换成了 const，常量在定义的时候必须赋值。

<code>
const
 pi = 
3.1415
const
 e = 
2.7182
/<code>

声明了pi和e这两个常量之后，在整个程序运行期间它们的值都不能再发生变化了。

多个常量也可以一起声明：

<code>
const
 
(
    
pi
 = 
3.1415
    
e
 = 
2.7182
)
/<code>

const同时声明多个常量时，如果省略了值则表示和上面一行的值 相同。 例如：

<code>
const
 
(
    
n1
 = 
100
    
n2
    
n3
)
/<code>

上面示例中，常量n1、n2、n3的值都是100。

iota

iota 是go语言的常量 计数器，只能 在常量的表达式中使用。

iota 在const关键字出现时将被 重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。

例如：

<code>
const
 (
		n1 = 
iota
  
		n2         
		n3         
		n4         
	)
/<code>

几个常见的iota示例:

使用_跳过某些值

<code> 
const
 (
		n1 = 
iota
  
		n2         
		_
		n4         
	)
/<code>

iota 中间插队

<code>
const
 (
		n1 = 
iota
  
		n2 = 
100
   
		n3 = 
iota
  
		n4         
	)
	
const
 n5 = 
iota
  
/<code>

多个iota定义在一行

<code>
const 
 (
		a, b = 
iota
 + 
1
, 
iota
 + 
2
  
		c, d                      
		e, f                      
	)
/<code>

点关注 不迷路

如果你从本篇内容有收获，求 点赞，求 关注，求 转发 ，让更多的人学习到。

如果本文有任何错误，请批评指教，不胜感激