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

最新推荐文章于 2023-05-11 11:14:24 发布

KayCh

最新推荐文章于 2023-05-11 11:14:24 发布

阅读量225

点赞数

文章标签： golang 学习开发语言

本文链接：https://blog.csdn.net/Kaychenl/article/details/125169638

版权

本文深入介绍了Go语言中的变量和常量的声明与使用，包括标识符、关键字、批量声明、匿名变量以及常量的声明与计数器`iota`的运用。强调了Go语言对未使用的变量的严格检查，并展示了如何在函数中有效地使用变量和常量。此外，还探讨了常量的批量声明和枚举特性，以及`iota`在常量表达式中的应用。

摘要由CSDN通过智能技术生成

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)
}