Golang入门指南 - Go的变量/常量

前端开发后端小白的 Golang 学习记录，如有不对或者遗漏的地方欢迎大佬指出，不接受抬杠你说的都对 ～

Go入门 Hello World

Go的环境搭建在此就不过多介绍啦～ 咱们直接上手开干 ！！！

// 声明文件所在的包 每个go文件必须有归属的包
package main
// 引入程序中所需要的包 为了使用包中函数
import "fmt"
// main 主函数 程序的入口
func main() { 
   // 在控制台打印输出
  fmt.Println("Hello World!")
}

方法一：

• 通过go build test.go 命令，编译后产生的二进制可执行文件 test.exe

• test.exe 执行操作

方法二：

• go run test.go 当作一个脚本直接运行，隐藏了编译及运行的步骤

---

Go的变量

变量相当于内存中一个数据存储空间的表示

命名规则： Go语言变量名由字母、数字、下划线组成，其中首个字符不能为数字（Go语言中 关键字 和 保留字 都不能用作为变量名）

定义变量

通过 var来进行变量的定义，如下所示：

package main
import "fmt"
func main(){
	// 变量声明 并且声明数据类型
	var language string
	// 变量的赋值
	language = "Golang"

	// 当然也可以直接进行声明并赋值
	var level string = "牛*"

	// 再当然 也可以直接定义 不声明数据类型 go可以推断变量的类型
	var desc = "yyds"

	//使用变量
	fmt.Println(language, level, desc)
}

# Golang 牛* yyds

重复定义

Go中同一个作用域是不允许变量重复定义

定义变量 language 并且进行赋值，后续再次进行重复的定义，则会抛出以下错误：

package main

import "fmt"

func main() {
	var language string = "JavaScript"
	var language string = "Golang"
	fmt.Println(language)
}

# command-line-arguments
# language redeclared in this block    
# other declaration of language

变量类型

定义变量时，不可以在赋值的时候给予不匹配的类型

在定义变量 num 时，我们赋予变量 int 类型，但我们在赋值时却给予了小数，在Golang中时不被允许的，会抛出以下错误：

package main

import "fmt"

func main() {
	var num int = 8.88
	fmt.Println(num)
}

# command-line-arguments
#  cannot use 8.88 (untyped float constant) as int value in variable declaration (truncated)

类型转换

Go中不允许隐式类型转换

例如变量 language 已赋值为 string 类型，那么后续是不允许赋值为其他数据类型的值 ，如果进行改操作，则会抛出以下错误：

package main

import "fmt"

func main() {
	var language string = "Golang"
	language = 18
	fmt.Println(language)
}

# command-line-arguments
# cannot use 18 (untyped int constant) as string value in assignment

变量默认值

变量定义后没有给予赋值，变量则输出默认值

Go是强类型语言，有很多类型（具体整理在Go的数据类型中，在此不过多介绍），而不同的类型默认值都不同

package main

import "fmt"

func main() {
	var language string
	fmt.Println("language=", language)

	var num int
	fmt.Println("num=", num)

	var flag bool
	fmt.Println("flag=", flag)
    
    //  ... 其他类型
}

此处 string 默认值为 “”
# language= 
# num= 0   
# flag= false

简洁的变量声明

go有一种方便简洁的变量声明操作符：:= ，简写可以省略var

package maind

import "fmt"

func main() {
    // 与 var language = "Golang" 同理 
    // 直接定义 不声明数据类型 go可以推断变量的类型
	language := "Golang"
	fmt.Println(language)
}

# Golang

通过函数也能正常工作，如下所示：

package main

import "fmt"

func main() {
	language := getLanguage()
	fmt.Println(language)
}
func getLanguage() string {
	return "Golang"
}

# Golang

这里需要谨记，:= 是一个变量声明语句，而 = 是一个变量赋值操作!!!

这里需要谨记，:= 是一个变量声明语句，而 = 是一个变量赋值操作!!!

这里需要谨记，:= 是一个变量声明语句，而 = 是一个变量赋值操作!!!

多变量声明

我们可以一次声明多个变量

package main

import "fmt"

func main() {
	var n1, n2, n3 int
	fmt.Println(n1, n2, n3)
    // 输出： 0 0 0 

	var name, birthday, n4 = "哆啦A梦", 2112, 8.8
	fmt.Println(name, birthday, n4)
    // 输出： 哆啦A梦 2112 8.8

	time, day, week, month := "time1", 2, 3.3, true
	fmt.Println(time, day, week, month)
    // 输出： time1 2 3.3 true
}

另外需要注意：

Go程序中不能存在未使用的局部变量 以及 导入但未使用的包（Go之所以这么严格是因为如果没有使用导入的包会使编译变慢）

全局变量

全局变量：定义在函数外的变量

局部变量：定义在 { } 中的称为局部变量

package main

import "fmt"

var name = "哆啦A梦"
var birthday = 2112

func main() {
	fmt.Println(name, birthday)
    // 输出： 哆啦A梦 2112
}

一个一个定义起来当然不方便啦 ~ 我们还可以通过以下方式一次性声明：

package main

import "fmt"

var (
   time = "time1"
   day  = 2
   week = 3.3
)

func main() {
   fmt.Println(time, day, week)
   // 输出： time1 2 3.3
}

Go的常量

相对于变量，常量是不变的值，多用于定义程序运行期间不会改变的值（是不是有JavaScript里const那味儿了 ~）

package main

import "fmt"

func main() {
	const language = "Golang"
	language = "JavaScript"

	fmt.Println(language)
}

# command-line-arguments
# cannot assign to language (untyped string constant "Golang")

多变量声明

同样常量也可以 多变量 声明，但不同的是 常量如果省略了值则表示和上面一行的值相同，如下所示：

package main

import "fmt"

func main() {
	const (
		num1 = 8
		num2
		num3
	)
	fmt.Println(num1, num2, num3)
    // 输出： 8 8 8
}