IKun来讲Go语法喽

1.基本变量类型

(1).int(整型）在 java、C++、C中均有该类型，不再缀述。

(2).string(字符串) 划重点！！！在Go中非常重要的类型，在C++、java中也存在该类型，但C++中有char类型，在Go中无char类型,重点是其方法。

(3).bool(布尔类型) 在C++、java中也有该类型不再缀述。

(4).指针类型,可以理解为地址，其存放的是变量所在的地址，指向变量。

(5).数组类型，其为静态数组，使用起来不方便,常使用切片来代替数组使用。

(6).切片类型，其为动态数组，可以动态扩容，使用时注意和python中切片的区别

(7).map类型，类似于Java和C++中的map，但有区别，例如在C++中map会根据key值对map中的元素进行排序，而在Go中map中的元素无固定位置，每次使用range对其进行遍历时，其元素会随机生成一个位置。

(8).结构体类型，类似于C++、C中的结构体

2.变量声明方式

(1)第一种声明方法：var + 变量名 + 类型 (= 值)(值可省略也可不省略)

(2)第二种声明方法：var + 变量名 = 值 (此时值不可省略，因为需要根据值推导变量的类型)

(3)第三种声明方式: 变量名 := 值 （此时值也不可省略)

举例说明：

var Practice_years float = 2.5 //第一种声明方法(练习时长两年半(bushi)) var Practice_years float 可以不赋值
var Practice_years_2 = 2.5  //第二种声明方法 var Pactice_years_2 不赋值报错
Practice_years_3 := 2.5     //第三种声明方法

3.分支语句

(1).if-else语句：用法和C/C++中的类似，但不需要对条件加括号，如果加了括号，编译器会自动去掉括号

(2).switch语句 语法格式如下

switch var1{
    case var2:
    case var3:
    ``````
    default:

上述var1 可以为空，var2.var3可以为和var1同类型的任何值,对于同一个case可以检测多个值，用","隔开所有的值即可。和C++/C不同的点在于Go中的Switch由上往下检测到第一个符合条件的case语句时便不再向下检测，因此无需添加break语句

4.循环语句

在Go中只有for语句，没有while语句，for的语法格式和C/C++类似，可以使用continue来继续循环，使用break跳出循环

基本语法如下：

//死循环写法
for{
·······
}
//基本写法
for exp; exp; exp{
}
实现字符串反转循环写法示例
name := "IKun"
name_ := []rune(name) //rune是一个基本类型，用于区分字符类型和整数类型，这里是一个强转，它可以将每一个字符强制转换成int32类型并保存在数组中
for i, j := 0, len(name_) - 1; i < j; i, j = i + 1, j - 1{
        name_[i], name_[j] = name_[j], name_[i] 
}
fmt.Println(string(name_)//将int32类型的数组强转成字符串类型

5.数组介绍

(1)声明方法：var + 数组名 + [size]数组类型

(2)赋值方法：与C/C++赋值方法类似使用 数组名[Index] = value的方式赋值

(3)特点：静态数组，在实际中不常用，常使用slice(切片)

6.切片介绍

(1)主要介绍：切片在Go中为动态数组，类似于C++中的vector可以动态扩容

(2)创建方法：

第一种方法：var + 切片名 + [] + 切片类型

第二种方法: 切片名 := make([] + 切片类型,长度，容量)其中容量可以省略，省略默认为长度

第三种方法: 切片名 := 另一个切片[start:end]此方法类似于Python中的切片，范围为左闭右开。

下面是对上述方法的的示例

var Xiao_hz []string //第一种声明方法
Xiao_hz_2= make([]string,4,8) //第二种声明方法，创建一个长度为4，容量为8的名为Xiao_hz_2的字符串切片
var Xiao_hz_3 [5]string
Xiao_hz_4 := Xiao_hz_3[2:4]//第三种声明方法，将字符串数组Xiao_hz_3[2,4)元素拷贝给Xiao_hz_4

(3)切片扩容并且添加值：使用append()函数进行添加值并且扩容，其返回类型也为切片，而且扩大的容量为之前容量的2倍。以下为示例：

	Ikun := make([]string, 3)
	Ikun[0] = "xiaoheizi"
	Ikun[1] = "niganma"
	Ikun[2] = "aiyou"
	Ikun = append(Ikun, "maganyou", "ttt", "laa")
	fmt.Println(Ikun)

7.结构体介绍

(1).基本语法介绍：type + 名称 + struct { } 结构体内可直接声明变量无需添加 var,可定义结构体的方法,基本定义方法的格式如下: func (结构体实列名 + 结构体名) + 方法名称() + 返回类型 其中返回类型可省略，即类似于C/C++中的void类型

(2).基本示例：下面是一个使用Go语言编写的链表示例希望能够帮助你理解结构体的使用

package main

import (
	"fmt"
)

type node struct { //链表的每一个结点
	value int
	next  *node
}
type list struct {
	head node // 头结点，其本身不存值
	size int  // 链表结点数目
}

func (_list *list) getsize() int { //获取链表数目
	return _list.size
}
func (_list *list) insert(index int, Node *node) bool { //向链表指定位置插入一个元素
	if index > _list.size { //插入位置不合法
		return false
	}
	var temp *node = &_list.head //获取头结点
	for i := 0; i < index; i++ { //寻找插入位置
		temp = temp.next
	}
	temp2 := temp.next
	temp.next = Node
	Node.next = temp2
	_list.size += 1
	return true
}

func (_list *list) erasevalue(index int) (node, bool) { //删除并返回一个结点
	if index >= _list.size {
		return node{-1, nil}, false //删除位置不合法
	}
	temp := &_list.head
	for i := 0; i < index; i++ { //寻找删除结点位置
		temp = temp.next
	}
	ret := *temp.next
	temp.next = temp.next.next
	_list.size -= 1
	return ret, true
}
func (_list *list) reverse() { //链表反转
	if _list.size == 0 { //0个结点不反转
		return
	} else if _list.size == 1 { //1个结点只反转两个结点
		pre := &_list.head
		cur := pre.next
		cur.next = pre
		pre.next = nil
		_list.head = *cur
	} else { //两个以上记录三个结点的信息
		pre := _list.head.next
		cur := pre.next
		next := cur.next
		pre.next = nil
		for next != nil {
			cur.next = pre
			pre = cur
			cur = next
			next = next.next
		}
		cur.next = pre
		var newhead node = node{-1, nil}
		newhead.next = cur
		_list.head = newhead
	}
}
func (_list *list) print() {
	first := _list.head.next
	for first != nil {
		fmt.Print(first.value, " ")
		first = first.next
	}
}
func main() {
	var t list
	var Node node
	Node.value = 2
	Node.next = nil
	t.insert(0, &Node)
	t.insert(1, &node{3, nil})
	t.insert(2, &node{4, nil})
	t.insert(3, &node{5, nil})
	fmt.Println(t.getsize())
	t.print()
	t.reverse()
	t.print()
}

Go语法的学习任重道远，作为一名合格的IKUN希望这些能够帮助到你。