Adminxe's Blog | 低调求发展 - 潜心习安全 ,技术永无止境 | 谢谢您对本站的支持,有什么问题或者建议请及时联系:点击这里给我发消息

GO语言学习–变量与常量

安全开发 MoCo, MoCo 249℃ 0评论

变量

标识符

在编程语言中标识符就是程序员定义的具有特殊意义的词,比如变量名、常量名、函数名等等。 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

变量声明(var)

Go语言中的变量需要声明后才能使用,同一作用域内不支持重复声明。 并且Go语言的变量声明后必须使用。

标准声明

变量声明格式为:

var 变量名 变量类型

变量声明以关键字var开头,变量类型放在变量的后面,行尾无需分号。

 var name string
     var age int
     var isOk bool

批量声明

每声明一个变量就需要写var关键字会比较繁琐,go语言中还支持批量变量声明:

var (
    a string
    b int
    c bool
    d float32
)

变量的初始化

Go语言在声明变量的时候,会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值,例如: 整型和浮点型变量的默认值为0。 字符串变量的默认值为空字符串。 布尔型变量默认为false。 切片、函数、指针变量的默认为nil。

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

var 变量名 类型 = 表达式

举个例子:

 var name string = "Q1mi"
     var age int = 18

或者一次初始化多个变量

var name, age = "Q1mi", 20

类型推导

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

 var name = "Q1mi"
     var age = 18

短变量声明

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

 package main

     import (
	     "fmt"
     )
     // 全局变量m
     var m = 100

     func main() {
	     n := 10
     	     m := 200 // 此处声明局部变量m
	     fmt.Println(m, n)
     }

匿名变量

在使用多重赋值时,如果想要忽略某个值,可以使用匿名变量(anonymous variable)。 匿名变量用一个下划线_表示,例如:

 func foo() (int, string) {
	     return 10, "Q1mi"
     }
     func main() {
	     x, _ := foo()
	     _, y := foo()
	     fmt.Println("x=", x)
	     fmt.Println("y=", y)
     }

匿名变量不占用命名空间,不会分配内存,所以匿名变量之间不存在重复声明。 (在Lua等编程语言里,匿名变量也被叫做哑元变量。)

注意事项:

  1. 函数外的每个语句都必须以关键字开始(var、const、func等)
  2. :=不能使用在函数外。
  3. _多用于占位,表示忽略值。
  4. 同一个作用域(花括号)中不能重复声明同名的变量

练习笔记代码(var)

package main

import "fmt"

//声明变量
//var name string
//var age int
//var isOk bool

// 批量声明
var (
    name string // ""
    age  int    //0
    isOk bool   //false
)

func main() {
    name = "撒旦"
    age = 16
    isOk = true

    fmt.Print(isOk)               //在终端中输出要打印的内容
    fmt.Printf("name:%s\n", name) //%s:占位符  使用name这个变量的值去替换占位符
    fmt.Println(age)              //打印完指定的内容之后会在后面加一个换行符

    //声明变量同时赋值
    var s1 string = "moco"
    fmt.Println(s1)

    //类型推导(根据值判断该变量是什么类型)
    var s2 = "20"
    fmt.Println(s2)
    //简短变量声明,只能在函数中用,不能用于全局。
    s3 := "哦哦哦"
    fmt.Println(s3)

    //

}

常量

Const

变量定义及基本使用

 const pi = 3.1415
     const e = 2.7182

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

多个常量一起声明

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

 //批量声明常量
     const (
	     statusOK = 200
	     notFound = 404
     )

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

 //批量声明常量时,如果某一行声明后没有赋值默认就和上一行一致
     const (
	     n1 = 100
	     n2
	     n3
     )

Iota

定义与基本用法

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

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

举个例子:

 //iota:类似于枚举
     const (
	     a1 = iota //0
	     a2        //1
	     a3        //2
     )

使用_跳过某些值

 const (
	     b1 = iota //0
	     b2 = iota //1
	     _  = iota //2
	     b3 = iota //3
     )

iota声明中间插队

 //插队
     const (
	     c1 = iota //0
	     c2 = 100  //100
	     c3 = iota //2
	     c4
     )

多个iota定义在一行

 //多个常量声明在一行
     const (
	     d1, d2 = iota + 1, iota + 2 //d1:1 d2:2
	     d3, d4 = iota + 1, iota + 2 //d3:2 d4:3
     )

定义数量级

(这里的<<表示左移操作,1<<10表示将1的二进制表示向左移10位,也就是由1变成了10000000000,也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位,也就是由10变成了1000,也就是十进制的8。)

 //定义数量级
     const (
	     _  = iota
	     KB = 1 << (10 * iota)
	     MB = 1 << (10 * iota)
	     GB = 1 << (10 * iota)
	     TB = 1 << (10 * iota)
	     PB = 1 << (10 * iota)
     )

     func main() {
    
	     fmt.Println("KB:", KB)
	     fmt.Println("MB:", MB)
	     fmt.Println("GB:", GB)
	     fmt.Println("TB:", TB)
	     fmt.Println("PB:", PB)
     }     

练习笔记代码(const)

package main

import "fmt"

//常量
//定义了常量之后不能修改
//在程序运行期间不会改变的量
const pi = 3.1415926

//批量声明常量
const (
    statusOK = 200
    notFound = 404
)

//批量声明常量时,如果某一行声明后没有赋值默认就和上一行一致
const (
    n1 = 100
    n2
    n3
)

//iota:类似于枚举
const (
    a1 = iota //0
    a2        //1
    a3        //2
)

const (
    b1 = iota //0
    b2 = iota //1
    _  = iota //2
    b3 = iota //3
)

//插队
const (
    c1 = iota //0
    c2 = 100  //100
    c3 = iota //2
    c4
)

//多个常量声明在一行
const (
    d1, d2 = iota + 1, iota + 2 //d1:1 d2:2
    d3, d4 = iota + 1, iota + 2 //d3:2 d4:3
)

//定义数量级
const (
    _  = iota
    KB = 1 << (10 * iota)
    MB = 1 << (10 * iota)
    GB = 1 << (10 * iota)
    TB = 1 << (10 * iota)
    PB = 1 << (10 * iota)
)

func main() {

    fmt.Println("n1:", n1)
    fmt.Println("n2:", n2)
    fmt.Println("n3:", n3)

    fmt.Println("a1:", a1)
    fmt.Println("a2:", a2)
    fmt.Println("a3:", a3)

    fmt.Println("b1:", b1)
    fmt.Println("b2:", b2)
    fmt.Println("b3:", b3)

    fmt.Println("c1:", c1)
    fmt.Println("c2:", c2)
    fmt.Println("c3:", c3)
    fmt.Println("c4:", c4)

    fmt.Println("d1:", d1)
    fmt.Println("d2:", d2)
    fmt.Println("d3:", d3)
    fmt.Println("d4:", d4)

    fmt.Println("KB:", KB)
    fmt.Println("MB:", MB)
    fmt.Println("GB:", GB)
    fmt.Println("TB:", TB)
    fmt.Println("PB:", PB)
}

参考链接

https://www.liwenzhou.com/posts/Go/01_var_and_const/

转载请注明:Adminxe's Blog » GO语言学习–变量与常量

喜欢 (2)or分享 (0)
发表我的评论
取消评论
表情

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址