Go大道至简之基础教程

基础语法

变量声明

var

Go 语言引入了关键字 var，并且将类型信息放在变量名之后，此外，变量声明语句不需要使用分号作为结束符

//单定义
var varib int
//多变量定义
var (
	varib1 int
	varib2 string 
)
//省略写法
varib3 := 14
//变量数据类型
var v1 int            // 整型
var v2 string         // 字符串
var v3 bool           // 布尔型
var v4 [10]int        // 数组，数组元素类型为整型
var v5 struct {
          // 结构体，成员变量 f 的类型为64位浮点型
    f float64
} 
var v6 *int           // 指针，指向整型
var v7 map[string]int   // map（字典），key为字符串类型，value为整型
var v8 func(a int) int  // 函数，参数类型为整型，返回值类型为整型

常量和枚举

常量

通过 const 关键字定义常量时，可以指定常量类型，也可以省略（底层会自动推导）

//定义常量数据类型
const Pi float64 = 3.1415926
//省略常量类型
const Pi1 = 3.1415926
//通过一个 const 关键字定义多个常量，和 var 类似
const(
	Pi3 int
	Pi4 = 3
)
// u = 0.0, v = 3.0，常量的多重赋值 
const u, v float32 = 0, 3  
// a = 3, b = 4, c = "foo", 无类型整型和字符串常量
const a, b, c = 3, 4, "foo" 

预定义常量

Go 语言预定义了这些常量：true、false 和 iota，iota 比较特殊，可以被认为是一个可被编译器修改的常量，在每一个 const 关键字出现时被重置为 0，然后在下一个 const 出现之前，每出现一次 iota，其所代表的数字会自动增 1。

const (    // iota 被重置为 0
	c0 = iota   // c0 = 0
	c1 = iota   // c1 = 1
	c2 = iota   // c2 = 2
)
const (
    u = iota * 2;  // u = 0
    v = iota * 2;  // v = 2
    w = iota * 2;  // w = 4
)
const x = iota;  // x = 0
const y = iota;  // y = 0

两个 const 的赋值语句的表达式是一样的，那么还可以省略后一个赋值表达式

const ( 
    c0 = iota 
    c1 
    c2 
)
const ( 
    u = iota * 2 
    v 
    w 
)

枚举

Go 语言并不支持其他语言用于表示枚举的 enum 关键字，而是通过在 const 后跟一对圆括号定义一组常量的方式来实现枚举。

const (
    Sunday = iota 
    Monday 
    Tuesday 
    Wednesday 
    Thursday 
    Friday 
    Saturday 
    numberOfDays
)

常量的作用域

1. 和函数体外声明的变量一样，以大写字母开头的常量在包外可见，类似于 public 修饰的类属性。
2. 以小写字母开头的常量只能在包内访问，类似于通过 protected 修饰的类属性。
3. 函数体内声明的常量只能在函数体内生效。

数据类型

布尔类型

关键字为 bool，可赋值且只可以赋值为预定义常量 true 和 false

//定义
var v1 bool 
v1 = true 
// v2 也会被推导为 bool 类型
v2 := (1 == 2)
// 打印结果为Result: true
fmt.Println("Result:", v2) 
//第二种写法 推导
var b bool 
// 编译正确 
b = (1!=0)
// 打印结果为Result: true
fmt.Println("Result:", b) 

整型

整型是所有编程语言里最基础的数据类型，Go 语言默认支持如下这些整型类型

类型	长度	说明	值范围	默认
int8	1	带符号8位整型	-128~127	0
uint8	1	无符号8位整型，与 byte 类型等价	0~255	0
int16	2	带符号16位整型	-32768~32767	0
uint16	2	无符号16位整型	0~65535	0
int32	4	带符号32位整型，与 rune 类型等价	-2147483648~2147483647	0
uint32	4	无符号32位整型	0~4294967295	0
int64	8	带符号64位整型	-9223372036854775808~9223372036854775807	0
uint64	8	无符号64位整型	0~18446744073709551615	0
int	32位或64位	与具体平台相关	与具体平台相关	0
uint	32位或64位	与具体平台相关	与具体平台相关	0
uintptr	与对应指针相同	无符号整型，足以存储指针值的未解释位	32位平台下为4字节，64位平台下为8字节	0

//定义
var i1 int32 = -45
var (
	i2 uint32 = 666
	i3 int64 = 888 
)
//多赋值
var i4，i5,i6 int64 = 123,456,789

浮点类型

Go 语言中的浮点数采用IEEE-754 标准的表达方式，定义了两个类型：float32 和 float64

• Float32，可以精确到小数点后 7 位。
• Float64，可以精确到小数点后 15 位。

//定义
var fat float32
//赋值
fat = 14
//省略写法，如果不加小数点，会被推导为整型而不是浮点型。
fat2 := 3.1415926 //其类型将被自动设置为 float64
//下面的赋值将导致编译错误,float64不能赋值float32。
fat = fat2 
//强制类型转换才可以
fat = float32(fat2)

复数类型

复数是实数的延伸，可以通过两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag）

• complex64（32位实部和虚部）
• complex128（64位实部和虚部）

//定义
var comp1 complex64
comp1 = 1.10 + 10i // 由两个 float32 实数构成的复数类型
comp2 := 1.10 + 10i //和浮点型一样，默认自动推导的实数类型是 float64，所以 comp2 是 complex128 
//读取实数
 real(comp1) //获得该复数的实部
//读取虚数
imag(comp2)

字符串

在 Go 语言中，字符串是一种基本类型，默认是通过 UTF-8 编码的字符序列，当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节，比如中文编码通常需要 3 个字节。

//声明和初始化
var str1 string
// 变量初始化
str1 = "Hello Golang" 
//省略写法 
str2 := "你好，明哥哥" 
//截取字符串
str[开始|结束]
ch1 := str1[0]  // 取字符串的第一个字符
ch2 := str1[:5] //获取索引5之前的字符串
ch3 := str1[5:] //获取索引5之后的字符串
ch4 := str1[3:6] //获取3-6之间的字符串
//字符串长度len
ch5 := len(str2)
//字符串连接
str1 = str1 + "emmmm"
str1 += "，2333333" //简写为这样，效果完全一样
//字符串遍历
n := len(str1) 
for i := 0; i < n; i++ {
   
    ch := str1[i]    // 依据下标取字符串中的字符，类型为byte
    fmt.Println(i, ch) 
}

字符类型

• byte（实际上是 uint8 的别名），代表 UTF-8 字符串的单个字节的值。
• rune，代表单个 Unicode 字符

rune 相关的操作，可查阅 Go 标准库的 unicode 包。 另外 unicode/utf8 包也提供了 UTF-8 和 Unicode 之间的转换。

复合类型

指针（pointer）

变量的本质对一块内存空间的命名，可以通过引用变量名来使用这块内存空间存储的值，而指针的含义则指向存储这些变量值的内存地址。

a := 100
var ptr *int
ptr = &a
fmt.Println(ptr)
fmt.Println(*ptr)
//如