变量和常量
声明变量的几种方式
在go语言中，变量的声明可以分为声明单个变量和声明多个变量
对单个变量的声明，go语言提供了三种声明方式。
- 第一种，在声明变量时指定变量类型，这种方式声明之后会在内存开辟一块空间来存储这个变量的值，如果声明后不赋值，则使用该类型的默认值作为该变量的默认值，例如int的默认值为0，string的默认值为""。
var name string
name = "yanlong"
- 第二种，根据值自行判定变量类型(类型推断Type inference) 如果一个变量有一个初始值，Go将自动能够使用初始值来推断该变量的类型。因此，如果变量具有初始值，则可以省略变量声明中的类型。
var name = "zhangsan"
var count = 100
- 第三种,省略var，注意 :=左侧的变量不应该是已经声明过的(多个变量同时声明时，至少保证一个是新变量)，否则会导致编译错误(简短声明)
var a int = 10
var b = 10
c := 10 // 省略var
需要注意的是，这种方式只能被用在函数体内，而不可以用于全局变量的声明与赋值。
对于多变量的声明，同样可以总结出三种方式。
- 第一种，以逗号分隔，声明与赋值分开，若不赋值，存在默认值
var name1, name2, name3 string
name1, name2, name3 = "张三", "李四", "王五"
- 第二种，直接赋值，变量类型可以是不同的类型
var name, count = "lyl", 100
- 第三种，集合类型
var (
name string
age int
sex bool
)
注意事项：
- 变量必须先定义才能使用
- go语言是静态语言，要求变量的类型和赋值的类型必须一致。
- 变量名不能冲突。(同一个作用于域内不能冲突)
- 简短定义方式，左边的变量名至少有一个是新的
- 简短定义方式，不能定义全局变量。
- 变量的零值。也叫默认值。
- 变量定义了就要使用，否则无法通过编译。
如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。
如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：
func main() {
var name string = "zhangsan"
fmt.Println("123")
}
尝试编译这段代码将得到错误 a declared and not used
单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用在同一个作用域中，已存在同名的变量，则之后的声明初始化，则退化为赋值操作
匿名变量
在使用多重赋值时候，如果不需要在左值中接收变量，可以使用匿名变量 _, python中也经常有这种用法
func test() (int, error) {
return 0, nil
}
func main() {
_, err := test()
if err != nil {
fmt.Println("函数调用成功")
}
}
说明: 第6行代码中接收函数返回值的时候使用到了匿名变量。因为此处我们并不打印返回的值而只是关心函数调用是否成功
注意：python中申明了变量名后续代码中不使用并没有问题，但是go语言中声明了变量不使用就会报错，所以匿名变量在go语言中会更加的常用。
常量的定义
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"
package main
import "fmt"
func main() {
const LENGTH int = 10
const WIDTH int = 5
var area int
const a, b, c = 1, false, "str" //多重赋值
area = LENGTH * WIDTH
fmt.Printf("面积为 : %d", area)
fmt.Println(a, b, c)
}
常量可以作为枚举，常量组
const (
Unknown = 0
Female = 1
Male = 2
)
常量组中如不指定类型和初始化值，则与上一行非空常量右值相同
package main
import (
"fmt"
)
func main() {
const (
x uint16 = 16
y
s = "abc"
z
)
fmt.Printf("%T,%v\n", y, y)
fmt.Printf("%T,%v\n", z, z)
}
常量的注意事项：
- 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型
- 不曾使用的常量，在编译的时候，是不会报错的
- 显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值
iota
iota，特殊常量，可以认为是一个可以被编译器修改的常量
iota 可以被用作枚举值：
const (
a = iota
b = iota
c = iota
)
第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：
const (
a = iota
b
c
)
package main
import "fmt"
func main() {
const (
a = iota //0
b //1
c //2
d = "ha" //独立值，iota += 1
e //"ha" iota += 1
f = 100 //iota +=1
g //100 iota +=1
h = iota //7,恢复计数
i //8
)
fmt.Println(a,b,c,d,e,f,g,h,i)
}
如果中断iota自增，则必须显式恢复。且后续自增值按行序递增
自增默认是int类型，可以自行进行显示指定类型
数字常量不会分配存储空间，无须像变量那样通过内存寻址来取值，因此无法获取地址
使用iota能简化定义，在定义枚举时很有用。
每次 const 出现时，都会让 iota 初始化为0
基础数据类型
基本数据类型
下图是go语言中可用的基本数据类型
1. 布尔型bool
布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true
2. 数值型
2.1 整型
| 具体类型 | 取值范围 |
|---|---|
| int8 | -128到127 |
| uint8 | 0到255 |
| int16 | -32768到32767 |
| uint16 | 0到65535 |
| int32 | -2147483648到2147483647 |
| uint32 | 0到4294967295 |
| int64 | -9223372036854775808到9223372036854775807 |
| uint64 | 0到18446744073709551615 |
| uint | 与平台相关，32位操作系统上就是uint32，64位操作系统上就是uint64 |
| int | 与平台相关，32位操作系统上就是int32，64位操作系统上就是int64 |
2.2 浮点型
-
float32
IEEE-754 32位浮点型数
-
float64
IEEE-754 64位浮点型数
-
complex64
32 位实数和虚数
-
complex128
64 位实数和虚数
2.3 其他
-
byte
类似 uint8
-
rune
类似 int32
-
uint
32 或 64 位
-
int
与 uint 一样大小
-
uintptr
无符号整型，用于存放一个指针
3. 字符串型
不同于python，在go语言中，字符串只能用双引号来表示，单引号的为数值类型，相当于byte.
var s = "hello world"
fmt.Println(s)
// （1）索引取值 slice[index]
a:= s[2]
fmt.Println(string(a))
// （2）切片取值slice[start:end], 取出的元素数量为：结束位置 - 开始位置；
b1:=s[3:5] //
fmt.Println(b1)
b2:=s[0:] // 当缺省结束位置时，表示从开始位置到整个连续区域末尾；
fmt.Println(b2)
b3:=s[:8] // 当缺省开始位置时，表示从连续区域开头到结束位置；
fmt.Println(b3)
// （3）字符串拼接
var s1 = "hello"
var s2 = "world"
var s3 = s1 + s2 // 生成一个新的字符串
fmt.Println(s3) // hello world
转义符
| 转义字符 | 意义 | ASCII码值（十进制） |
|---|---|---|
| \n | 换行(LF) ，将当前位置移到下一行开头 | 010 |
| \r | 回车(CR) ，将当前位置移到本行开头 | 013 |
| \t | 水平制表(HT) （跳到下一个TAB位置） | 009 |
| \ | 代表一个反斜线字符'\' | 092 |
| \' | 代表一个单引号（撇号）字符 | 039 |
| \" | 代表一个双引号字符 | 034 |
| \? | 代表一个问号 | 063 |
多行字符串
Go语言中要定义一个多行字符串时，就必须使用反引号字符：
s1 := `welcome
to my
channel
`
fmt.Println(s1)
注意：反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。
复合（派生）数据类型
1、指针类型（Pointer） 2、数组类型 3、结构化类型(struct) 4、Channel 类型 5、函数类型 6、切片类型 7、接口类型（interface） 8、Map 类型
字符串的常用方法
| 方法 | 介绍 |
|---|---|
len(str) | 求长度 |
strings.ToUpper,strings.ToLower | 生成一个新的全部大写的字符串,生成一个新的全部小写的字符串 |
strings.ReplaceAll | 生成一个新的原字符串被指定替换后的字符串 |
strings.Contains | 判断是否包含 |
strings.HasPrefix,strings.HasSuffix | 前缀/后缀判断 |
strings.Trim、 | 去除字符串两端匹配的内容 |
strings.Index(),strings.LastIndex() | 子串出现的位置 |
strings.Split | 分割，将字符串按指定的内容分割成数组 |
strings.Join(a[]string, sep string) | join操作，将数组按指定的内容拼接成字符串 |
数据类型的转换
简单的数据类型转换
// 浮点数
a := 5.0
// 转换为int类型
b := int(a)
/*
不是所有数据类型都能转换的，例如字母格式的string类型"abcd"转换为int肯定会失败
低精度转换为高精度时是安全的，高精度的值转换为低精度时会丢失精度。例如int32转换为int16，float32转换为int
这种简单的转换方式不能对int(float)和string进行互转，要跨大类型转换，可以使用strconv包提供的函数
*/
strcov
Itoa和Atoi
int转换为字符串： Itoa()
println("a" + strconv.Itoa(32)) // a32
string转换为int：Atoi()
i,_ := strconv.Atoi("3")
println(3 + i) // 6
// Atoi()转换失败
i,err := strconv.Atoi("a")
if err != nil {
println("converted failed")
}
//由于string可能无法转换为int，所以这个函数有两个返回值：第一个返回值是转换成int的值，第二个返回值判断是否转换成功。
Parse类函数
Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。
b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)
ParseInt()和ParseUint()有3个参数：
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error)
说明：
bitSize参数表示转换为什么位的int/uint，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8。base参数表示以什么进制的方式去解析给定的字符串，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析。
Format类函数
将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。
s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16) //表示将-42转换为16进制数，转换的结果为-2a。
s := strconv.FormatUint(42, 16)
第二个参数base指定将第一个参数转换为多少进制，有效值为2<=base<=36。当指定的进制位大于10的时候，超出10的数值以a-z字母表示。例如16进制时，10-15的数字分别使用a-f表示，17进制时，10-16的数值分别使用a-g表示。
FormatFloat()参数众多：
bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。
fmt表示格式：'f'（-ddd.dddd）、'b'（-ddddp±ddd，指数为二进制）、'e'（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）、'g'（指数很大时用'e'格式，否则'f'格式）、'G'（指数很大时用'E'格式，否则'f'格式）。
prec控制精度（排除指数部分）：对'f'、'e'、'E'，它表示小数点后的数字个数；对'g'、'G'，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。
运算符和表达式
1. 算数运算符
+- * / %(求余) ++ --
2. 关系运算符
== != > < >= <=
3. 逻辑运算符
| 运算符 | 描述 |
|---|---|
| && | 逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。 |
| || | 逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。 |
| ! | 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。 |
这个和python不一样，python中使用 and or来连接
package main
import "fmt"
func main() {
var a bool = true
var b bool = false
if ( a && b ) {
fmt.Printf("第一行 - 条件为 true\n" )
}
if ( a || b ) {
fmt.Printf("第二行 - 条件为 true\n" )
}
/* 修改 a 和 b 的值 */
a = false
b = true
if ( a && b ) {
fmt.Printf("第三行 - 条件为 true\n" )
} else {
fmt.Printf("第三行 - 条件为 false\n" )
}
if ( !(a && b) ) {
fmt.Printf("第四行 - 条件为 true\n" )
}
}
赋值运算符
下表列出了所有Go语言的赋值运算符。
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，将一个表达式的值赋给一个左值 | C = A + B 将 A + B 表达式结果赋值给 C |
| += | 相加后再赋值 | C += A 等于 C = C + A |
| -= | 相减后再赋值 | C -= A 等于 C = C - A |
| *= | 相乘后再赋值 | C *= A 等于 C = C * A |
| /= | 相除后再赋值 | C /= A 等于 C = C / A |
| %= | 求余后再赋值 | C %= A 等于 C = C % A |
| <<= | 左移后赋值 | C <<= 2 等于 C = C << 2 |
| >>= | 右移后赋值 | C >>= 2 等于 C = C >> 2 |
| &= | 按位与后赋值 | C &= 2 等于 C = C & 2 |
| ^= | 按位异或后赋值 | C ^= 2 等于 C = C ^ 2 |
| |= | 按位或后赋值 | C |= 2 等于 C = C | 2 |
其他运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 返回变量存储地址 | &a; 将给出变量的实际地址。 |
| * | 指针变量。 | *a; 是一个指针变量 |
运算符优先级
有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低
| 优先级 | 分类 | 运算符 | 结合性 |
|---|---|---|---|
| 1 | 逗号运算符 | , | 从左到右 |
| 2 | 赋值运算符 | =、+=、-=、*=、/=、 %=、 >=、 <<=、&=、^=、= | 从右到左 |
| 3 | 逻辑或 | || | 从左到右 |
| 4 | 逻辑与 | && | 从左到右 |
| 5 | 按位或 | | | 从左到右 |
| 6 | 按位异或 | 从左到右 | |
| 7 | 按位与 | & | 从左到右 |
| 8 | 相等/不等 | ==、!= | 从左到右 |
| 9 | 关系运算符 | <、<=、>、>= | 从左到右 |
| 10 | 位移运算符 | <<、>> | 从左到右 |
| 11 | 加法/减法 | +、- | 从左到右 |
| 12 | 乘法/除法/取余 | *（乘号）、/、% | 从左到右 |
| 13 | 单目运算符 | !、*（指针）、& 、++、--、+（正号）、-（负号） | 从右到左 |
| 14 | 后缀运算符 | ( )、[ ]、-> | 从左到右 |
当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。
输入输出格式化
懒得整理了，自行查文档学习。
