3.Go语言中常量,变量, 及其命名规则以及代码风格

1. Go语言中变量的声明

Go 语言变量名由字母, 数字, 下划线组成; 其中首个字符不能为数字; Go语言中关键字和保留字都不能作变量名;

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

1.1 var声明变量

var 变量名称 变量类型

• 变量声明后没有初始化的话, 值为空

func main() {
	// 变量名  :=  表达式
	var name string
	var a1 = "张三"         //可以省略类型
	fmt.Println(name, a1) //变量声明后没有初始化的话,  值为空
}
           

1.2 变量的初始化

Go 语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值;

例如：

1. 整型和浮点型变量的默认值为 0。
2. 字符串变量的默认值为空字符串。

   3.  布尔型变量默认为 false。
            4.  切片、函数、指针变量的默认为 nil。
              

• 初始化第一种方式, 先声明后赋值

  func main() {
  	var name string //变量声明
  	name = "张三"     //变量初始化赋值
  	fmt.Printf(name)
  }
             

• 第二种方式, 声明的时候直接赋值

  //定义入口文件
  func main() {
  	var name string = "张三" 
  	fmt.Println(name, age)
  }
             

• 第三种初始化方式, 类型推导的方式直接赋值, 省略 变量类型, 推荐使用

  func main() {
  	var age = 18 //类型可以省略, 可以根据类型推导自动判断类型
  	fmt.Println(age)
  }
             

1.3 一次声明多个变量

• var 变量名称, 变量名称 类型

  ; 声明的变量类型必须一致

  //定义入口文件
  func main() {
  	var name, sex string  //声明的变量类型必须一致
  	fmt.Printf("name的类型是%T sex的类型是%T", name, sex)
  }
             

• 声明的变量类型可以不一致

  func main() {
  	var (
  		name string
  		age  int
  		sex  = "男" //声明的时候可以直接赋值,可以省略数据类型,自动推导类型
  	)
  	fmt.Printf("name的类型是%T age的类型是%T sex的值是=%v", name, age, sex)
  }
             

  注意:
  • go语言中, 声明的变量类型和赋值的类型必须保持一致, 比如,声明为string,就必须赋值为string
  • 变量声明之后, 必须要使用, 不然会报错

1.4 短变量声明法(推荐使用)

• 在函数的内部, 可以使用更简略的

  :=

  方式声明并初始化变量
• 注意: 短变量只能用于声明局部变量; 不能用于全局变量的声明

var a = 10
//定义入口文件
func main() {
	b := "男"
	fmt.Printf("a=%v b=%v", a, b)
}
           

• 声明多个变量

  func main() {
  	a, b, c := 12, 13, "学习" //类型可以不一致,  var声明必须保持类型一致, 不能类型推导
  	fmt.Println(a, b, c)
  }
             

1.5 类型推导

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

1.6 匿名变量(忽略某个值)

• 在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示
• 匿名变量不占用命名空间, 不会分配内存, 所以匿名变量之间不存在重复声明

//(int, string) 表示要返回数据的类型
func getInfo() (int, string) {
	return 10, "张三"
}

func main() {
	// 下划线_ 忽略了10, 张三赋值给了username
	_, username := getInfo()
	fmt.Println(username)
}
           

2. Go语言中的常量

2.1 使用const定义常量

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

• 常量在定义的时候必须赋值
• const 同时声明多个常量时，如果省略了值则表示和上面一行的值相同

func main() {
	const p = 3.1415
	// p = 1.123 不能重新赋值, 变量可以
	fmt.Println(p) //在整个程序运行期间它们的值都不能再发生变化了
	const (
		n1 = 100
		n2  //如果省略了值则表示和上面一行的值相同
		n3  //如果省略了值则表示和上面一行的值相同
	)
	fmt.Println(n1, n2, n3) 
}

输出:
I:\goiteam>go run main.go
3.1415
100 100 100
           

2.2 const常量和iota的使用

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

iota 在 const 关键字出现时将被重置为 0(const 内部的第一行之前);

const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

2.2.1 iota 只能在常量的表达式中使用;

2.2.2 每次 const 出现时, 都会让 iota 初始化为0 (自增长)

func main() {
	const p = iota //p=0
	const (
		n1 = iota //0
		n2        //1
		n3        //2
	)
	fmt.Println(p, n1, n2, n3) //0 0 1 2
}
           

2.2.3 const iota 使用_跳过某些值

func main() {
	const (
		n1 = iota //0
		n2        //1
		_
		n3 //3
	)
	fmt.Println(n1, n2, n3) // 0 1 3
}
           

2.2.4 iota 声明中间插队

func main() {
	const (
		n1 = iota //0
		n2 = 100  //100
		n3 = iota //2
		n4        //3
	)
	fmt.Println(n1, n2, n3, n4) //0 100 2 3
}
           

2.2.5 多个 iota 定义在一行

func main() {
	const (
		n1     = iota               //0
		n2, n3 = iota + 1, iota + 2 //2,3
		n4, n5                      //3,4
	)
	fmt.Println(n1, n2, n3, n4, n5) //0 2 3 3 4
}
           

3. Go语言变量, 常量命名规则

• 变量名称必须由数字、字母、下划线组成
• 标识符开头不能是数字
• 标识符不能是保留字和关键字
• 变量的名字是区分大小写的如: age 和 Age 是不同的变量。在实际的运用中,也建议,不要用一个单词大小写区分两个变量。
• 标识符(变量名称)一定要见名思意 ：变量名称建议用名词，方法名称建议用动词;
• 变量命名一般采用驼峰式(大驼峰或小驼峰)，当遇到特有名词（缩写或简称，如 DNS）的时候，特有名词根据是否私有全部大写或小写;

4. Go语言代码风格

• 代码每一行结束后不用写分号（ ;）
• 运算符左右建议各加一个空格:

  var username string = "itying"

• Go 语言程序员推荐使用驼峰式命名; 当名字有几个单词组成的时优先使用大小写分隔

  小驼峰表示私有, 大驼峰表示公有

• 强制的代码风格

  左括号必须紧接着语句不换行，这个特性刚开始会使开发者不习惯，但随着对 Go 语言的不断熟悉，就会发现风格统一让大家在阅读代码时把注意力集中到了解决问题上，而不是代码风格上

• go fmt 主要用于格式化文档，让所有人的代码风格保持一致, 现在一般编辑器保存都自动格式化了

D:\golang\src\demo01>go fmt main.go main.go