02从零开始学习GO语言--标识符、关键字、变量和常量

目录

一: 标识符概念

1. Golang 对各种变量、方法、函数等命名时使用的字符序列称为标识符
2. 凡是自己可以起名字的地方都叫标识符

标识符的命名规则

1. 由 26 个英文字母大小写，0-9 ，_ 组成

2. 数字不可以开头。var num int //ok var 3num int //error

3. Golang 中严格区分大小写。

   var num int
   var Num int
   说明：在 golang 中，num 和 Num 是两个不同的变量
   

4. 标识符不能包含空格。

5. 下划线“_”本身在 Go 中是一个特殊的标识符，称为 空标识符。可以代表任何其它的标识符，但
   是它对应的值会被忽略(比如：忽略某个返回值)。所以 仅能被作为占位符使用，不能作为标识符使用

6. 不能以系统 保留关键字作为标识符（一共有 25 个），比如 break，if 等等...

标识符的案例

hello // ok
hello12 //ok
1hello // error ,不能以数字开头
h-b // error ,不能使用 -
x h // error, 不能含有空格
h_4 // ok
_ab // ok
int // ok , 我们要求大家不要这样使用
float32 // ok , 我们要求大家不要这样使用
_ // error
Abc // ok

标识符命名注意事项

1. 包名：保持 package 的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和
   标准库不要冲突 fmt

2. 变量名、函数名、常量名：采用驼峰法
   举例：

   var stuName string = “tom” 形式: xxxYyyyyZzzz 
   

3. 如果变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能
   在本包中使用 ( 注：可以简单的理解成， 首字母大写是公开的， 首字母小写是私有的) ,在 golang 没 有
   public , private 等关键字

二:系统保留关键字

系统的预定义标识符

三:变量的介绍

变量的介绍

变量的概念

变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门
牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量
(值)。

变量的使用步骤

1. 声明变量(也叫:定义变量)
2. 变量赋值
3. 使用变量

语法：var identifier type

var 变量名 变量类型

变量名 = 值

变量快速入门案例

变量类型

变量（Variable）的功能是存储数据。不同的变量保存的数据类型可能会不一样。经过半个多世纪的发展，编程语言已经基本形成了一套固定的类型，常见变量的数据类型有：整型、浮点型、布尔型等。

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 = "Egrep"
var age int = 18

或者一次初始化多个变量

var name, age = "Egrep", 20

类型推导

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

var name = "Egrep"
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, "Egrep"
}
func main() {
	x, _ := foo()
	_, y := foo()
	fmt.Println("x=", x)
	fmt.Println("y=", y)
}

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

变量使用注意事项

1. 变量表示内存中的一个存储区域

2. 该区域有自己的名称（变量名）和类型（数据类型）
   示意图：

   

3. Golang 变量使用的三种方式
   (1) 第一种：指定变量类型， 声明后若不赋值，使用默认值

​

(2) 第二种：根据值自行判定变量类型(类型推导)

(3) 第三种：省略 var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误

4. 多变量声明
   在编程中，有时我们需要一次性声明多个变量，Golang 也提供这样的语法
   举例说明:

5. 该区域的数据值可以在同一类型范围内不断变化(重点)

6. 变量在 同一个作用域(在一个函数或者在代码块)内不能重名

7. 变量= 变量名+ 值+ 数据类型，这一点请大家注意，变量的三要素
8. Golang 的变量如果没有赋初值，编译器会使用默认值, 比如 int 默认值 0 string 默认值为空串，
   小数默认为 0

变量的声明，初始化和赋值

四:程序中 +号的使用

1. 当左右两边都是数值型时，则做加法运算
2. 当左右两边都是字符串，则做字符串拼接

五:常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值。

const pi = 3.1415
const e = 2.7182

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

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

const (
    pi = 3.1415
    e = 2.7182
)

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

const (
    n1 = 100
    n2
    n3
)

上面示例中，常量n1、n2、n3的值都是100。

iota

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

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

举个例子：

const (
		n1 = iota //0
		n2        //1
		n3        //2
		n4        //3
	)

几个常见的iota示例:

使用_跳过某些值

const (
		n1 = iota //0
		n2        //1
		_
		n4        //3
	)

iota声明中间插队

const (
		n1 = iota //0
		n2 = 100  //100
		n3 = iota //2
		n4        //3
	)
	const n5 = iota //0

定义数量级

const (
		_  = iota
		KB = 1 << (10 * iota)
		MB = 1 << (10 * iota)
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)

多个iota定义在一行

const (
		a, b = iota + 1, iota + 2 //1,2
		c, d                      //2,3
		e, f                      //3,4
	)

练习题

要求: Golang中交换两个变量的值,但是不允许使用第三个变量？

方法一:

Go 语言提供了大多数语言不支持的多重赋值，这使得变量的交换变得十分简单。下面通过一个例子来了解 Go 语言的多重赋值

func main() {<br>　　
    fmt.Println("方法一>>:")
    var i int = 2
    var j int = 3
    fmt.Printf("Before i=%v j=%v\n", i, j)
    i, j = j, i
    fmt.Printf("After i=%v j=%v\n", i, j)
}
 
运行结果
方法一>>:
Before i=2 j=3
After i=3 j=2

方法二:

package main
 
import (
    "fmt"
)
 
func main() {
    //声明两个变量并且赋值  a=10 b=20 交换后的值是a=20 b=10 并且，不可以使用第三个变量
    a := 10
    b := 20
    //1.首先a=a+b的值 10+20=30
    a = a + b
    // 这个时候a的值发生改变但是b的值没有  b=a-b
    b = a - b  // b = a -b ==>> b = a + b -b 等于a的值 b=10
    a = a - b  // a的值未发生改变还是原来的30  a - b == 30 - 10 =20 等于a=20 这里的b现在是10是a的值
    fmt.Printf("a=%v\nb=%v", a, b)
}
 
运行的结果
a=20
b=10