go基础笔记----基础语法

go语言安装与开发环境

    下载：https://studygolang.com/dl 选择相应的版本就好

基础语法

• 变量定义

package main

import "fmt"

// 在函数外部不可以使用:=来定义变量

// 定义包内部变量
var ii = 11

// 定义包内部多个变量
var (
	bb       = true
	ss       = "hello world"
	temp int = 123
)

func variable() {

	// 声明变量
	var a int // 变量名在类型之前
	var b string
	fmt.Printf("%d %q \n", a, b)

	// 赋初始值
	var c, e int = 1, 4
	var d string = "123"
	fmt.Println(c, d, e) // 变量定义即需要使用

	// 自动推断类型
	var g, f, h, i = 11, 44, true, "def"
	fmt.Printf("%d %d %v %s \n", g, f, h, i) // 格式化输出变量

	// 初始化
	j, k := 11, false
	k = true // 初始化之后可以重新赋值
	fmt.Printf("%d %v \n", j, k)
}

func main() {
	// 定义变量尽量短一点，能:= 来处理就可以使用，但是:= 只可以在函数内部使用
	variable()
	fmt.Println("hello world", ii, bb, ss, temp)
}

• 内建变量类型

package main

import (
	"fmt"
	"math"
	"math/cmplx"
)

func euler() {
	fmt.Printf("%.3f \n", cmplx.Exp(1i*math.Pi)+1)
}

func triangle() {
	var a, b int = 3, 4
	var c int
	c = int(math.Sqrt(float64(a*a + b*b)))
	fmt.Println(c)
}

func main() {
	/*
		1.bool
		2.string
		3.int (u)int8 (u)int16 (u)int32 (u)int64 uintptr（指针） //加u为无符号整形
		4.byte 8位
		5.rune 32位
		6.float32 float64 comexpl64 comexpl128 comexpl为复数 比如i=根号-1 i=3+4i 3为实部 4i为虚部首 后面听不懂了 见谅


	*/
	// 欧拉公式验证，使用复数
	euler()
	// 强制类型装换
	triangle()
}

• 常亮与枚举

package main

import "fmt"

func consts() {
	const (
		fileNameID = "abc.txt"
		a, b       = 3, 4
	)
	fmt.Println(fileNameID, a, b)
}

func enums() {
	// const ( //普通枚举 可以用自增来简写
	// 	cpp    = 0
	// 	java   = 1
	// 	python = 2
	// 	golang = 3
	// )

	// 普通枚举类型
	const (
		cpp = iota
		java
		_ // 代表一个元素
		python
		golang
		javascript
	)

	// 更加复杂的const表达式使用iota 来表示 b kb mb gb tb pb
	// 自增值枚举类型
	const (
		b = 1 << (10 * iota)
		kb
		mb
		gb
		tb
		pb
	)

	fmt.Println(cpp, java, python, golang, javascript)
	fmt.Println(b, kb, mb, gb, tb, pb)
}

func main() {

	// 自动判断类型的变量在计算的时候才会确定类型

	// 声明常量 常量可以作为各种类型使用
	consts()

	// 枚举类型
	enums()
}

• 条件语句与循环

package main

import (
	"bufio"
	"fmt"
	"io/ioutil"
	"os"
	"strconv"
)

func grage(score int) string {
	g := ""
	switch { // switch后面可以没有表达式
	case score < 0 || score > 100:
		panic(fmt.Sprintf(
			"Wrong score: %d", score))
	case score < 60:
		g = "f"
	case score < 80:
		g = "c"
	case score < 90:
		g = "b"
	case score < 100:
		g = "a"
	}
	return g
}

func converToBin(n int) string {
	res := ""
	for ; n > 0; n /= 2 {
		lsb := n % 2
		res = strconv.Itoa(lsb) + res
	}
	return res
}

func printFile(filename string) {
	file, err := os.Open(filename)
	if err != nil {
		panic(err)
	}
	scanner := bufio.NewScanner(file)

	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}
}

func forever() {
	for {
		fmt.Println("abc")
	}
}

func main() {
	const filename = "abc.txt"
	// if语句里可以赋值 但是条件里赋值的变量作用域在if中 不可以在if外使用
	if contents, err := ioutil.ReadFile(filename); nil != err {
		fmt.Println(err)
	} else {
		fmt.Printf("%s \n", contents)

	}

	// switch
	fmt.Println(grage(11))
	// for 整数转化为二进制表达式
	fmt.Println(converToBin(13))
	printFile("abc.txt")
	forever()

}

• 函数

package main

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

func eval(a, b int, op string) (int, error) { //返回多个值，error用来判断出错情况
	switch op {
	case "+":
		return a + b, nil
	case "-":
		return a - b, nil
	case "*":
		return a * b, nil
	case "/":
		q, _ := div(a, b) //返回多个值 但是需要其中一个，多余的值需要使用 _ 替代
		return q, nil
	default:
		return 0, fmt.Errorf("没有找到运算符号：%s", op)
	}
}

//返回值可以使用名字 仅用于比较简单的函数使用
func div(a, b int) (q, r int) {
	return a / b, a % b
}

func apply(op func(int, int) int, a, b int) int {
	p := reflect.ValueOf(op).Pointer()
	opName := runtime.FuncForPC(p).Name()
	fmt.Printf("calling function %s with args"+
		"(%d, %d \n)", opName, a, b)
	return op(a, b)
}

func sum(numbers ...int) int {
	s := 0
	for i := range numbers {
		s += numbers[i]
	}
	return s
}

func pow(a, b int) int {
	return int(math.Pow(float64(a), float64(b)))
}

func main() {
	if result, err := eval(3, 4, "("); err != nil {
		fmt.Println("error:", err)
	} else {
		fmt.Println(result)
	}
	q, r := div(13, 3)
	fmt.Println(q, r)
	fmt.Println(sum(1, 2, 3, 4, 5))

}

• 指针

package main

import "fmt"

// 引用传递 交换两个数
func swap1(a, b *int) {
	*b, *a = *a, *b
}

// 直接返回结果
func swap2(a, b int) (int, int) {
	return b, a
}

func main() {
	// go语言指针不可以运算
	// go指针传递为值传递
	a, b := 3, 4
	swap1(&a, &b)
	fmt.Println(a, b)
	a, b = swap2(a, b)
	fmt.Println(a, b)

}