MSG

# 3. 常量跟变量、键盘输入

#　为什么需要变量

变量是程序的基本组成单位：不论是使用哪种高级程序语言编写程序，变量都是其程序的基本组成单位。

# 变量的介绍

  1. 变量的概念
    1. 变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量 (值)。
  2. 变量的使用步骤
    1. 声明变量(也叫:定义变量)
    2. 非变量赋值
    3. 使用变量

# 变量使用注意事项

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

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

  3. Golang 变量使用的三种方式

    1. 第一种：指定变量类型，声明后若不赋值，使用默认值
    2. 第二种：根据值自行判定变量类型(类型推导)
    3. 第三种：省略 var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误

  4. 多变量声明

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

      package main
import "fmt"

func main(){
    
	//该案例演示 golan如何一次性声明多个变量
	// var n1, n2, n3 int
	fmt. Println("n1=”,n1,"n2=",n2,"n3=",n3)

	//一次性声明多个变量的方式2
	var nl, name, n3= 100,tom, 888
	fmt Println("n1=",n1,"name=", name,"n3=", n3)

	//一次性声明多个变量的方式3,同样可以使用类型推导
	nl, name n3 100,"tom-",888
	fmt Println("n1=",nl,"name=", name,"n3=", n3)
}

    2. 如何一次性声明多个全局变量【在 go 中函数外部定义变量就是全局变量】

      image-20200724150958285

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

    image-20200724151020798

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

      image-20200724151058851

    2. 变量= 变量名+ 值+ 数据类型，这一点请大家注意，变量的三要素

    3. Golang 的变量如果没有赋初值，编译器会使用默认值, 比如 int 默认值 0 string 默认值为空串，小数默认为 0

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

Go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明。 并且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

# 短变量声明

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

因其短小、灵活、故而在局部变量的声明和初始化中主要使用短变量声明。

var声明通常是为那些跟初始化表达式类型不一致的局部变量保留的，或者用于后面才对变量赋值以及变量初始值不重要的情况下。

注意：使用短变量声明最少声明一个新变量，否则代码编译无法通过。

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. _多用于占位，表示忽略值

# 程序中 +号的使用

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

image-20200727104204283

# 变量的生命周期

生命周期指在程序执行过程中变量存在的时间段，包级别变量的生命周期是整个程序的执行时间

相反

局部变量有一个动态的生命周期，每次执行声明语句时创建一个新的实体，变量一直生存到它变得不可访问，这时它占用的存储空间就会被回收

函数的参数和返回值也是局部变量，它们在其闭包函数被调用的时候创建。

那么垃圾回收器如何知道一个变量是否可以被回收，基本思路是每个包级的变量以及每个当前执行函数的局部变量，可以作为寻找该变量的路径的源头，通过指针和其他方式的引用可以找到变量，如果变量的路径不存在，就会变得不可访问，因此它不会影响任何其他的计算过程

# 标识符的命名规范

# 标识符概念

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

# 标识符的命名规则

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

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

  3. Golang 中严格区分大小写

    1. var num int
    2. var Num int
    3. 在 golang 中，num 和 Num 是两个不同的变量

  4. 标识符不能包含空格

    image-20200813103227808

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

    image-20200813103254512

  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

    image-20200813103426565

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

    1. var stuName string = “tom” 形式: xxxYyyyyZzzz ...
    2. var goodPrice float32 = 1234.5

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

  4. image-20200813103534014

  5. image-20200813103540258

# 系统保留关键字

image-20200813103607946

# 系统的预定义标识符

image-20200813103619979

# 常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把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

定义数量级 （这里的<<表示左移操作，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)
	)

多个iota定义在一行

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

# 键盘输入语句

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。InputDemo.go

# 使用方式

  1. 导入 fmt 包

  2. 调用 fmt 包的 fmt.Scanln() 或者 fmt.Scanf()

    1. fmt.Scanln()

      ​ image-20200813201549223

    2. fmt.Scanf()

      ​ image-20200813201601183

# 演示

要求：可以从控制台接收用户信息，【姓名，年龄，薪水, 是否通过考试 】

# 使用 fmt.Scanln() 获取

image-20200813201632251

# 使用 fmt.Scanf() 获取

image-20200813201641511

← 4. 基本数据类型 →