1.1Golang变量和常量 - Golang教程网

标识符和关键字

注意：

函数外只能放标识符（变量常量函数类型）声明
语句不能放在函数外
函数外的每个语句都必须以关键字开始（var、const、func等）

标识符

标识符就是在编程中具有特殊意义的词，比如变量名，常量名，函数名等。Go语言中标识符由字母，数字和下划线组成，而且不能以数字开头。

关键字

关键字是指编程语言中预先定义好的具有特殊含义的标识符。关键字和保留字都不建议用作变量名。

Go语言中有25个关键字：

break        default      func         interface    selectcase         defer        go           map          structchan         else         goto         package      switchconst        fallthrough  if           range        typecontinue     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

变量

格式：

var 变量名变量类型

Go语言中的变量必须先声明再使用。在Go中推荐使用小驼峰命名法，即第一个单词首字母小写，第二个单词首字母大写，

例如：

studentName

注意：

全局变量是定义在函数外部的变量
Go语言非全局变量声明必须使用，不使用就编译不过去
最简单的使用就是印同一个作用域中（一对{}）不能重复声明同名（相同的名字）的变量

标准声明：

var name    stringvar age     intvar a1      bool

批量声明变量

var (    name string    age  int    a1   bool  )

输出：

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。(开辟了内存空间)每个变量会被初始化成其类型的默认值.

例如：

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

变量初始化

格式：

var 变量名类型 = 表达式

声明时赋值

var name3 string = "宝宝"
var a, b int = 2, 4
var c, d = true, "baobao"

类型推导

根据值判断该变量是什么类型

var hobby = "lanqiu"

简短变量声明

只能在函数内使用

name := "宝宝"

匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量。匿名变量用一个下划线 _ 表示。

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

用处：

如果一个函数的返回值有两个，而我们只需要使用一个变量，这时就用到了匿名变量。
若没有匿名变量的话就会报错，这里匿名变量就起到了一个占位的用处。

上代码：

func f1() (int, string) {  return 18, "宝宝"}func main() {  x, _ := f1()  _, y := f1()  fmt.Println("x=", x)  fmt.Println("y=", y)}

结果：

变量使用方法

在函数外，我们通常会使用批量声明对象的方式来声明变量
在函数内通常会使用简短变量声明的方式来声明变量，特定情况下使用var关键字声明变量

上代码：

package main
import "fmt"//批量声明变量var (  name string  // ""  age int      // 0  ha bool     // false)
func main()  {  name = "宝宝"  age = 18  ha = true  // Go语言中，变量定义后就必须使用，否则无法进行编译  fmt.Print(ha)  // 输出要打印的内容  fmt.Println()  // 打印换行  fmt.Println(age)  // 打印完指定的内容后会在后面添加一个换行符  fmt.Printf("name:%s",name)  // %s:占位符，使用name去替换这个占位符  fmt.Println()  // 声明变量同时赋值  var gender string = "男"  fmt.Println(gender)  // 类型推导（根据值判断该变量是什么类型）  var hobby = "篮球"  
  fmt.Println(hobby)  // 简短变量声明,只能在函数中使用  job := "王子"  fmt.Println(job) }

输出：

常量

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

常量定义之后不能修改，在程序运行期间常量不会改变

单个声明常量

const pai = 3.1415926

批量声明常量

const (

city = "Shanghai"

name = "宝宝"

)

批量声明常量时，如果某一行声明后没有赋值，默认就和上一行一致

隐含的意思就是值和类型一样

上代码：

package main
import "fmt"

const (  name3 = 6  name4  name5)
func main() {    // %T 打印类型   %v打印值  fmt.Printf("name3的类型：%T \t name3的值：%v\n",name3,name3)   fmt.Printf("name4的类型：%T \t name4的值：%v\n",name4,name4)   fmt.Printf("name5的类型：%T \t name5的值：%v\n",name5,name5)   }

输出：

iota用法

iota是go语言中的常量计数器，只能在常量的表达式中使用
iota在const关键字出现时将被重置为0
const中每新增一行常量声明，iota就会计数一次
使用iota能简化定义，在定义枚举时很有用

上代码：

package main

import "fmt"

func main(){  const (    a = iota    b    c  )

  fmt.Println(a)  fmt.Println(b)  fmt.Println(c)}

输出：

多个常量声明在一行

只有每新增一行iota的值才会加1，当多个常量在一行时，iota的值不会改变

上代码：

packagemain
import"fmt"
func main() {  const (    s1,s2=iota+1,iota+2   //这一行的iota值为0    s3,s4=iota+1,iota+2   //这一行的iota值为1  )  fmt.Println(s1)  // 1  fmt.Println(s2)  //2  fmt.Println(s3) //2  fmt.Println(s4) //3}

结果：

利用iota定义数量级

讲解：

_ = iota 代表将0丢弃

KB = 1 << (10 * iota)

<< 表示左移

1 << (10 * iota)代表将1向前移动（10iota）位，即向前移动10位，移动后为10000000000，转换为10进制数即为1024

同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8

const (    _  = iota  //这一行的iota值为0    KB = 1 << (10 * iota) //这一行的iota值为1    MB = 1 << (10 * iota) //这一行的iota值为2    GB = 1 << (10 * iota) //这一行的iota值为3    TB = 1 << (10 * iota) //这一行的iota值为4    PB = 1 << (10 * iota) //这一行的iota值为5  )

iota常见的例子

上代码：

代码中的注释为结果

const (    a1 = iota //0    a2        //1    _    a4        //3  )

const (    a1 = iota //0    a2 = 1000  //1000    a3 = iota //2    a4        //3  )

const (    a, b = iota + 2, iota + 3 //2,3    c, d                      //3,4    e, f                      //4,5  )

const (    q = 2      //2    w = iota   //1    e = 100    //100    g          //100    r = iota   //4  )

const (    a9 = iota //0    q1 = 2    //2    w1 = iota //2    e1 = 100  //100    g1        //100    r1 = iota //5)

CSDN博客地址：

https://blog.csdn.net/cc20172019?spm=1000.2115.3001.5343

个人号：