golang学习笔记——基本语法

golang基本语法

变量定义

package main

import "fmt"

var(
	aa = 3
	ss = "kkk"
	bb = true
) 

func variableZeroValue()  {
	var a int							//无自定义初值，初值为0
	var s string						//无自定义初值，初值为空
	fmt.Println(a) 						//打印int初值，0
	fmt.Println(s)						//打印string初值
	fmt.Println(a, s)
	fmt.Printf("%d %q\n", a, s)			//可以打印空字符串
}

func variableInitiaValue()  {
	var a, b int = 3, 4					//可同时定义多个变量
	var s string = "abc"				//给string赋值
	fmt.Println(a, b, s)
}

func variableTypeDuction()  {
	// var a, b, c, s = 3, 4, true, "def"
	a, b, c, s := 3, 4, true, "def" 	//可定义多个不同类型的变量
	b = 5								//对已定义的变量进行重新赋值
	fmt.Println(a, b, c, s)
}


func main() {
	fmt.Println("Hello, world!")
	variableZeroValue()
	variableInitiaValue()
	variableTypeDuction()
	fmt.Println(aa, ss, bb)
}

内建变量类型

package main
 
import "fmt"
import "math"
import "cmplx"

func euler() {
	fmt.Println(cmplx.Exp(1i*math.Pi) + 1)
}

func main() {
	//内建变量类型：bool，string，
	//(u)int,(u)int8,(u)int16,(u)int32,(u)int64,uintptr,
	//byte,rune,float32,float64,complex64,complex128
	euler()
} 

强制类型转换

package main

import (
	"fmt"
	"math"
)

func triangle() {
	var a, b int = 3, 4
	var c int
	c = int(math.Sqrt(float64(a*a + b*b))) //必须输入float64类型的变量
	fmt.Println(c)
}

func main() {
	triangle()
}

常量和枚举

package main

import (
	"fmt"
	"math"
)

//常量
func consts() {
	const (
		filename = "abc.txt"
		a, b     = 3, 4
	) //一组常量
	var c int
	c = int(math.Sqrt(a*a + b*b)) //需要强制转换成int
	fmt.Println(filename, c)
}

//枚举
func enums() {
	const (
		cpp = iota //iota表示自增值
		java
		golang
		python
		_
		javascript
	) // 枚举

	const (
		b int64 = 1 << (10 * iota) //需要加上int64，不然会报overflows int, << 10表示2^10,1024
		kb
		mb
		gb
		tb
		pb
	)

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

func main() {
	consts()
	enums()
}

条件语句

package main

import (
	"fmt"
	"io/ioutil"
)

//if语句
func bounded() {
	const filename = "abc.txt" //需要在main目录下创建一个abc.txt文件

	if content, err := ioutil.ReadFile(filename); err != nil {
		fmt.Println(err) //如果没有该文件，则返回：content, err := ioutil.ReadFile(filename)
	} else {
		fmt.Printf("%s\n", content)
	}
}

//switch语句
func grade(score int) string {
	g := ""
	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 main() {
	bounded()
	fmt.Println(
		grade(0),
		grade(59),
		grade(60),
		grade(80),
		grade(99),
		grade(100),
		// grade(-1),  //会触发panic
	)
}

循环

package main

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

//循环
func convertToBin(n int) string {
	result := ""

	if n > 0 {
		for ; n > 0; n /= 2 {
			lsb := n % 2
			result = strconv.Itoa(lsb) + result// 反向添加
		}
	} else if n == 0 {
		result = "0"
	}

	return result
}

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() {
	fmt.Println(
		convertToBin(5),  //输出101
		convertToBin(13), //输出1101
		convertToBin(1234444444),
		convertToBin(0), //输出0
	)

	printFile("abc.txt")
	forever()
}

函数

package main

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

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 "/":
		return a / b, nil
	default:
		return 0, fmt.Errorf("unsupported operation : %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()
	fmt.Println(reflect.ValueOf(op))
	fmt.Println(p)
	opName := runtime.FuncForPC(p).Name() //返回函数名
	fmt.Println(runtime.FuncForPC(p))
	fmt.Printf("calling function %s with args "+"(%d,%d)\n", opName, a, b)
	return op(a, b)

}

func sum(values ...int) int {

	sum := 0
	for i := range values {
		sum += values[i]
	}
	return sum

}

func main() {

	if result, err := eval(3, 4, "x"); err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println(result)
	}
	// fmt.Println(eval(3, 4, "x"))
	fmt.Println(div(13, 3))

	fmt.Println(apply(func(a, b int) int {
		return int(math.Pow(float64(a), float64(b)))
	}, 3, 4))

	fmt.Println(sum(1, 2, 3, 4, 5))

}

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

指针

package main

import "fmt"

func swap(a, b int) {
	b, a = a, b
}

func swap1(a, b *int) {
	*b, *a = *a, *b
}

func swap2(a, b int) (int, int) {
	return b, a
}

func main() {
	a := 2
	b := 3
	swap(a, b)
	fmt.Println(a, b)        // 2, 3
	fmt.Println(swap2(a, b)) // 3, 2
	fmt.Println(a, b)        // 2, 3
	swap1(&a, &b)
	fmt.Println(a, b) // 3, 2
}

• go语言的指针不能运算
• go的参数传递是值传递