go基础语法之变量与常量

go基础语法之变量与常量

标识符与关键字

标识符

标识符开发程序时定义的具有特定含义的词,如:变量名、常量名、函数名等...

​ 组成由:字母、数字、下划线_组成,只能以字母和下划线_开头

​ 例如:abc _123 a123

关键字

关键字时编程语言中保留定义好的具有特定含义的字符,关键字和保留字都不可用作变量名;

go的25个关键字

	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

go的37个保留字

 		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	

变量

变量是什么

​ 程序中的数据,都以二进制方式,存储在内存的某个地址中,操作数据时,需要指明数据所在的内存地址,而内存地址的标识较为繁琐,因此给内存地址起个名字,就是变量名,变量名对应的就是内存地址;

变量类型

​ 变量的作用,存储数据,数据又分多种不同的类型,常见又:整型、浮点型、布尔型、字符型、字符串型;

​ go中,每个变量都必须有一个类型,且变量必须先声明,再使用;

变量声明

  • go变量声明后,才可使用;
  • 且,声明后必须使用;
  • 同一个作用域内,不可重复使用;

标准声明

格式:

var 变量名 变量类型

示例:

var name string
var age int
var isOk bool

批量声明

go支持一个关键字var,声明多个变量,简化代码:

var (
	a string
	b int
	c boo
	d float32
)

变量的初始化

go在声明一个变量时,会自动对变量所在内存区进行初始化,每个变量的值会被初始化该类型的默认值:如:整型和浮点型默认值是:0;字符串变量默认值是:空字符串;布尔型变量值默认值是:false;切片、函数、指针默认为nil;

  1. 声明变量同时赋值;

    格式:
    var 变量名 类型 = 值表达式
       
    示例:
    var name string = "wang"
    var age int = 18
       
    批量初始化:
    var name,age = "wang", 18
    
  2. 类型推导;

    省略变量的类型时,编译器会根据=右边表达式推导变量的类型,完成初始化;

    var name = "wang" 推导为string类型
    var age  = 18 	  推导为int类型
    
  3. 短变量声明;

    在函数内部,:=可以更简洁的初始化变量

    package main
       
    import (
     "fmt"
    )
    // 全局变量m,且使用了类型推导
    var m = 100
       
    func main () {
     n := 10
     m := 20 // 此处为局部变量m
     fmt.Println(m,n)
    }
    
  4. 匿名变量;

    多重赋值时,想忽略某值,可以用匿名变量anonymous variable,匿名变量用下划线_表示

    匿名变量,不占用命令空间、不分配内存、匿名变量不存在重复声明

    示例:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    
    package main
       
    import (
     "fmt"
    )
    func foo(){
     return 10,"wang"
    }
       
    func main(){
     x,_ := foo()
     _,y := foo()
     fmt.Println("x=",y)
     fmt.Println("y=",y)
    }
    

注意事项

  • 函数外,每个语句,需以关键字开头;var、const、func等;
  • := 不能在函数外使用;
  • _ 多用于占位,表示想忽略的值;

常量

常量,即程序运行期间不会改变值的量,参数声明和变量一致,只需把var换为const,常量定义时必须赋值

demo1:

const pi = 3.14
const e = 2.7182

demo2:批量声明

const (
	pi = 3.14
	e = 2.7
)

demo3:批量声明时,忽略值的常量,则和上面一行相同

1
2
3
4
5
const (
	n1 = 100
	n2
	n3
)

demo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main

import "fmt"

const (
	n = 100
	m = 200
)

const (
	i = 10
	j
)
// j和i 同值
func main() {
	fmt.Println(n)
	fmt.Println(m)
	fmt.Println(i)
	fmt.Println(j)

}
// go build 后输出
D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
100
200
10
10

iota

iota是go中常量的计数器,只能在常量的表达式中用;

iota在const关键字出现时将被重置为0,const中每新增一行常量声明将使得iota计数加一,**iota可理解为const语句块中的行索引,**定义枚举时可用

1
2
3
4
5
6
7
8
9
const (
	n1 = iota 	//0
    n2 			//1
    n3			//2
    n4 			//3
)

// 根据规则,n2到n4没定义时默认和上一行保持相同,即都是iota,而iota每多一行常量定义,就+1,所以 n1 n2 n3 内
分别是 0  3
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main

import "fmt"

// iota demo

const (
	n1 = iota
	n2
	n3
	n4
)

func main() {
	fmt.Println(n1)
	fmt.Println(n2)
	fmt.Println(n3)
	fmt.Println(n4)
}

D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
0
1
2
3

iota示例

  1. iota之间插入值

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    
    package main
       
    import "fmt"
    const (
     n1 = iota // 0
     n2 = 100 // 100
     n3 = iota // 2
     n4 			// 3
    )
       
    func main() {
     fmt.Println(n1)
     fmt.Println(n2)
     fmt.Println(n3)
     fmt.Println(n4)
    }
       
       
    D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
    0
    100
    2
    3
    
  2. ​ 使用_ 跳过某些不需要的值

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    
    const (
     n1	=	iota
     _	
     n3	
     n4
    )
       
    func main() {
     fmt.Println(n1)
    //	fmt.Println(n2)
     fmt.Println(n3)
     fmt.Println(n4)
    }
       
       
    D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
    0
    2
    3
    
  3. 定义数量级

    << 表示对二进制数的左移操作,

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    
    const (
     _  = iota
     kb = 1 << (10 * iota)
     mb = 1 << (10 * iota)
     gb = 1 << (10 * iota)
    )
    // 0 赋值给_
    // kb 值表达式意思是:1的二进制表示,向左移动10位,即1变成了1后加10个0,即2的十次方,即1024,kb的大小
    // mb 表达式意思:1 的二进制表示,向左移动 20位,即1变成了1后加20个0,即2的二十次放,即mb的大小
    // gb 表达式意思:1 的二进制表示,向左移动 30位,即1变成了1后加30个0,即2的三十次方,即gb的大小
    func main() {
     // fmt.Println(n1)
     // //	fmt.Println(n2)
     // fmt.Println(n3)
     // fmt.Println(n4)
     fmt.Println(kb)
     fmt.Println(mb)
     fmt.Println(gb)
    }
    D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
    1024
    1048576
    1073741824
    
  4. 一行中,使用多个iota

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    
    const (
     a, b = iota + 1, iota + 2 // 同属于一行,2个表达式里的iota值一样,都是0
     c, d
     e, f
    )
       
    func main() {
     fmt.Println(a)
     fmt.Println(b)
     fmt.Println(c)
     fmt.Println(d)
     fmt.Println(e)
     fmt.Println(f)
    }
    D:\workstation\mycode\gocode\src\learngo\basic_grammar\02const>02const.exe
    1
    2
    2
    3
    3
    4
    
updatedupdated2020-12-282020-12-28
加载评论