01 go基础语法

1、定义var关键字：

（1）var a,b,c bool
（2）var aa,bb string = “hello”,“world”
（3）可放在函数内，或直接放在包内。
（4）函数内使用案例（可使用 : 替代定义变量，但只能在函数内使用）：

package main
import "fmt"
func funOne()  {
	//: 等于 var
	a,b,c,d,e := 1,2,true,"qwe",3
	b = 10	// 给b重新赋值
	fmt.Println(a,b,c,d,e)
}
func main() {
	funOne()
}

（5）包内使用案例（可使用var()集中定义变量）：包内指package（package main），相当于函数外。

var qq = true    
var (
	aa = 1
	ss = "qqq"
	bb = false
)

2、内建变量类型：

（1）bool,string
（2）整数类型：(u)int,(u)int8,(u)int16,(u)int32,(u)int64,uintptr
	加u无符号整数。不加u有符号整数。
	有符号整数分两类：规定符号长度（如：int8,int16...）和不规定长度。
	uintptr:无符号整型，用于存放一个指针。
（3）byte,rune
（4）float32，float64，complex64，complex128	
详见：https://www.runoob.com/go/go-data-types.html

3、强制类型转换（类型转换是强制的）

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

4、常量与枚举

(1)常量的定义(const 数值可作为各种类型使用)：

func consts()  {
	const (
		name = "lili"
		a,b = 6,1
	)
	var c int
	c = int(math.Sqrt(a*a + b*b))
	fmt.Println(c)	// 6
}

（2）枚举类型：

// 普通枚举类型：
	func enums()  {
		const (
			cpp = iota
			java
			python
		)
		fmt.Println(cpp,java,python)	// 0 1 2 
	}
	
// 自增值枚举类型（iota）：
	func enums()  {
		// iota 自增值
		// _ 可以理解为占位
		const (
			cpp = iota
			_
			python
			golang
			javascript
		)
		const (
			b = 1<<(10*iota)
			c
			d
			e
		)
		fmt.Println(cpp,python,golang,javascript)	// 0 2 3 4
		fmt.Println(b,c,d,e)	// 1 1024 1048576 1073741824
	}

（3）定义要点：

• 变量类型写在变量名之后。
• 编译器可推测变量类型。
• 没有char，只有rune。
• 原生支持复数类型。

5 条件语句

(1) if 条件语句。

• if判断条件是不需要放到括号里的。
• if 的条件里可以赋值。
• if 的条件里赋值的变量作用域就在这个if语句里。
• if 条件里也可定义变量。

func iffunmain() {
	const filename = "abc.txt";
	// 第一种写法
	contents,err := ioutil.ReadFile(filename)
	if err != nil {
		fmt.Println(err)
	}else {
		fmt.Printf("%s\n",contents)
	}
	//第二种写法—— 简写if语句：
	if contents,err := ioutil.ReadFile(filename) ; err != nil {
		fmt.Println(err)
	}else {
		fmt.Printf("%s\n",contents)
	}
}
func main() {
	iffunmain(); 
	/*  结果：
		同级目录未建abc.txt文件报：open abc.txt: no such file or directory
		已建abc.txt文件，会读取文件里的内容。如：找到abc.txt文件！啦啦啦
	*/
}

（2）switch 条件语句。

• switch 语句的不同的 case 之间不使用 break 分隔，默认只会执行一个 case。
• 如果我们需要执行后面的 case，可以使用 fallthrough 关键字：
  使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。
• switch 后可以没有表达式，在case 后加上条件语句也可以。
• switch 不需要break,也可以直接switch多个条件。

func switchfun(score int) string {
	g :=""
	switch {
	case score < 0 || score > 100 :
		panic( fmt.Sprintf("没有匹配项：%d",score))
	case score < 60 :
		g ="F"
	case score <= 100 :
		g ="A"
	}
	return g
}
func main() {
	fmt.Println(		
		switchfun(0),	// F
		switchfun(59),	// F 
		switchfun(100),	// A
	)
}

6、循环

（1）for 循环语句。

• for的条件里不需要括号。
• for的条件里可以省略初始条件，结束条件，递增表达式。

func convertToBin(n int) string {  // 整数转为二进制。
   	result := ""
   	for ; n>0; n/=2 {
   		lsb := n%2
   		result = strconv.Itoa(lsb)+result
   	}
   	return  result
   }
	func main() {
		fmt.Println(
			convertToBin(5),		// 101
			convertToBin(13),	// 1101
		)
	}


   func printFile(filename string)  {
   	file, err := os.Open(filename);	  // Open打开一个文件用于读取
   	if err != nil {
   		panic(err)
   	}
   	scanner := bufio.NewScanner(file)
   	for scanner.Scan(){
   		fmt.Println(scanner.Text())
   	}
  }
	func main() {
		printFile("abc.txt")	// 找到abc.txt文件！啦啦啦
	}

   // 死循环：结果会一直打印 "abc"
   func forever()  {
   	for  {
   		fmt.Println("abc")
   	}
   }

7、函数

• 返回值类型写在最后面。
• 可返回多个值。
• 函数作为参数。
• 没有默认参数，可选参数。

func eval(a,b int, op string) (int,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 main() {
	if result, err := eval(3,4,"X");err != nil {
		fmt.Println("Error:",err)
	}else {
		fmt.Println(result)
	}		// Error: 报错: X
   }

/*
   	返回两个或多个值。例：13 / 4 = 4 ...1
   	返回多个值时可以起名称
   	仅用于非常简单的函数
   	起什么名称，对调用者而言没有区别
   */
   func div(a,b int) (int,int) {
   	return a/b, a%b
   }
   func main() {
	a,b := div(13,3)
	fmt.Println(a,b)	// 4 1
   }

 /*
   	例：op是个函数，有两个参数，返回是int类型
   */
   func apply(op func(int,int) int,a,b int) int {
   	p := reflect.ValueOf(op).Pointer()
   	opName := runtime.FuncForPC(p).Name()
   	fmt.Printf("打印op函数 %s"+"(%d %d)",opName,a,b)
   	return op(a,b)
   }
   func main() {
	fmt.Println(apply(
		func(a int, b int) int {
			return int(math.Pow(
				float64(a),float64(b)))
		},3,4))	// 打印op函数 main.main.func1(3 4)81
   }

8、指针

参数传递：go语言只有值传递一种方式。

	例：互换两个值，需要传指针进去
		func swap(a,b *int)  {
			*a,*b = *b,*a
		}

• 当一个指针被定义后没有分配到任何变量时，它的值为 nil。
• nil 指针也称为空指针。
• nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。

 // 第一种写法：
   func swap(a,b *int)  {
   	*a,*b = *b,*a
   }
   func main(){
	a,b := 3,4
   	swap(&a,&b)
   	fmt.Println(a,b)	// 4 3
   }
   // 第二种写法：简化
   func swap(a,b int) (int,int) {
   	return b,a
   }
   func main() {
	a,b := 3,4
	a,b = swap(a,b)
	fmt.Println(a,b)	// 4 3
   }

最近在学某课的Go语言开发课程，为加深记忆，想着在学习的过程中做了一些笔记，不足之处，请各位大佬多多指正。