Golang基础语法

变量定义

package main

import (
	"fmt"
)

var test11 = 45 // 在main函数外部定义变量必须要用 var

var (
	aa = "多个也可以这样赋值"
	bb = 34
	cc = 232
)

func main() {
	//字符类型
	var tt = 'c'
	fmt.Printf("%c\n", tt)

	var test0 = 92
	var test1, test2, te = 34, 21, "可以不写类型, 且连续赋值"
	test3, test4 := "可以不用var声明, 使用 := 代替", 89

	fmt.Println("测试中文名", test11, test0,
		test1, test2, te, test3, test4, aa, bb, cc, tt)
}

常量定义

package main

func enum(){
	// 枚举类型
	const (
		cpp = 0
		java = 1
		python = 2
		golang = 3
	)
}

func main() {
	const aaa = "定义字符串"
	const a, b, c = 1, 2, 3

}

iota  自增关键字

package main

import "fmt"

func main() {
	const (
		cpp = iota + 2  // 自增 0 + 2
		java // 1 + 2
		python // 2 + 2
		golang // 3 + 2
		_ // pass
		rust // 5 + 2
	)
	// 可以使用_跳过

	fmt.Println(cpp, java, python, golang, rust)
}

条件语句

package main

import "fmt"

func _switch(a, b int, op string) int{
	// 没有 break
	var result int
	switch op {
	case "+":
		result = a + b
	case "-":
		result = a - b
	default:
		panic("unsupported op")
	}
	return result
}


func main() {
	if b := _switch(3, 4, "+"); b == 7{
		fmt.Println("表达式中可以同时包含同时包含变量定义、赋值和判断")
	}
}

循环语句

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	// 通用方式
	for i := 0; i < 100; i++{
		fmt.Println(i)
	}
	// 省略初始条件
	j := 3
	for ; j <= 5; j++{
		fmt.Println(j)
	}

	// 死循环，等效于其他语言的 while True
	a := 3
	for {
		a ++
		fmt.Println(a)
		if a > 100{
			break
		}

	}

	//
	file, err := os.Open("1_基础语法/bnode_1_基础语法")
	print(err)
	scanner := bufio.NewScanner(file)
	for scanner.Scan(){ // 相当于迭代器
		fmt.Println(scanner.Text()) // 使用 scanner.Text() 获取
	}

}

函数

package main

import (
	"fmt"
	"reflect"
	"runtime"
)

// 基本定义
func test1(a int, b int) (int, int) {
	return a + 1, b + 1
}

// 可给返回值起名字，分别叫q、c
func test2(a int, b int) (q, c int) {
	return a + 1, b + 1
}

// 可设置函数参数
func apply(op func(int, int) (int, int), a int, b int) (int, int) {
	// 使用 反射 获取函数名
	opPoint := reflect.ValueOf(op).Pointer()
	funcName := runtime.FuncForPC(opPoint).Name()
	fmt.Printf("调用函数： %s, 参数：a: %d, b %d", funcName, a, b)

	return op(a, b)
}

// 可变参数
func test12(nums ...int) int {

	for _, num := range nums{
		print(num)
	}
	return 45
}

func main() {
	q, r := test1(1, 3)
	println(q, r)

	// 如果只想用一个，可以使用 _
	q2, _ := test1(1, 3)
	println(q2)

	// 可传递函数指针作为参数
	q1, r1 := apply(test1, 4, 5)
	println(q1, r1)

	// 匿名函数可以直接定义在参数列表中, 匿名函数定义不用写 函数名
	println(apply(
		func(a, b int) (int, int) {
			return a + 2, b + 45
		}, 4, 5))

	// 可变参数列表
	test12(1, 2, 3, 4, 5)

}

指针

package main

func main() {
	// 赋值
	var a = 2
	var p *int = &a
	*p = 3
	print(*p)
}