Golang基本语法

Golang打包命令

windows下使用git bash 执行如下打包Linux可执行程序：
export GOARCH=amd64
export GOOS=linux

• go build xxx.go
• go install xxx.go

Golang项目结构

• 项目名称
  • src：放置项目和库的源文件
  • bin：放置编译后的可执行文件
  • pkg：放置编译后生成的包/归档文件

Golang声明变量

var a int
var a, b int = 1, 2
var a, b, c = 1, "go", true //全局使用
a, b, c := 1, "go", true //只能再函数内使用
var (
    a = 1
    b = "go"
    c = true
)  //常用于全局变量声明

Golang数据类型

系统变量类型

bool
string
(u)int、(u)int8、(u)int16、(u)int32、(u)int64、uintptr
byte(uint8)、rune(int32 unicode)
float32、float64、complex64、complex128

// %T 打印数据类型

常量
不在代码里面调用也不会报错

const s string = "Hello"
const a, b = 3, 4
const (
    s1  = "golang"
    c   = 5
    MAX = 10
)

枚举
关键字：iota

func enumDemo() {
	const (
		Sunday = iota //0
		Monday  //1
		TuesDay //2
		Wednesday
		Thursday
		Friday
		Staurday
	)
	fmt.Println(Sunday, Monday, TuesDay, Wednesday, Thursday, Friday, Staurday)
}

类型定义与别名

type MyInt1 int //基于int定义一个新的类型
type MyInt2 = int //和int完全一样

var i int = 1
var i1 MyInt1 = MyInt1(i)
var i2 MyInt2 = i

---

• 类型定义：基于int创建的一个新类型，提高代码可读性
• 类型别名：基于int创建的一个别名，和远类型完全一样，用于包兼容
• 类型定义，转换的时候需要强制转换

算数运算符

运算符	说明	实例
+	相加	A+B
-	相减	A-B
*	相乘	A*B
/	相除	A/B
%	求余	A%B
++	自增	A++
–	自减	A–

关系运算符

运算符	说明	实例
==	判断两个值是否相等，相等返回True，否则返回False
!=	判断两个值是否不相等，不相等返回True，否则返回False
>	判断左边是否大于右边，大于返回True，否则返回False
<	判断左右是否小于右边，小于返回True，否则返回False
>=	判断左右是否大于等于右边，如果是返回True,否则返回False
<=	判断左右是否小于等于右边，如果是返回True，否则返回False

逻辑运算符

运算符	说明	实例
&&	逻辑and运算符，如果两边都是True，则返回True
II	逻辑OR运算符，两边一边为True，则返回True
！	逻辑not运算符，如果条件为True，则逻辑not条件True，返回False

条件语句

if bool表达式 {
	
}else if bool表达式 {
	
} else {
	
}

---

b := 22
switch b {
	case 21:
		fmt.Println("21")
	case 22:
		fmt.Println("22")

	}

switch {
	case b == 22:
		fmt.Println("22")
}

switch case 直到找到匹配项，默认情况下case匹配成功后就不会再执行其他的case，如果需要执行 后面的case则可以使用fallthrough

循环语句

func main() {
	//求和 1-100
	sum := 0
	for i := 0; i <= 100; i++ {
		sum += i
	}
	fmt.Println(sum)
	fmt.Println("---------")

	for { //死循环
		fmt.Println("test")
	}
}

• 不需要扩报包裹
• 没有初始值
• 没有初始值，没有循环条件表示死循环

循环控制语句

a := 15
	b := 15
	c := 20
	for a < 20 {
		a++
		if a == 16 {
			continue //跳出当次循环
		}
		fmt.Println(a)
	}
	fmt.Println("---------")
	for b < 20 {
		b++
		if b > 18 {
			break //跳出整个循环
		}
		fmt.Println(b)
	}

	Loop: for c < 25 {
		c++
		if c == 22 {
			goto Loop //将控制转移到被标记语句
		}
	}

• break 用于中断当前循环
• continue 用于跳过当前循环的语句，进入下一轮循环
• goto 将控制转移到被标记的语句

函数

func sum(nums ...int) int {
	s := 0
	for i := 0; i < len(nums); i++ {
		s += nums[i]
	}
	return s
}


func swap(a, b int) (x, y int) {
	x, y = b, a
	return
}

func main() {
	a, b := 10, 5
	fmt.Println(operate(a, b, "+"))
	fmt.Println(swap(a, b))

	file, err := os.Open("test.txt")
	if err != nil {
		fmt.Println("打开文件有误")
	} else {
		fmt.Println(file)
	}
}

• 函数返回值类型写在最后面
• 函数可以返回多个值，也可以给返回值命名，一般和error结合使用
• 函数式编程，函数也可以作为参数传递给其他函数
• go语言中没有默认参数，可选参数，但是可以使用可变参数列表

变量作用域

package main

import "fmt"

//全局变量
var g int = 100

// a, b形式参数
func sum(a, b int) int {
	// c 局部变量
	var c = 10
	return a + b + c
}

func main() {
	//局部变量
	var a, b, c int
	a = 10
	b = 20
	c = a + b
	fmt.Println(a, b, c)
}

• 局部变量：函数内定义的变量（作用域只在函数体内，参数和返回值变量也是局部变量）
• 全局变量：函数外定义的变量（全局变量可以在整个包，和外部包被导出后使用）
• 形式参数：函数定义中的变量（作为函数的局部变量来使用）

指针

var p int = 20 /* 声明实际变量 */
var ip *int    /* 声明指针变量 */
ip = &p        /* 指针变量的存储地址 */
*ip = 30       /*给指针变量赋值*/
fmt.Println(p)

• 指针变量指向一个值的内存地址，*是用于指定一个变量作为一个指针
• & 符号是用于取后面变量的内存地址