【Go语言学习】——Go语言的变量和常量

Go语言的变量和常量

---

参考博客

• 标识符：具有特殊意义的词，如变量名、常量名、函数名等，由字母、数据、下划线组成，且只能以字母和下划线为开头 。首字母大写的标识符表示对外部(暴露的，共有的)，当编写工具包需要开发给其他包使用的方法首字母大写。

• 关键字和保留字：具有特殊含义的标识符，关键字有25个，保留字有37个

• 使用:=声明并赋值变量时，只要左边有一个是新声明的变量就行，可以有已经声明过的变量，这种情况就只会声明新的变量，而已有变量只是赋值，常用于返回含有err的两个值时的情况，err重复使用其实只声明了一次。

  //关键字  
  	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           
  

    //保留字   
  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
  

• 变量：存储数据，包含有整型、浮点型、布尔型

  package main //GO语言的中的变量要先声明再使用  
  
  import "fmt"
  
  //单独声明变量 var 名称 类型
  // var name string
  // var age int
  // var isOK bool
  
  //批量声明变量，推荐使用驼峰式命名，第二个词的首字母大写如studentName
  var (
  	name string
  	age  int
  	isOk bool
  )
  //全局变量什么不使用会出现警告，但是可以编译，使用指复制并用在函数里
  
  func foo() (int, string) {
  	return 10, "Q1mi"
  }
  
  func main() {
  	name = "卡卡"
  	age = 16
  	isOk = true
      // var noUse String 函数里声明了局部变量但不使用，编译不能通过
  	
      //Go语言中声明的变量必须全部使用，否则编译不通过
  	fmt.Printf("name:%s\n", name) //%s是占位符，使用后面的变量值去代替，唯一可用占位符的打印
  	fmt.Println(age)              //打印并换行,不能使用占位符
  	fmt.Print(isOk)               //打印，不能使用占位符
      
      //声明并赋值
  	var s1 string = "Lkaak"
  	var s2 = "Morain" //根据赋值来判断声明变量类型
  	fmt.Print(s1)
  	fmt.Println()
  	fmt.Print(s2)
  	fmt.Println()
  
  	//简短声明变量,只能声明局部变量，推荐使用
  	s3 := "zq"
  	fmt.Println(s3)
      
      //匿名变量用_表示，在使用多重赋值时来忽略其中一个值
      x, _ := foo()
  	_, y := foo()
  	fmt.Println("x=", x)
  	fmt.Println("y=", y)
      
      //s3 := "lkc" 同一个作用域不能用同一个名字
  }
  

• 常量

  package main
  
  import "fmt"
  
  //常量类似变量，只是关键字用const，而且必须声明就赋值，而且不能修改
  const pi = 3.1415926
  
  //批量声明,如果只用名字没有赋值，则表示和上面一行的值一样
  const (
  	ei = 2.7182
  	n1 = 100
  	n2 //100
  	n3 //100
  )
  
  //iota是常量计数器，用在常量表达式中
  // 在const关键字中声明重置为0，每新增一行则加一（空行不算），常用在枚举中
  const (
  	s1 = iota //0
  	s2        //1
  	_         //2,但赋值给了匿名变量，相当于忽略了
  	s4        //3
  )
  
  //插队
  const (
  	l1 = iota //0
  	l2 = 100  //100
  	l3 = iota //2，继续计数，如果不写的话就是和上一行一样是100，而且由于过了两行，所以为2
  	l4        //3
  )
  const l5 = iota //0，因为重新用const声明了，所以重置为0
  
  //声明在一行
  const (
  	a, b = iota + 1, iota + 2 //1,2,iota=0
  	c, d                      //2,3,iota=1
  	e, f                      //3,4,iota=2
  )
  
  //定义数量级
  const (
  	_  = iota             //0
  	KB = 1 << (10 * iota) //1左移10位，即2^10
  	MB = 1 << (10 * iota) //2^100
  	GB = 1 << (10 * iota) //2^1000
  	TB = 1 << (10 * iota) //2^10000
  	PB = 1 << (10 * iota) //2^100000
  )
  
  func main() {
  	fmt.Println("批量声明")
  	fmt.Println(pi)
  	fmt.Println(ei)
  	fmt.Println("iota1")
  	fmt.Println(n1)
  	fmt.Println(n2)
  	fmt.Println(n3)
  	fmt.Println("iota2")
  	fmt.Println(s1)
  	fmt.Println(s2)
  	fmt.Println(s4)
  	fmt.Println("iota3")
  	fmt.Println(l1)
  	fmt.Println(l2)
  	fmt.Println(l3)
  	fmt.Println(l4)
  	fmt.Println(l5)
  	fmt.Println("iota4")
  	fmt.Println(a)
  	fmt.Println(b)
  	fmt.Println(c)
  	fmt.Println(d)
  	fmt.Println(e)
  	fmt.Println(f)
  }