SRE文档

深浅模式

1.golang变量 ​

变量是计算机语言中能 储存计算结果或能表示值的抽象概念。不同的变量保存的数据类型可能会不一样。

基本数据类型明变量 ​

类型描述
uint8 / uint16 / uint32 / uint64无符号 8 / 16 / 32 / 64位整型
int8 / int16 / int32 / int64有符号8 / 16 / 32 / 64位整型
float32 / float64IEEE-754 32 / 64 位浮点型数
complex64 / complex12832 / 64 位实数和虚数
byte类似 uint8
rune类似 int32
uintptr无符号整型，用于存放一个指针

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

  • 声明变量的语法
go
var identifier type

var: 声明变量关键字
identifier： 变量名称
type： 变量类型

//例如
package main
import "fmt"

func main() {
    var name string
    var age int
    var ok bool
}
var identifier type

var: 声明变量关键字
identifier： 变量名称
type： 变量类型

//例如
package main
import "fmt"

func main() {
    var name string
    var age int
    var ok bool
}

如果变量没有初始化 ​

在go语言中定义了一个变量，指定变量类型，如果没有初始化，则变量默认为零值。零值就是变量没有做初始化时系统默认设置的值。

类型零值
数值类型0
布尔类型false
字符串“”（空字符串）

如果变量没有指定类型 ​

在go语言中如果没有指定变量类型，可以通过变量的初始值来判断变量的类型。

go
package main
import "fmt"
func main() {
    var d = true
    fmt.Println(d)
}
package main
import "fmt"
func main() {
    var d = true
    fmt.Println(d)
}

1.1 :=符号 ​

当我们定义一个变量后又使用该符号初始化变量，就会产生编译错误，因为该符号其实是一个声明语句。

使用格式：typename := value 变量名 := 变量值

也就是说 intVal := 1相等于：

go
var intVal int
intVal = 1
var intVal int
intVal = 1

1.2批量声明 ​

使用一个var 关键字，吧一些变量写在一个括号()里

go
package main

func main() {
	var (
		name string
		age int
		ok  bool
	)
}
package main

func main() {
	var (
		name string
		age int
		ok  bool
	)
}

1.3变量初始化 ​

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

  • 变量初始化语法
go
var 变量名 类型 = 表达式


//如
package main
func main() {
    var name string = "xxx"
    var site string = "www.xxx.com"
    var age int = 30
}
var 变量名 类型 = 表达式


//如
package main
func main() {
    var name string = "xxx"
    var site string = "www.xxx.com"
    var age int = 30
}

类型推导 ​

我们在声明变量时，可以根据初始化值进行类型推导，从而省略类型

go
package main
func main() {
	var name = "tom"
	var site = "ww.xx.com"
	var age int = 30
}
package main
func main() {
	var name = "tom"
	var site = "ww.xx.com"
	var age int = 30
}

初始化多个变量 ​

可以一次初始化多个变量，中间用逗号分割

go
package main
func main() {
	var name, site, age = "tom","xx.com",30
}
package main
func main() {
	var name, site, age = "tom","xx.com",30
}

值交换 ​

当一次定义了多个值的时候就可以进行交换

go
tel,desc := "10010","上海"
    fmt.Println(tel,desc)
    tel,desc = desc,tel
    fmt.Println(tel,desc)

package main
import "fmt"
var version string = "www.linuxea.com"
func main(){
    tel,desc := "10010","上海"
    fmt.Println(tel,desc)
    tel,desc = desc,tel
    fmt.Println(tel,desc)
}
tel,desc := "10010","上海"
    fmt.Println(tel,desc)
    tel,desc = desc,tel
    fmt.Println(tel,desc)

package main
import "fmt"
var version string = "www.linuxea.com"
func main(){
    tel,desc := "10010","上海"
    fmt.Println(tel,desc)
    tel,desc = desc,tel
    fmt.Println(tel,desc)
}

1.4短变量声明 ​

在函数内部，可以使用 :=运算符对变量进行声明和初始化，在定义变量的时候，可以不指定类型，go会根据赋值类型自动推导，但是必须赋值

go
package main

func main() {
	name := "tom"
	site := "xxx.com"
	age := 20

}
package main

func main() {
	name := "tom"
	site := "xxx.com"
	age := 20

}

这种方法只适合在函数内部，函数外不能使用

var简短声明和区别

[!NOTE]

注意：

这里使用了简短声明，没有使用var声明 。在函数体内可以使用简短声明。而在函数体外必须使用var 定义，如下，go会根据值类型进行自动推导类型

1.5匿名变量 ​

如果我们接收到多个变量，有一些变量使用不到，可以是使用下划线 _表示变量名称，这种变量叫做匿名变量。

匿名变量的特点是一个下画线_，这本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。

使用匿名变量时，只需要在变量声明的地方使用下画线替换即可

go
func GetData() (int,int) {
    return 10,20
}
func main(){
    a, _ := GetData()
    _, b := GetData()
    fmt.Println(a,b)
}
func GetData() (int,int) {
    return 10,20
}
func main(){
    a, _ := GetData()
    _, b := GetData()
    fmt.Println(a,b)
}

需要注意的是匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用

go
package main

import "fmt"

//name 和 age 可以省略
func getNameAndAge() (name string, age int) {
	return "tom", 30
}

func main() {
	name, _ := getNameAndAge()
	fmt.Printf("name: %v\n" , name)
}
package main

import "fmt"

//name 和 age 可以省略
func getNameAndAge() (name string, age int) {
	return "tom", 30
}

func main() {
	name, _ := getNameAndAge()
	fmt.Printf("name: %v\n" , name)
}

1.6全局变量 ​

关于全局变量的声明如下： var ( vname1 v_type1 vname2 v_type2 )

go
var (
	a int 
    b bool 
)
var (
	a int 
    b bool 
)

1.7变量作用域 ​

作用域指的是已声明的标识符所表示的常量、类型、函数或者包在源代码中的作用范围，在此我们主要看一下go中变量的作用域，根据变量定义位置的不同，可以分为一下三个类型：

1.函数内定义的变量为局部变量，这种局部变量的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。这种变量在存在于函数被调用时，销毁于函数调用结束后

2.函数外定义的变量为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，甚至可以使用import引入外部包来使用。全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写

3.函数定义中的变量成为形式参数，定义函数时函数名后面括号中的变量叫做形式参数（简称形参）。形式参数只在函数调用时才会生效，函数调用结束后就会被销毁，在函数未被调用时，函数的形参并不占用实际的存储单元，也没有实际值。形式参数会作为函数的局部变量来使用

注意：

函数体内的变量必须使用，否则会报错

go
package main
import "fmt"
var version string = "xxm"
func main(){
    var me string
    me = "linuxea.com"
    fmt.Println(me)
}
package main
import "fmt"
var version string = "xxm"
func main(){
    var me string
    me = "linuxea.com"
    fmt.Println(me)
}

函数外的变量没有使用是不会报错的

💡 注意

变量只能声明一次，不能重复定义，但是可以重复赋值

tel := 10086

tel = 10086