Go语言基础——01 注释、变量、常量

Go语言基础——01 注释、变量、常量

注释

什么是注释？为什么我们要写注释？

注释：顾名思义，解释代码的文字。用来描述我们当前写的代码是做什么的。
一个项目，由多个部分组成。随着时间的推移，我们可能会忘记自己写的代码是什么意思，或在多人协作时，直接读懂别人的代码可能是比较困难的，这时如果我们能在写代码的时候，用一段文字来描述当前代码的意思，那么会使整个协作开发变得容易起来，能快速理解代码的意思。
在Go语言中注释的方法由两种：

• 单行注释（//）
• 多行注释（块注释）（/**/）

package main

import "fmt"

// 单行注释
func main() {
	/*
		多行注释
	*/
	fmt.Println("hello,world!")
}

注意：注释不会被编译

变量

变量的定义

• 变量来源于数学，是计算机语言中能储存计算结果或能表示值的抽象概念。
• 变量可以通过变量名访问。
• 在Go语言中变量名由字母、数字、下划线组成，其中首个字符不能为数字。

变量的声明

声明变量的一般形式是使用 var 关键字
var 变量名 类型
可以同时声明多个变量
var identifier1, identifier2 type

• 第一种，指定变量类型，如果没有初始化，则变量默认为零值。

package main

import (
	"fmt"
	"time"
)

func main() {
	// 声明变量，没有初始化，变量默认为零值
	// 零值：变量没有做初始化时系统默认设置的值
	// 数值类型（包括complex64/128）为 0
	// 数值类型（包括complex64/128）为 0
	// 字符串为 ""（空字符串）
	// 以下几种类型为 nil：
	/*
		var a *int
		var a []int
		var a map[string] int
		var a chan int
		var a func(string) int
		var a error // error 是接口
	*/
	var addr string
	fmt.Println(addr)
	
	var phone string = "12200000000"
	fmt.Println(phone)

	var name string
	name = "name1"
	fmt.Println(name)

	var age, salary int
	age = 11
	salary = 1000
	fmt.Println(age, salary)

	var (
		sex      string
		birthday time.Time
	)
	sex = "男"
	birthday = time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
	fmt.Println(sex, birthday)
}

• 第二种，根据值自行判定变量类型。

package main

import "fmt"

func main() {
	var name = "name1"
	var age = 12
	fmt.Println(name, age)
}

• 第三种，语法糖。

package main

import "fmt"

func main() {
	name := "name1"
	fmt.Println(name)
}

注意：

• 声明变量的语法：var 变量名 变量类型
• 语法糖：变量名 := 值，快速定义变量，它会自动推导类型

变量的交换

package main

import "fmt"

func main() {
	var a int = 100
	var b int = 200
	fmt.Println("a: ", a, "  b: ", b)
	var n int
	n = a
	a = b
	b = n
	fmt.Println("a: ", a, "  b: ", b)

	var c int = 1
	var d int = 2
	fmt.Println("c: ", c, "  d:", d)
	c, d = d, c
	fmt.Println("c: ", c, "  d:", d)
}

理解变量

package main

import "fmt"

func main() {
	var a int
	a = 100
	fmt.Printf("a的值：%d，内存地址：%p\n", a, &a) // a的值：100，内存地址：0xc00000e0c8
	a = 200
	fmt.Printf("a的值：%d，内存地址：%p\n", a, &a) // a的值：200，内存地址：0xc00000e0c8

	var str string
	str = "str1"
	fmt.Printf("str的值：%s，内存地址：%p\n", str, &str) // str的值：str1，内存地址：0xc000088220
	str = "str2"
	fmt.Printf("str的值：%s，内存地址：%p\n", str, &str) // str的值：str2，内存地址：0xc000088220

	m := map[int]int{}
	m[1] = 2
	fmt.Printf("m的值：%v，内存地址：%p\n", m, &m) // m的值：map[1:2]，内存地址：0xc00000a030
	m[1] = 3
	fmt.Printf("m的值：%v，内存地址：%p\n", m, &m) // m的值：map[1:3]，内存地址：0xc00000a030
}

匿名变量

在Go语言中，_ 下划线，代表匿名变量
任何赋值给匿名变量的值都会被丢弃

package main

import "fmt"

func main() {
	// 只想要第一个结果，使用匿名变量 _
	i, _ := test()
	fmt.Println(i)

	// 只想要第二个结果，使用匿名变量 _
	_, i2 := test()
	fmt.Println(i2)
}

func test() (int, int) {
	return 100, 200
}

变量的作用域

• 全局变量
  在函数体外声明的变量称为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。
• 局部变量
  在函数体内声明的变量称为局部变量，它们的作用域只在函数体内，参数和返回值也是局部变量

package main

import "fmt"

/* 声明全局变量 */
var c int
var d string = "全局 d"

func main() {
	/* 声明局部变量 */
	var a, b int

	/* 初始化参数 */
	a = 1
	b = 2
	c = a + b
	fmt.Printf("结果：a=%d, b=%d, c=%d\n", a, b, c)

	var d string = "局部 d"
	fmt.Println(d)
}

注意：

• 全局变量定义的时候无法使用语法糖（:=）创建，必须使用 var 关键字定义。
• 全局变量和局部变量可以重名
• 如果全局变量和局部变量重名，优先使用局部变量

常量

常量：广义概念是“不变化的量”。

在Go语言中，使用关键字 const 来定义常量。 var 定义变量
常量定义的格式：
const 常量名称 [类型] = 值

定于常量的方式：

• 显示类型定义：const a string = "a"
• 隐式类型定义：const b = "b"

多个相同类型的声明可以简写为：

const 常量1, 常量2 = 值1, 值2

package main

import "fmt"

func main() {
	const URL1 string = "www.baidu.com"
	const URL2 = "www.bilibili.com"
	fmt.Println(URL1, URL2)

	const URL3, URL4 = "www.baidu.com", "www.bilibili.com"
	fmt.Println(URL3, URL4)
}

注意：

• 常量是一个特殊的变量，它的值无法改变。
• 常量的值也并非无法改变，但是需要跳过常量名，直接找到内存地址，进行修改值

特殊常量 iota

iota是一个特殊的常量，可以认为是一个可以被编译器修改的常量

• iota 在 const 关键字出现时将被重置为 0（const 内部的第一行之前），const 中每新增一行常量声明将使 iota 计数一次（iota 可理解为语句块中的行索引）
• 第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1

package main

import "fmt"

func main() {
	const (
		a = iota // 0
		b = iota // 1
		c = 10   // 独立值 10，iota += 1
		d = iota // 3
		e = iota // 4
		f = 100  // 100，iota += 1
		g = iota // 6
		h = iota //7
	)
	fmt.Println(a, b, c, d, e, f, g, h) // 0 1 10 3 4 100 6 7
}