Go语法基础之标识符本质

Go语法基础之标识符和常量

1、标识符本质

1.1 注释

go语言中的注释

• 函数、结构体等习惯把注释写在上面
• 包注释会写在package之上

多行注释
/*
这个样子
*/

// 函数注释   

func main() {
    fmt.Println(add(4,5)) //打印
}

// TODO 之后完成某个功能
//NOTE：注意
//Deprecated ：告知已过期，建议不要使用，。未来某个版本可能移除。

1.2、行

Go语言把分隔符作为一条语句的结尾。也就是说，一般情况下，一行结束，敲回车即可。

1.3、命名规范

1、标识符采用CamelCase驼峰命名

驼峰 UserName 大驼峰， useName 小驼峰，user_name 蛇形命令

1. 如果只在包内可用，采用小驼峰命名
2. 如果要在包外可见，就采用大驼峰命名；

2、简单循环变量可以使用i、j、k、v等。

3、条件变量、循环变量可以是单个字母或单个字母，Go倾向于单个字母。

4、常量驼峰命令即可。

5、函数/方法的参数、返回值应是单个单词或单个字母。

6、函数可以是多个单词命令

7、类型可以是多个单词命令

8、方法由于调用时会绑定类型，所以可以考虑使用单个单词。

9、包以小写单词命令，包名应该和导入路径的最后一段路径保持一致

10、接口优先采用单个单词，一般加er后缀，GO语言推荐尽量定义小接口，接口也可以组合。

1.4 关键字

https://golang.google.cn/ref/spec

break	default  	func   	interface	select
case	defer	 	go	   	map	        struct
chan	else	 	goto	package	    switch
const	fallthrough	if		range	    type	
continue	for		import	return	    var	

1.5 预定义标识符

语言用的方便，提前设置的标识符

https://golang.google.cn/ref/spec#Predeclared identifies

Types:
 	any bool byte comparable
 	complex64 complex128 error float32 float64
 	int int8 int16 int32 int64 rune string
 	uint unit8 uint16 uint32 uint64
 Constants:
 	true false iota
 Zero value
 	nil
 Functions:
 	append cap close complex copy delete imag len
 	make new panic print println real recover
 	
 	

2、标识符

• 一个名字，本质上是个字符串，用来指代一个值
• 只能是大小写字母，数字、下划线、也可以是Unicode字符。
• 不能以数字开头
• 不能是Go语言的关键字
• 尽量不要使用“预定义标识符”，否则后果难料
• 大小写敏感

字面常量：

a = 100 a指代100 ，a就是指代100 的一个名称，标识符。

a = 200 说明 a的指代 可以变化，a变心了，可以变化指代指的标识符，称为 变量标识符。
如果说a 的指代一旦关联，不可变，a这个标识符指代的值不能改变了，称为 常量标识符。

3、字面常量

它是值 ，不是标识符，但本身是常量，不能被修改

Go语言中，boolean ，rune，integer，float，complex、string 都是字面常量，其中、rune、integer、float、complex常量被称为数值常量

100
3.14
3.14e2

'测'
'\x31'
'1'
'\n'

true
false
iota

以上字面常量在Go语言中也被称为无类型常量untyped constant 。无类型常量的缺省类型为bool、rune、int、float64、complex128或字符串。

var m int32 =1000
//var n int = int(m)
// n := m
var n = 2.6 // n float64
fmt.Println(float64(m) + n )
fmt.Println(1000 + 2.6) // untyped constant ,隐式类型转换 ，float64

4、常量

常量： 使用const定义一个标识符，她所对应的值，不允许被修改。

对常量并不要求大写加下划线的命令规则。

func main(){
    const c = "abc"
    const d int = 100 //字面常量 无类型常量100 关联
    const e uint = 100 //无类型常量100 和左边有类型常量uint8 e
    // int 8bits => 1bytes 0~127 -128~127 0-255
    const f float32 = 1.5
    g  = true
    
}

var 变量名
const 常量名  = 初值 常量必须在定义是直接赋初值。

func main() {
    //iota 定义成批常量
    const (
    	a = iota  //0  iota  定义成批常量 iota从0 ，从成批的第一行
        b         //1  批量定义的时候，下面一行可以继承上面的表达式 b =iota
        c
        _ //空白标识符 ，黑洞_=iota
        d
        t = 100
        _
        _
        e
        
    )
    fmt.Println(a,b,c,d)
}



func main() {
    const (
    	m = 100
        n
        a = iota * 2
        b
        c
        d
    )
    fmt.Println(a,b,c,d) //4,6,8,10
}


生成月份，星期。
const (
	sun = iota
    MON  
    TUE
)


package main

import (
	"fmt"
)

func main() {
	const (
		a = (iota + 1) * (iota + 1)
		b
		c
		d
	) //局部，只能在当前函数用
	fmt.Println(a, b, c, d)
}

//总结： iota是在成批定义和序列有关的

总结：iota是在成批定义和序列有关的常量定义

其它语言中

const a = [ 1, 2]

go语言中，常量不可以用数组。

注意: Go语言的常量定义

a = “abc” 赋值语句，名称是a，被赋值，a 是一个指代，指向某个值

a = 100

​ 如果可以，再次可以赋值，a称为变量，a的指代可以发送变化

​ 如果不可以，

​ a 有类型要求，不可以改变类型，同类型可以再次赋值，a是变量（a=100 不可以，a="aaa"可以）

​ a就是不可以在被赋值，a和第一个赋给它的值之间的联系不可改变，a称为常量标识符

常量： 标识符的指向的值一旦建立，不可改变，要求定义是必须建立关联

变量：标识符的指向的值建立后，可以改变

​ 1、类型也可以变，往往动态语言后JS 、Python，

​ 2、同类型可以变

4.1 类型推导

类型推导可以用在常量、变量定义，包括批量定义时

//赋值等式右边用“”

const a = "abc" //赋值语句，右边是无类型常量，它的缺省类型是string，左边a没有指定类型，a会进行类型推导，会依赖右边的类型，所以，a被推测为string类型。

const a int = 100 //指定类型定义常量并赋值
const （           //定义常量，等式左边未给出类型，将进行类型推导
	b = "abc"
	c = 12.3
	d = 'T'
）


const a  // 错误，const定义常量，必须在定义时赋值，并且之后不能改变

const c = [2]int{1,2} //错误，数组的容器内容会变化，不能在编译期间明确的确定下来，这个和其它语言不一样

注意：Go语言的常量定义，必须是能在编译器就要完全确定值，所以，值只能使用字面常量。

这个和其它语言不同！列如，在其它语言中，可以用常量标识符定义一个数组，因为常量标识符保证数组地址不变，而其它内元素可以变化，但是Go根本不允许这样做。