初识Go的语法（三）

一、Hello Word初识

先来解释一下上次的代码

package main // 声明 main 包，表明当前是一个可执行程序

import (
	"fmt"
) // 导入内置 fmt 包

func main() { // main函数，是程序执行的入口
	fmt.Println("Hello World!") // 在终端打印 Hello World!
}

1、package main

package 是一个的包声明关键字，作用是声明当前文件属于那个包 main是包名，，另外如果包名是main 那么当前这个代码会被编译行可执行文件，如果需要声明包给别人用，那就不能使用main做包名，，且在main 包下·要有一个main函数（函数看下面第三小节）

2、import

import是导入语句，导入包，这里我们导入了“fmt”这个包

3、func

func是用来声明函数的，这里我们声明了一个main函数，在main函数里执行了打印语句 main函数也是程序的入口函数

二、语法初识

变量与常量

1、常见变量的数据类型

有：整型、浮点型、布尔型等

2、Go语言的变量声明格式为：

var 变量名 变量类型
变量声明以关键字var开头，变量类型放在变量的后面，行尾无需分号
例如：

var name string
var age int

3、批量声明变量

var (
name string
age int
)

4、变量的初始化

• 整型和浮点型变量的默认值为0
• 字符串变量的默认值为空字符串
• 布尔型变量默认为false
• 切片、函数、指针变量的默认为nil

var 变量名 类型 = 表达式

var name string = "zx"
var age int = 21

如果嫌麻烦也可以将类型省略声明，编译器会根据等号右边的值来推导变量的类型完成初始化。

var name = "zx"
var age = 21

如果还嫌麻烦，可以在函数内部使用短变量
变量名 := 值
注意： 不能使用在函数外使用短变量
函数外的每个语句都必须以关键字开始（var、const、func等

func main(){
n := 10
m := 200 // 此处声明局部变量m
}

5、匿名变量~~（我个人是不推荐使用的）~~

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示，例如

func foo() (int, string) {
	return 10, "Q1mi"
}
func main() {
	x, _ := foo()
	_, y := foo()
	fmt.Println("x=", x)
	fmt.Println("y=", y)
}

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

6、常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明，只是把var换成了const，常量在定义的时候必须赋值。

const pi = 3.1415
const e = 2.7182

声明之后就不能再修改了

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

const (
    n1 = 100
    n2
    n3
)

标识符与关键字

在编程语言中标识符就是程序员定义的具有特殊意义的词，比如变量名、常量名、函数名等等。 Go语言中标识符由字母数字和_(下划线）组成，并且只能以字母和_开头
Go语言中有25个关键字，37个保留字
关键字

    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

保留字

        onstants:    true  false  iota  nil

        Types:    int  int8  int16  int32  int64  
                  uint  uint8  uint16  uint32  uint64  uintptr
                  float32  float64  complex128  complex64
                  bool  byte  rune  string  error

    Functions:   make  len  cap  new  append  copy  close  delete
                 complex  real  imag
                 panic  recover

三、基本数量类型

Go语言中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道（channel）等。Go 语言的基本类型和其他语言大同小异。

整形

整型分为以下两个大类： 按长度分为：int8、int16、int32、int64 对应的无符号整型：uint8、uint16、uint32、uint64

uint8就是我们熟知的byte型，int16对应C语言中的short型，int64对应C语言中的long型。
在使用int和 uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。这个和c语言类似，再不同平台上有差异，
例如 int 在32位操作系统上就是int32，64位操作系统上就是int64

浮点型

Go语言支持两种浮点型数：float32和float
64float32 的浮点数的最大范围约为 3.4e38
常量定义 ：math.MaxFloat32

float64 的浮点数的最大范围约为 1.8e308
常量定义：math.MaxFloat64

布尔值

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。 默认为false
1、Go 语言中不允许将整型强制转换为布尔型.
2、布尔型无法参与数值运算，也无法与其他类型进行转换

字符串

Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64 等）一样。 Go 语言里的字符串的内部实现使用UTF-8编码

1、转义字符

转义字符	值
\r	回车符（返回行首）
\n	换行符（直接跳到下一行的同列位置）
\t	换行符制表符
\’	单引号
\"	双引号
\	反斜杠

f方法名	作用
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作

2、多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号字符

const string k=`1234
11223
1122
`

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出

byte和rune类型

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

• uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
• rune类型，代表一个 UTF-8字符。
  当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32

修改字符串

字符串底层是一个byte数组，所以可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成，所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符，一个rune字符由一个或多个byte组成。
要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

func changeString() {
	s1 := "big"
	// 强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))

	s2 := "白萝卜"
	runeS2 := []rune(s2)
	runeS2[0] = '红'
	fmt.Println(string(runeS2))
}

类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

T(表达式)

其中，T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等.

四、运算符

Go语言的运算符与其他语言并无太大差距，额几乎没有差距吧

算术运算符

加（+）
减（-）
乘（*）
除（/）
求余（%）

关系运算符

等于 ==
不等于 !=
大于>
小于<
大于等于 >=
小于等于<=

逻辑运算符

逻辑与 &&
逻辑或 ||
逻辑非 !

赋值运算符

= 赋值
+= 相加再赋值
-= 相减再赋值
*= 相乘再赋值
%= 取模再赋值
还有其他的就不一一列举了

流程控制

如果有其它语言的基础，那么流程控制应该是没什么问题的，其实流程控制和绝大多数语言是类似的，当然也增加了一些东西，毕竟是新语言，没点创新的想法肯定是不行的。

选择结构

普通if

if 表达式1 {
    分支1
} else if 表达式2 {
    分支2
} else{
    分支3
}

特殊if

func ifDemo2() {
	if score := 60; score >= 80 {
		fmt.Println("A")
	} else if score > 70 {
		fmt.Println("B")
	} else {
		fmt.Println("C")
	}
}

循环结构

格式

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

样例

func main() {
	for i := 0; i < 10; i++ {
		fmt.Println(i)
	}
}

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

for range(键值循环)

Go语言中可以使用for range遍历数组、切片、字符串、map 及通道（channel）,注意：

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

循环终止

Go语言里面的循环可以通过 break（跳出）、continue（跳过一次）go to（跳转到指定标签）

break

func main() {
d1:
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break d1
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	fmt.Println("...")

go to

func gotoDemo2() {
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// 设置跳出标签
				goto breakTag
			}
			fmt.Printf("%v-%v\n", i, j)
		}
	}
	return
	// 标签
breakTag:
	fmt.Println("结束for循环")
}