go 语言基本语法

构建

执行代码：

1. 打开命令行，并进入程序文件保存的目录中。

2. 输入命令 go run hello.go 并按回车执行代码。

   

构建可执行程序： go build hello_go.g

        

//package main 定义了包名。package main表示一个可独立执行的程序
package main

//import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），
//fmt 包实现了格式化 IO（输入/输出）的函数
import (
	"fmt"
)

func numbers() (int , int, string) {
	return 2, 4, "wer"
}

//声明一个函数类型
//函数名：functype 参数：int 返回值：string
type functype func(int) string


func main() {
	/*
		这是一行注释
	*/
	fmt.Println("hello, go world")
	fmt.Println("hello, world!\n")
	var tmpnum = 123
	var data = "2020-12-31"
	var url = "Num=%d & data=%s"
	var target_url = fmt.Sprintf(url, tmpnum, data)
	fmt.Println(target_url)

	//变量定义
	var tmp int
	var str bool
	fmt.Println(tmp)
	fmt.Println(str)

	//_ 为点位符，不使用函数返回值时，可用_代替
	_, num2, str33 := numbers()
	fmt.Println(num2, str33)

	//定义常量
	const length int = 10
	const width int = 5
	var area int
	//多常量同时定义
	const consta, constb, constc = 1, false, "str"
	area = length * width
	fmt.Printf("面积为：%d", area)

	//iota，特殊常量，可以认为是一个可以被编译器修改的常量。
	const(
		a = iota
		b = iota
		c = iota
	)
	println(a, b, c)

	//循环
	sum := 0
	for i:=0; i<=10; i++ {
		println(i)
		sum+=i
		fmt.Println("sum: ",sum)
	}
	sum=1
	for sum<=10 {
		sum +=sum
		println("summmmm: ", sum)
	}
	sum = 0
	//死循环
	//for {
	//	sum++
	//	println(sum)
	//}

	strings := []string{"google", "runoob"}
	strings = append(strings, "aaa")
	//迭代遍历数组
	for i, s:= range strings{
		fmt.Println(i, s)
		//strings = append(strings, "a")
	}
	//数组不够位置时，默认为0
	numbers := [6]int{1,2,4}
	for i, x := range numbers{
		println("numbers: ",i, x)
	}

	fmt.Println("----- break label ----")
	re:
		for ii:=0 ; ii < 4; ii++ {
			println("第一层循环：ii = ", ii, "\n")
			for jj:=0; jj < 2; jj++{
				println("第二层循环：jj= ", jj)
				if jj*ii == 4{
					break re
				}
			}
		}
	fmt.Println("------ goto -------")
	var num int = 0
	LOOP: for  num <=4 {
		if num == 2{
			num++
			goto LOOP
		}
		fmt.Printf("num= %d\n", num)
		num++
	}

	fmt.Println("----- 回调函数 -----")
	testCallBack(1, callBack)
	testCallBack(1, func(i int) string {
		fmt.Printf("回调函数：i: %d\n",i)
		str := string(i)
		return str
	})

	fmt.Println("----- 闭包 --------")
	//创建nextNumber函数变量接收 getSequence()返回值 此时 i = 0
	nextNumber := getSequence()
	/* 调用 nextNumber 函数 ，i变量+1 并返回 */
	fmt.Println("nextNumber()", nextNumber())
	fmt.Println("nextNumber()", nextNumber())

	fmt.Println("------ 数组 -------")
	balance2 := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
	/* 输出每个数组元素的值 */
	for j := 0; j < 5; j++ {
		fmt.Printf("balance2[%d] = %f\n", j, balance2[j] )
	}
	//  将索引为 1 和 3 的元素初始化
	balance3 := [5]float32{1:2.0,3:7.0}
	for k := 0; k < 5; k++ {
		fmt.Printf("balance3[%d] = %f\n", k, balance3[k] )
	}

	fmt.Println("------range-----")
	nums := [] int {2,3,4}
	summ := 0
	//使用range 遍历切片，并求和
	for _, num :=range nums {
		summ += num
	}
	fmt.Println("sum: " ,summ)
	//在数组上使用range将传入index和值两个变量。上面那个例子我们不需要使用该元素的序号，
	//所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
	for i, num := range nums {
		if num == 4 {
			fmt.Println("index: ", i)
		}
	}
	kvs := map[string] string{"a":"apple", "b": "banana"}
	for k ,v :=range kvs{
		fmt.Printf("kvs: %s -> %s\n", k, v)
	}
	//range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
	for i,c := range "good"{
		fmt.Printf("good: %d —> %s\n", i, c)
	}
}

func testCallBack(x int, f functype )  {
	f(x)
}

func callBack(x int ) string  {
	x++
	var str string = string(x)
	fmt.Printf("回调函数：x: %d\n",x)
	return str
}

//函数闭包
//getSequence() 返回函数func，在返回函数中执行 i+1,并在返回函数中返回 i 的值
func getSequence() func() int {
	i:=0
	fmt.Println("getSequence():: i= ", i)
	return func() int {
		i+=1
		fmt.Println("getSequence()::return i= ", i)
		return i
	}
}