go - 03 基础语法（持续更新）

基本语法

标识符

由一个或是多个字母、数字、下划线组成，不能以数字开头。

行分隔符

一行代表一个语句结束，行尾不需要分号，（多个语句写在一行时需要用分号进行隔开）

注释

// 单行注释
/*
  多行注释
*/

package

一个可执行go程序只有一个main包, main package中的go程序文件直接存放在工程根目录。其他package下的程序文件存放在根目录下package对应的目录中。

package main

导包

import可以导入其他非main包，格式：[项目名/]包名

//单行导入
import "fmt"
//多行导入
import (
 "fmt"
 "os/user"
 "unsafe"
)

数据类型

声明举例	类型	说明
b	bool	//布尔型，默认值为false
_str	string	//字符串
_byte	byte	//类似uint8
_rune	rune	//类似uint32
_uint	uint	//32位或者64位
_int	int	//与uint一样大小
_uintptr	uintptr	//无符号整形，用于存放指针
_uint8	uint8	//无符号 8 位整型 (0 到 255)
_uint16	uint16	//无符号 16 位整型 (0 到 65535)
_uint32	uint32	//无符号 32 位整型 (0 到 4294967295)
_uint64	uint64	//无符号 64 位整型 (0 到 18446744073709551615)
_int8	int8	//有符号 8 位整型 (-128 到 127)
_int16	int16	//有符号 16 位整型 (-32768 到 32767)
_int32	int32	//有符号 32 位整型 (-2147483648 到 2147483647)
_int64	int64	//有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
f32	float32	//32位浮点型数
f64	float64	//64位浮点型数
comp64	complex64	//32位实数和虚数
comp128	complex128	//62位实数和虚数

常量声明

//单个声明
const KEY string = "hello.key"

//一次多个常量声明
const (
 PI      = 3.14 //类型可以省略。go会从右侧变量自动推断
 ENABLED = false
 a       = "abc"
 alen 	 = len(a) 	//常量可以用内置函数计算表达式的值。
 c       = unsafe.Sizeof(a)
)

iota，特殊常量，随代码执行顺序递增

const (
 i = iota * 2 //iota = 0 , i = 0*0 = 0
 j = iota * 2 //iota = 1 , j = 1*2 = 2
 k            //等效于“k = iota*2”,与上一行右侧表达式一致情况下可省略 
 m = "hello"  //iota += 1
 n            //iota = 4 , n="hello"
 x = iota     //iota = 5 , x = 5
 y            //iota = 6 , y = 6
)

全局变量

//全局变量
var name = "TOM"
var i1, i2, isOk = 1, 2, false

//多个全局变量
var (
	str  string    //未赋值时必须声明数据类型
	str1 = "world" //声明时就赋值则不需要声明数据类型，go会自动从右侧进行推断
)

局部变量声明

func hellogo() {
	var stuNo int    //一般类型声明
	stuName := "JIM" //简短声明(只能在方法体中使用简短声明)
	stuNo = 1001     //变量赋值操作

	//一次声明多个变量
	var enabled, disabled = true, false
	stuAge, StuAddress := 15, "湖北省武汉市"

	fmt.Println(stuName, stuNo)
	fmt.Println(enabled, disabled)
	fmt.Println(stuAge, StuAddress)
}

函数声明

//首字母大写 声明public类型的函数
func PublicFunc() {
	//全局的public函数也是go的export函数，导出函数应该有相应的注释。
}
//首字母小写表示函数为private
func privateFunc() {
	//
}

main函数

//main函数是go程序的入口
func main() {
	fmt.Println("main 函数开始执行...")
}

init函数

package中的init函数在package被导入时自动执行，可以在其中执行package中定义的变量。init函数可以定义多个，多个init函数执行时无先后顺序。（可以按照java中的static块来理解）

func init() {
	fmt.Println("init 11")
}
func init() {
	fmt.Println("init 22")
}

struct定义与声明

type MyStruct struct{
  Name string 
  //匿名struct
  Desc struct{
    ID int
    DescStr string
  }
}
func print(){
  ms := MyStruct{}
  fmt.Println("%v",ms)
  ms1 := struct{
    Name string
    age int
  }{"Tom",25}
  fmt.Printf("%v",ms1)
}

interface定义与声明

//接口定义
type MyInterface interface{
  //接口方法
  Fn()
}

//实现类定义
type MyImpls struct{}
//实现接口中的函数
func (impl *MyImpls) Fn() {
	//do something
}

func Test(impl MyInterface) {
	impl.Fn()
}
func main() {
	impl := MyImpls{}
	Test(&impl)
}

if…case

x := "test"
if x == "test" {
	fmt.Println("x is test")
}

if x == "1" {

} else if x == "test" {

} else {

}

switch…case

sex := "M"
switch sex {
case "M":
	fmt.Println("man")
case "F":
	fmt.Println("woman")
	break
default:
	fmt.Println("no match")
}

go中的case子句会自动跳出,不需要显示使用break。增加break和不增加break效果一致

for循环

for index, count := 0, 3; index < count; index++ {
	fmt.Printf("第%d次循环", index)
	fmt.Println()
}

num := 1
for {
	switch num {
	case 1:
		fmt.Println("case1 执行")
		break 	//只会跳出case子句，不会跳出for循环
	case 2:
		fmt.Println("case2 执行")
	}
	break		//会跳出for循环
}

nums := [1,2,3,4,5]
for i,v := range nums{
  fmt.Printf("nums[%d]:%f\n", i, v)
}

Slice(切片/数组)

var arys [5]int  						//声明切片
fmt.Println(arys)
nums := make([]float32, 3)  //利用make函数声明切片
nums1 := []int{1, 2, 3} 		//利用字面常量声明切片 

字符串

	//定义字符串
	str := "hello world !"
	//前缀判断
	res := strings.HasPrefix(str, "hello")
	//后缀判断
	res := strings.HasSuffix(str, "!")
	//遍历字符串，i为字符下标
	for i, s := range ary {
		fmt.Printf("%d:%s\n", i, s)
	}
	//拆分为数组
	ary = strings.Split(str, "l")

Map

func mapDemo() {

	week := map[int]string{
		1: "张三",
		2: "李四",
		3: "小明",
		4: "老王",
		5: "二蛋",
		6: "玲玲",
		7: "费邪",
	}

	fmt.Printf("原始map:%v\n", week)
	keys := make([]int, len(week))
	i := 0
	for k := range week {
		keys[i] = k
		i++
	}
	sort.Ints(keys)
	for _, k := range keys {
		fmt.Printf("key:%d,val:%s", k, week[k])
	}
}

List

type student struct {
	stuNo   int
	stuName string
}
func (ptr student) String() string {
	return fmt.Sprintf("{stuNo:%d,stuName:%s}", ptr.stuNo, ptr.stuName)
}
func listDemo() {
	list := list.New()
	list.PushBack(101)
	list.PushBack("102")
	list.PushBack(103)

	stu := new(student)
	stu.stuNo = 100
	stu.stuName = "校长"

	var stu1 student
	stu1.stuNo = 24
	stu1.stuName = "老王"

	list.PushBack(stu)
	for e := list.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)
	}
	fmt.Println(stu1)
	fmt.Println(stu)
	fmt.Println(list)
}

Stack

func structDemo() {
	sta := new(stack.Stack)
	sta.Cap = 5

	sta.Push(19)
	sta.Push(12)
	sta.Push(13)
	fmt.Println(sta.Pop())
	fmt.Println(sta)
	sta.Push(188)
	fmt.Println(sta)
}