Go语言基本语法

Go语言基本语法

hello world.

package main

import "fmt"

func main() {
	fmt.Println("hello world")
}

变量

变量定义

默认零值

func variableZeroValue() {
   var a int
   var s string

   fmt.Printf("%d %q \n", a, s) // %q 可以把引号一起打出来，%s只打印出string内容
}

带有初始化值的变量

func variableInitValue() {
   var a, b int = 3, 4
   var s string = "abc"

   fmt.Println(a, b, s)
}

自动推断类型

func variableTypeDeduction() {
   var a, b, s = 1, 2, "def"

   fmt.Println(a, b, s)
}

简短的类型定义

func variableShorter() {
   a, b, s := 1, 2, "def"
    
   fmt.Println(a, b, s)
}

但是在函数外定义变量的时候不可以使用:=的形式定义变量

定义多个变量

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

内建变量类型

• bool, string
• (u)int, (u)int8, (u)int16, (u)int32, (u)int64, uintptr
• byte, rune(字符型，char)
• float32, float64, complex64, complex128

Complex(复数)

func euler() {
	c := 3 + 4i
	fmt.Println(cmplx.Abs(c)) // 求模长
}

构造欧拉公式

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

强制类型转化

• 类型转换是强制的
• var a, b int = 3, 4

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

常量

常量的定义

• const 数值可以作为各种类型使用

func consts() {
   const filename = "abc.txt"
   const a, b = 3, 4
   var c int
   c = int(math.Sqrt(a*a + b*b))
   fmt.Println(filename, c)
}

在不指定类型的使用常量既可以是int也可以是float

使用常量定义枚举类型

• 普通值的枚举类型
• 子增值的枚举类型

func enums() {
   const (
      cpp = iota // iota 自增
      java
      python
      golang
   )

   // b, kb, mb, gb, tb, pb
   const (
      b = 1 << (10 * iota)
      kb
      mb
      gb
      tb
      pb
   )

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

变量总结

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

控制循环语句

if

const filename = "abc.txt"
if contents, err := os.ReadFile(filename); err != nil {
   fmt.Println(err)
} else {
   fmt.Printf("%s \n", contents)
}

• if的条件里可以赋值
• if的条件里赋值的变量作用域就在这个if语句里

switch

func eval(a, b int, op string) int {
    var result int
    switch op {
    case "+":
        result = a + b
    case "-":
        result = a - b
    case "*":
        result = a * b
    case "/":
        result = a / b
    default:
        panic("unsupported operator:" + op)
    }
    return result
}

• switch会自动break，除非使用fallthrough

func grade(score int) string {
   result := ""
   switch {
   case score < 0 || score > 100:
      panic(fmt.Sprintf("Wrong score: %d", score))
   case score < 60:
      result = "F"
   case score < 80:
      result = "C"
   case score < 90:
      result = "B"
   case score <= 100:
      result = "A"
   }
   return result
}

• switch后面可以没有表达式

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 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")
    }
}

• for，if后面没有括号
• if条件里面也可以定义变量
• 没有while
• switch不需要break，也可以直接switch多个条件

函数（一等公民）

func eval(a, b int, op string) int {
	switch op {
	case "+":
		return a + b
	case "-":
		return a - b
	case "*":
		return a * b
	case "/":
		return a / b
	default:
		panic("unsupported operation: " + op)
	}
}

• 函数返回多个值时可以起名
• 仅用于非常简单的函数
• 对于调用者而言没有区别

函数语法要点回顾

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

指针

• 指针不能运算

参数传递

值传递？引用传递？

• go语言只有值传递一种方式

package main

import "fmt"

func main() {
	a := 1
	f(a)
	fmt.Println(a)
	fa(&a)
	fmt.Println(a)
}

func f(a int) {
	a++
}

func fa(pa *int) {
	*pa++
}