Golang的基本语法学习笔记

1、var 变量名称 类型

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

变量首字符不能为数字

关键字不能作为变量名

同一个作用域不允许变量重复声明

但是以下属于赋值，是允许的

一次定义多个变量

注意：赋值时必须与声明的变量类型一致

声明不同类型的写法

短变量声明法

在函数内部可以使用更简略的 := 方式声明并初始化变量

注意：短变量只能用于声明局部变量，不能用于全局变量的声明

匿名变量

**注意：**匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明

2、常量

使用const定义常量

常量声明和赋值同时进行，不能先声明再赋值

常量的值不可改变

多常量同时声明

const 同时声明多个常量时，如果省略了值则表示和上面一行的值相同

const常量结合iota的使用

每次const出现时，都会让iota初始化为0【自增长】

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

iota是const关键字出现时将被重置为0（const内部的第一行之前）

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

每次const出现，都会让iota初始化为0【自增长】

const a = iota // a = 0
const (
    b = iota // b=0
    c        // c = 1
    d        // d = 2
)

const iota使用_跳过某些值

const (
    b = iota // b=0
    _
    d        // d = 2
)

iota声明中间插队

iota可以定义在一行

3、数据类型

概述

Go 语言中数据类型分为：基本数据类型和复合数据类型基本数据类型有：

整型、浮点型、布尔型、字符串

复合数据类型有：

数组、切片、结构体、函数、map、通道（channel）、接口等。

整型

整型分为以下两个大类：

有符号整型按长度分为：int8、int16、int32、int64

对应的无符号整型：uint8、uint16、uint32、uint64

如果我们直接写 int也是可以的，它在不同的操作系统中，int的大小是不一样的

• 32位操作系统：int -> int32
• 64位操作系统：int -> int64

可以通过unsafe.Sizeof 查看不同长度的整型，在内存里面的存储空间

var num2 = 12
fmt.Println(unsafe.Sizeof(num2))

类型转换

通过在变量前面添加指定类型，就可以进行强制类型转换

var a1 int16 = 10
var a2 int32 = 12
var a3 = int32(a1) + a2
fmt.Println(a3)

注意，高位转低位的时候，需要注意，会存在精度丢失，比如上述16转8位的时候，就丢失了

var n1 int16 = 130
fmt.Println(int8(n1)) // 变成 -126

数字字面量语法

Go1.13版本之后，引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：

v := 0b00101101  // 代表二进制的101101
v：= Oo377       // 代表八进制的377

进制转换

var number = 17
// 原样输出
fmt.Printf("%v\n", number)
// 十进制输出
fmt.Printf("%d\n", number)
// 以八进制输出
fmt.Printf("%o\n", number)
// 以二进制输出
fmt.Printf("%b\n", number)
// 以十六进制输出
fmt.Printf("%x\n", number)

浮点型

Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE754标准：

float32的浮点数的最大范围约为3.4e38，可以使用常量定义：math.MaxFloat32。float64的浮点数的最大范围约为1.8e308，可以使用一个常量定义：math.MaxFloat64

打印浮点数时，可以使用fmt包配合动词%f，代码如下：

var pi = math.Pi
// 打印浮点类型，默认小数点6位
fmt.Printf("%f\n", pi)
// 打印浮点类型，打印小数点后2位
fmt.Printf("%.2f\n", pi)

Golang中精度丢失的问题

几乎所有的编程语言都有精度丢失的问题，这是典型的二进制浮点数精度损失问题，在定长条件下，二进制小数和十进制小数互转可能有精度丢失

d := 1129.6
fmt.Println(d*100) //输出112959.99999999

解决方法，使用第三方包来解决精度损失的问题

http://github.com/shopspring/decimal

布尔类型

布尔类型默认为false

Go不允许整型强制转换为布尔型

布尔型无法参与数值运算，也无法与其他类型进行转换

定义

var fl = false
if f1 {
    fmt.Println("true")
} else {
    fmt.Println("false")
}

字符串类型

字符串声明方式

字符串转义符

\n 换行

当遇到字符串内容为路径，可能与转义符冲突，可使用双重反斜杠解决

想要在字符串中输出单引号"，也使用反斜杠\

多行字符串

如果想要定义多行字符串，可以使用反引号

字符串的常见操作

byte 和 rune类型

声明与定义

组成每个字符串的元素叫做 “字符”，可以通过遍历字符串元素获得字符。字符用单引号 ' 包裹起来

• golang中定义字符 字符属于int类型

两种字符型说明

Go语言中的字符有以下两种类型

• uint8类型：或者叫byte型，代表了ACII码的一个字符
• rune类型：代表一个UTF-8字符

当需要处理中文，日文或者其他复合字符时，则需要用到rune类型，rune类型实际上是一个int32

Go使用了特殊的rune类型来处理Unicode，让基于Unicode的文本处理更为方便，也可以使用byte型进行默认字符串处理，性能和扩展性都有照顾。

需要注意的是，在go语言中，一个汉字占用3个字节（utf-8），一个字母占用1个字节。golang中汉字使用的是UTF-8编码 编码后的值就是int类型

通过循环输出字符串里面的字符

正常的循环方式无法正确地打印出中文+英文的字符串

需要使用run的range循环方式

修改字符串

要修改字符串，需要先将其转换成[]rune 或 []byte类型，完成后在转换成string，无论哪种转换，都会重新分配内存，并复制字节数组

转换为 []byte 类型

// 字符串转换
s1 := "big"
byteS1 := []byte(s1)
byteS1[0] = 'p'
fmt.Println(string(byteS1))
//---------------------------------
//输出结果：pig

转换为rune类型

// rune类型
s2 := "你好golang"
byteS2 := []rune(s2)
byteS2[0] = '我'
fmt.Println(string(byteS2))

4、基本数据类型之间的相互转换

相同类型、不同精度之间的转换

// 整型和浮点型之间转换
var aa int8 = 20
var bb int16 = 40
fmt.Println(int16(aa) + bb)

// 建议整型转换成浮点型
var cc int8 = 20
var dd float32 = 40
fmt.Println(float32(cc) + dd)

建议从低位转换成高位，高位转换成低位的时候如果转换不成功就会溢出，如下图所示

其他类型转换成字符串类型

**注意：**Sprintf 使用中需要注意转换的格式，int为%d 、float为%f、bool为%t、byte为%c

第一种方式，就是通过 fmt.Sprintf()来转换

// 字符串类型转换
var i int = 20
var f float64 = 12.456
var t bool = true
var b byte = 'a'
str1 := fmt.Sprintf("%d", i)
fmt.Printf("类型：%v-%T \n", str1, str1)
//输出结果： 值：20类型：string
str2 := fmt.Sprintf("%f", f)
fmt.Printf("类型：%v-%T \n", str2, str2)
//输出结果： 值：12.456000类型：string
str3 := fmt.Sprintf("%t", t)
fmt.Printf("类型：%v-%T \n", str3, str3)
//输出结果： 值：true 类型：string
str4 := fmt.Sprintf("%c", b)
fmt.Printf("类型：%v-%T \n", str4, str4)
//输出结果： 值：a 类型：string

第二种方法就是通过strconv包里面的集中转换方法进行转换

**优点：**这个方法不仅能把其他类型转换成string类型，也能吧string类型转换成数值类型

// int类型转换str类型
var num1 int64 = 20
s1 := strconv.FormatInt(num1, 10)
fmt.Printf("转换：%v - %T", s1, s1)

// float类型转换成string类型
var num2 float64 = 3.1415926

/*
		参数1：要转换的值
		参数2：格式化类型 'f'表示float，'b'表示二进制，‘e’表示 十进制
		参数3：表示保留的小数点，-1表示不对小数点格式化
		参数4：格式化的类型，传入64位 或者 32位
	 */
s2 := strconv.FormatFloat(num2, 'f', -1, 64)
fmt.Printf("转换：%v-%T", s2, s2)

字符串类型转换成int 和 float类型

str := "10"
// 第一个参数：需要转换的数
// 第二个参数：进制
// 第三个参数：32位或64位
num,_ = strconv.ParseInt(str, 10, 64)

// 转换成float类型
str2 := "3.141592654"
num,_ = strconv.ParseFloat(str2, 10)

数值类型没法和bool类型进行转换

注意：在go语言中数值类型没法直接转换成bool类型，bool类型也没法直接转换成数值类型。

5、运算符

内置的运算符

• 算数运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符

算数运算符

在golang中， ++ 和 -- 只能单独使用，错误的写法如下

var i int = 8
var a int
a = i++  // 错误，i++只能单独使用
a = i--  // 错误，i--只能单独使用

同时在golang中，没有 ++i这样的操作

var i int = 1
++i  // 错误

正确的写法

var i int = 1
i++ //正确

关系运算符

逻辑运算符

8& 逻辑AND运算符。如果两边的操作数都是True，则为True,否则为 False || 逻辑OR运算符。如果两边的操作数有一个True，则为True,否则为False ！ 逻辑NOT运算符。如果条件为True，则为False，否则为True

当&&左边的条件为False时，不会执行&&右边的代码，称为&&逻辑短路

当||左边已经为true了，不会执行||右边的代码，称为||逻辑短路

赋值运算符

运算符练习

位运算符

6、流程控制

流程控制是每种编程语言控制逻辑走向和执行次序的重要部分，流程控制可以说是一门语言的“经脉"

Go 语言中最常用的流程控制有if和for，而switch和goto主要是为了简化代码、降低重复代码而生的结构，属于扩展类的流程控制。

if else

推荐if后面不适用括号，当然也可以使用括号括起来

func main() {
	var num = 10
	if num == 10 {
		fmt.Println("hello == 10")
	} else if(num > 10) {
		fmt.Println("hello > 10")
	} else {
		fmt.Println("hello < 10")
	}
}

if的另外一种写法，下面的方法的区别是 num2是局部变量

if num2:= 10; num2>=10 {
    fmt.Println("hello >=10")
}

**注意：**if的{}不能省略，哪怕只有一句。{}的左括号必须紧挨着语句

for 循环结构

Go语言中的所有循环类型均可使用for关键字来完成

for循环的基本格式如下：

for 初始语句; 条件表达式; 结束语句 {
	循环体
}

条件表达式返回true时循环体不停地进行循环，直到条件表达式返回false时自动退出循环

实例：打印1 ~ 10

for i := 0; i < 10; i++ {
    fmt.Printf("%v ", i+1)
}

注意，在Go语言中，没有while语句，我们可以通过for来代替

for {
    循环体
}

for循环可以通过break、goto、return、panic语句退出循环

for range（键值循环）

Go 语言中可以使用for range遍历数组、切片、字符串、map及通道（channel）。通过for range遍历的返回值有以下规律：

• 数组、切片、字符串返回索引和值。
• map返回键和值。
• 通道（channel）只返回通道内的值。

实例：遍历字符串

var str = "你好golang"
for key, value := range str {
    fmt.Printf("%v - %c ", key, value)
}

遍历切片（数组）

var array = []string{"php", "java", "node", "golang"}
for index, value := range array {
    fmt.Printf("%v %s ", index, value)
}

switch case

使用switch语句可方便的对大量的值进行条件判断

extname := ".a"
switch extname {
	case ".html": {
		fmt.Println(".html")
		break
	}
	case ".doc": {
		fmt.Println(".doc")
		break
	}
	case ".js": {
		fmt.Println(".js")
	}
	default: {
		fmt.Println("其它后缀")
	}
}

switch的另外一种写法

switch extname := ".a"; extname {
	case ".html": {
		fmt.Println(".html")
		break
	}
	case ".doc": {
		fmt.Println(".doc")
		break
	}
	case ".js": {
		fmt.Println(".js")
	}
	default: {
		fmt.Println("其它后缀")
	}
}

同时一个分支可以有多个值

extname := ".txt"
switch extname {
	case ".html": {
		fmt.Println(".html")
		break
	}
	case ".txt",".doc": {
		fmt.Println("传递来的是文档")
		break
	}
	case ".js": {
		fmt.Println(".js")
	}
	default: {
		fmt.Println("其它后缀")
	}
}

tip：在golang中，break可以不写，也能够跳出case，而不会执行其它的。

如果我们需要使用switch的穿透 fallthrought，fallthrough语法可以执行满足条件的 case 的下一个case，为了兼容c语言中的case设计

extname := ".txt"
switch extname {
	case ".html": {
		fmt.Println(".html")
		fallthrought
	}
	case ".txt",".doc": {
		fmt.Println("传递来的是文档")
		fallthrought
	}
	case ".js": {
		fmt.Println(".js")
		fallthrought
	}
	default: {
		fmt.Println("其它后缀")
	}
}

fallthrought 只能穿透紧挨着的一层，不会一直穿透，但是如果每一层都写的话，就会导致每一层都进行穿透

break：跳出循环

Go语言中break 语句用于以下几个方面：

• 用于循环语句中跳出循环，并开始执行循环之后的语句。
• break在switch（开关语句）中在执行一条case后跳出语句的作用。
• 在多重循环中，可以用标号label标出想break的循环。

var i = 0
for  {
    if i == 10{
        fmt.Println("跳出循环")
        break
    }
    i++
    fmt.Println(i)
}

go：跳转到指定标签

goto 语句通过标签进行代码间的无条件跳转。goto 语句可以在快速跳出循环、避免重复退出上有一定的帮助。Go语言中使用goto语句能简化一些代码的实现过程。

	var n = 20
	if n > 24 {
		fmt.Println("成年人")
	} else {
		goto lable3
	}

	fmt.Println("aaa")
	fmt.Println("bbb")
lable3:
	fmt.Println("ccc")
	fmt.Println("ddd")

7、数组

Array数组介绍

数组是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），这种类型可以是任意的原始类型，比如int、string等，也可以是用户自定义的类型。一个数组包含的元素个数被称为数组的长度。在Golang中数组是一个长度固定的数据类型，数组的长度是类型的一部分，也就是说[5]int和[10]int是两个不同的类型。Golang中数组的另一个特点是占用内存的连续性，也就是说数组中的元素是被分配到连续的内存地址中的，因而索引数组元素的速度非常快。

和数组对应的类型是Slice（切片），Slice是可以增长和收缩的动态序列，功能也更灵活，但是想要理解slice工作原理的话需要先理解数组。

数组定义

var 数组变量名 [元素数量] T

示例

// 数组的长度是类型的一部分
var arr1 [3]int
var arr2 [4]string
fmt.Printf("%T, %T \n", arr1, arr2)

// 数组的初始化 第一种方法
var arr3 [3]int
arr3[0] = 1
arr3[1] = 2
arr3[2] = 3
fmt.Println(arr3)

// 第二种初始化数组的方法
var arr4 = [4]int {10, 20, 30, 40}
fmt.Println(arr4)

// 第三种数组初始化方法，自动推断数组长度
var arr5 = [...]int{1, 2}
fmt.Println(arr5)

// 第四种初始化数组的方法，指定下标
a := [...]int{1:1, 3:5}
fmt.Println(a)

遍历数组

方法1

// 第四种初始化数组的方法，指定下标
a := [...]int{1:1, 3:5}
for i := 0; i < len(a); i++ {
	fmt.Print(a[i