1、命名
-
Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则：一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线。大写字母和小写字母是不同的：A和a是两个不同的名字。
-
Go语言中类似if和switch的关键字有25个(均为小写)。关键字不能用于自定义名字，只能在特定语法结构中使用。
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 -
此外，还有大约30多个预定义的名字，比如int和true等，主要对应内建的常量、类型和函数。
- 内建常量:
true false iota nil - 内建类型:
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error - 内建函数:
make len cap new append copy close delete
complex real imag
panic recover
- 命名规范
- 允许使用数字字母下划线
- 不允许使用关键字
- 不允许使用数字开头
- 区分大小写
- 见名知意
起一个有意义的名字，尽量做到看一眼就知道意思（提高代码的可读性）
- 驼峰命名法
如：userNameUserInfo
①. 小驼峰命名法：第一个单词以小写字母开始，第二个单词的首字母大写。
例如：myName myDog
②. 大驼峰命名法：每个单词的首字母都采用大写字母。
例如：FirstName LastName
③. 不过在程序员中还有一种命名法比较流行，就是用下划线"_"来连接所有单词。
例如：url_list user_list
2.1 变量
- 变量是几乎所有编程语言中最基本的组成元素，变量是程序运行期间可以改变的量。
- 从根本上说，变量相当于是对一块数据存储空间的命名，程序可以通过定义一个变量来申请一块数据存储空间，之后可以通过引用变量名来使用这块存储空间。
2.2 变量声明
Go语言的变量声明方式与C和C++语言有明显的不同。对于纯粹的变量声明，Go语言引入了关键字var，而类型信息放在变量名之后，示例如下：
var x1 int
var x2 int
//一次定义多个变量
var x3, x4 int
var (
x5 int
x6 int
)
- 变量用
var 变量名 类型进行生命，变量声明以后必须使用，不然会报错
- 只是声明变量，默认为0
- 在同一个{}中，声明的变量是唯一的
2.3 变量初始化
对于声明变量时需要进行初始化的场景， var关键字可以保留，但不再是必要的元素，如下所示：
var x1 int = 10 // 方式1
var x2 = 10 // 方式2，编译器自动推导出x2的类型
x3 := 10 // 方式3，编译器自动推导出x3的类型
fmt.Println("x3 type is ", reflect.TypeOf(x3)) //x3 type is int
//出现在 := 左侧的变量不应该是已经被声明过，:=定义时必须初始化
var x4 int
x4 := 2 //err
自动推导 :=左边变量必须未声明或者没有使用过
2.4 变量赋值
var x1 int
x1 = 123
var x2, x3, x4 int
x2, x3, x4 = 1, 2, 3 //多重赋值
i := 10
j := 20
i, j = j, i //多重赋值
2.5 匿名变量（需要结合函数返回值使用才有优势）
_（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃：
package main
import "fmt"
func main() {
tmp,_ := 7,8
fmt.Println(tmp)
}
如果函数的某个返回值不需要，可以使用匿名变量接收
package main
import "fmt"
// 函数可以返回多个值
func test()(a,b,c int){
return 1,2,3
}
func main() {
_,b,c := test()
fmt.Println(b,c)
}
2.6 不同类型的变量的定义
-
直接声明
package main import "fmt" func main() { var a int = 1 var b float32 = 2.0 fmt.Println(a,b) }
-
利用括号同时定义
package main import "fmt" func main() { var ( a int = 1 b float32 = 2.0 ) fmt.Println(a,b) }
-
自动推导
package main import "fmt" func main() { var( a = 1 b = 2.0 ) fmt.Println(a,b) }
-
终极简单自动推导
package main import "fmt" func main() { a,b := 1,2.0 fmt.Println(a,b) }
3.1 常量
在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、浮点型和复数类型）、布尔类型、字符串类型等。
常量使用const进行定义
3.2 字面常量(常量值)
所谓字面常量（literal），是指程序中硬编码的常量，如：
123
3.1415 // 浮点类型的常量
3.2+12i // 复数类型的常量
true // 布尔类型的常量
"foo" // 字符串常量
3.3 常量定义
const Pi float64 = 3.14
const zero = 0.0 // 浮点常量, 自动推导类型
const ( // 常量组
size int64 = 1024
eof = -1 // 整型常量, 自动推导类型
)
const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重赋值
const a, b, c = 3, 4, "foo"
// a = 3, b = 4, c = "foo" //err, 常量不能修改
3.4 iota枚举
常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。
在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。
- iota常量自动生成器,每隔一行，自动+1
- iota给常量赋值使用
- iota遇到const,重置为0
- 对多个常量使用iota,在同一个圆括号中只写一个iota
- 同一行iota代表同一个值
const (
x = iota // x == 0
y = iota // y == 1
z = iota // z == 2
w // 这里隐式地说w = iota，因此w == 3。其实上面y和z可同样不用"= iota"
)
const v = iota // 每遇到一个const关键字，iota就会重置，此时v == 0
const (
h, i, j = iota, iota, iota //h=0,i=0,j=0 iota在同一行值相同
)
const (
a = iota //a=0
b = "B"
c = iota //c=2
d, e, f = iota, iota, iota //d=3,e=3,f=3
g = iota //g = 4
)
const (
x1 = iota * 10 // x1 == 0
y1 = iota * 10 // y1 == 10
z1 = iota * 10 // z1 == 20
)
4.1 分类
Go语言内置以下这些基础类型：
| 类型 | 名称 | 长度 | 默认值 | 说明 |
|---|---|---|---|---|
| bool | 布尔类型 | 1 | false | 其值不为真即为假，不可以用数字代表true或false |
| byte | 字节型 | 1 | 0 | uint8别名 |
| rune | 字符类型 | 4 | 0 | 专用于存储unicode编码，等价于uint32 |
| int, uint | 整型 | 4或8 | 0 | 32位或64位 |
| int8, uint8 | 整型 | 1 | 0 | -128 ~ 127, 0 ~ 255 |
| int16, uint16 | 整型 | 2 | 0 | -32768 ~ 32767, 0 ~ 65535 |
| int32, uint32 | 整型 | 4 | 0 | -21亿~ 21亿, 0 ~ 42亿 |
| int64, uint64 | 整型 | 8 | 0 | |
| float32 | 浮点型 | 4 | 0.0 | 小数位精确到7位 |
| float64 | 浮点型 | 8 | 0.0 | 小数位精确到15位 |
| complex64 | 复数类型 | 8 | ||
| complex128 | 复数类型 | 16 | ||
| uintptr | 整型 | 4或8 | ⾜以存储指针的uint32或uint64整数 | |
| string | 字符串 | “” | utf-8字符串 |
4.2 布尔类型
- 布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换
var v1 bool v1 = true v2 := (1 == 2) // v2也会被推导为bool类型 //布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换 var b bool b = 1 // err, 编译错误 b = bool(1) // err, 编译错误
4.3 整型
- int 为有符号整形，uint为无符号整形
- unsafe.Sizeof() 查看变量在内存中占多少字节
var v1 int32 v1=123 v2:=64//v1将会被自动推导为int类型
4.4 浮点型
- 浮点型数据分为单精度float32和双精度float64，前者精确到小数点后七位，后者精确到15位
- 通过自动推导创建的浮点型变量，默认类型为float64
- 如果不加小数点， fvalue2会被推导为整型而不是浮点型
var f1 float32 f1 = 12 f2 := 12.0 // 如果不加小数点， fvalue2会被推导为整型而不是浮点型，float64
4.5 字符类型
-
byte字符类型，同时也是nint8别名
-
单引号表示字符，双引号表示字符串
-
在Go语言中支持两个字符类型，一个是byte（实际上是uint8的别名），代表utf-8字符串的单个字节的值；另一个是rune，代表单个unicode字符。
package main import ( "fmt" ) func main() { var ch1, ch2, ch3 byte ch1 = 'a' //字符赋值 ch2 = 97 //字符的ascii码赋值 ch3 = '\n' //转义字符 fmt.Printf("ch1 = %c, ch2 = %c, %c", ch1, ch2, ch3) }
4.6 字符串
- 在Go语言中，字符串也是一种基本类型
- 在字符串的结尾，会有一个字符’\0’。及时\0为字符串结束标志
- len函数 可以计算字符串中字符的个数（但不包含\0）
- 在go语言中，一个汉字占3个字符
- 字符串拼接 ① 直接用
+进行拼接 - 字符串中每个字符都有下表，可以使用
str[i]获取第i个字符的ASCII码值。可以使用%c输出字符。var str string // 声明一个字符串变量 str = "abc" // 字符串赋值 ch := str[0] // 取字符串的第一个字符 fmt.Printf("str = %s, len = %d\n", str, len(str)) //内置的函数len()来取字符串的长度 fmt.Printf("str[0] = %c, ch = %c\n", str[0], ch) //`(反引号)括起的字符串为Raw字符串，即字符串在代码中的形式就是打印时的形式，它没有字符转义，换行也将原样输出。 str2 := `hello mike \n \r测试 ` fmt.Println("str2 = ", str2) /* str2 = hello mike \n \r测试 */
字符与字符串的区别
- 字符使用单引号，往往只有一个字符（除了\n、\t等转义字符以外）
- 字符串使用双引号，字符串可以有一个或多个字符组成
- 字符串都是隐藏了一个结束符
\0
4.7 复数类型
- 复数实际上由两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag）。
- 通过
real()获取实部 - 通过
imag()获取虚部 - 默认推导是建立
complex128
var v1 complex64 // 由2个float32构成的复数类型
v1 = 3.2 + 12i
v2 := 3.2 + 12i // v2是complex128类型
v3 := complex(3.2, 12) // v3结果同v2
fmt.Println(v1, v2, v3)
//内置函数real(v1)获得该复数的实部
//通过imag(v1)获得该复数的虚部
fmt.Println(real(v1), imag(v1))
5.1 格式说明
| 格式 | 含义 |
|---|---|
| %% | 一个%字面量 |
| %b | 一个二进制整数值(基数为2)，或者是一个(高级的)用科学计数法表示的指数为2的浮点数 |
| %c | 字符型。可以把输入的数字按照ASCII码相应转换为对应的字符 |
| %d | 一个十进制数值(基数为10) |
| %e | 以科学记数法e表示的浮点数或者复数值 |
| %E | 以科学记数法E表示的浮点数或者复数值 |
| %f | 以标准记数法表示的浮点数或者复数值 |
| %g | 以%e或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出 |
| %G | 以%E或者%f表示的浮点数或者复数，任何一个都以最为紧凑的方式输出 |
| %o | 一个以八进制表示的数字(基数为8) |
| %p | 以十六进制(基数为16)表示的一个值的地址，前缀为0x,字母使用小写的a-f表示 |
| %q | 使用Go语法以及必须时使用转义，以双引号括起来的字符串或者字节切片[]byte，或者是以单引号括起来的数字 |
| %s | 字符串。输出字符串中的字符直至字符串中的空字符（字符串以’\0‘结尾，这个’\0’即空字符） |
| %t | 以true或者false输出的布尔值 |
| %T | 使用Go语法输出的值的类型 |
| %U | 一个用Unicode表示法表示的整型码点，默认值为4个数字字符 |
| %v | 使用默认格式输出的内置或者自定义类型的值，或者是使用其类型的String()方式输出的自定义值，如果该方法存在的话 |
| %x | 以十六进制表示的整型值(基数为十六)，数字a-f使用小写表示 |
| %X | 以十六进制表示的整型值(基数为十六)，数字A-F使用小写表示 |
5.2 输出
package main
import "fmt"
func main() {
a := 10
b := "abc"
c := 'a'
d := 3.14
// %T 打印变量所属数据类型
fmt.Printf("%T,%T,%T,%T\n",a,b,c,d)
// %d 整形格式输出
// %s 字符串格式输出
// %c 字符格式输出
// %f 浮点型格式输出
fmt.Printf("%d,%s,%c,%.2f\n",a,b,c,d)
// %v 自动匹配格式输出
fmt.Printf("%v,%v,%v,%v",a,b,c,d)
}
//整型
a := 15
fmt.Printf("a = %b\n", a) //a = 1111
fmt.Printf("%%\n") //只输出一个%
//字符
ch := 'a'
fmt.Printf("ch = %c, %c\n", ch, 97) //a, a
//浮点型
f := 3.14
fmt.Printf("f = %f, %g\n", f, f) //f = 3.140000, 3.14
fmt.Printf("f type = %T\n", f) //f type = float64
//复数类型
v := complex(3.2, 12)
fmt.Printf("v = %f, %g\n", v, v) //v = (3.200000+12.000000i), (3.2+12i)
fmt.Printf("v type = %T\n", v) //v type = complex128
//布尔类型
fmt.Printf("%t, %t\n", true, false) //true, false
//字符串
str := "hello go"
fmt.Printf("str = %s\n", str) //str = hello go
5.3 输入
- 输入会阻塞进程，等待用户的输入
-
fmt.scanf()是格式化输入，需要设置占位符 -
fmt.Scan()不需要输入格式var v int fmt.Println("请输入一个整型：") fmt.Scanf("%d", &v) //fmt.Scan(&v) fmt.Println("v = ", v)
Go语言中不允许隐式转换，所有类型转换必须显式声明，而且转换只能发生在两种相互兼容的类型之间。
-
类型转换只能在不同的但相互兼容的数据类型之间进行转换
-
数据类型(变量)
-
数据类型(表达式)
-
一般在类型转换时候，建议由低类型转换为高类型，保证数据精度（int8→int16→int32→int64、float32→float64）
-
整形和浮点型相互转换时，建议整形转换为浮点型
var ch byte = 97 //var a int = ch //err, cannot use ch (type byte) as type int in assignment var a int = int(ch)
- 利用
type关键字可以给类型起别名type bigint int64 //int64类型改名为bigint var x bigint = 100 type ( myint int //int改名为myint mystr string //string改名为mystr )
