三.GO语言的基本语法

一.基本数据类型和操作符

1.1文件名、关键字、标识符

1.1.1 命名规则：

1.1.2 常用的关键字如下所示：

关键字

内置常量：

      true    false    iota    nil

内置类型：

            int                 int8              int16                  int32               int64

   uint                uint8            uint16               uint32              uint64                                    

   uintptr            float32         float64              complex128 

   complex64     bool             byte                  rune

   string              error

内置函数： 

          make      len           cap         new     append

  copy       close       delete      complex

  real         imag        panic      recover

 

1.1.3 Go语言程序结构：

                      

 

1.2 函数 

注意：

1.2.1 golang函数不支持重载，一个包不能有两个函数名一样的函数。

1.2.2 函数也是一种类型，一个函数可以赋值给变量。

package main

import "fmt"

func add(a, b int) int {
	return a + b
}

func main() {
	c := add
	fmt.Println(c)

	sum := c(10, 20)
	fmt.Println(sum)
       if ( c == add ) {
               fmt.Println(“c equal add”)
       }
}

package main

import "fmt"

type add_func func(int, int) int

func add(a, b, c int) int {
	return a + b
}

func operator(op add_func, a int, b int) int {
	return op(a, b)
}

func main() {
	c := add
	fmt.Println(c)
	sum := operator(c, 100, 200)
	fmt.Println(sum)
}

1.2.3 函数参数传递的两种类型（值传递/引用传递）

• 无论是值传递，还是引用传递，传递给函数的都是变量的副本，不过，值传递是值的拷贝。引用传递是地址的拷贝，一般来说，地址。拷贝更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能越低。
• map、slice、chan、指针、interface默认以引用的方式传递。

package main

import "fmt"

func modify(a int) {
	a = 100
}

func main() {
	a := 8
	fmt.Println(a)
	modify(a)
	fmt.Println(a)
}

1.2.4 多返回值

func add(a, b int) (c int) {
        c = a + b
        return c;
}

 

func calc(a, b int) (sum int, avg int) {
        sum = a + b
        avg = (a +b)/2
        return
}

 _标识符，用来忽略返回值：

func calc(a, b int) (sum int, avg int) {
        sum = a + b
        avg = (a +b)/2
        return}
func main() {
      sum, _ := calc(100, 200)
}

可变参数：

• 0或多个参数

func add(arg…int) int {
}

•  1或多个参数

func add(a int, arg…int) int {
}

• 2或多个参数

func add(a int, b int, arg…int) int {
}

1.2.5 匿名函数 

由一个不带函数名的函数声明和函数体组成。

func main()  {
    i := 1

    go func(i int) {
        time.Sleep(100*time.Millisecond)
        fmt.Println("i =", i)
    } (i)

    i++
    time.Sleep(1000*time.Millisecond)
}

1.3 流程控制 

1.3.1 switch case语句：

普通的switch语句：

var i = 0
switch i {
case 0:
case 1:
      fmt.Println(“1”)
case 2:
fmt.Println(“2”)
default:
     fmt.Println(“def”)
}

 fallthrough语句：

var i = 0
switch i {
case 0:
        fallthrough
case 1:
      fmt.Println(“1”)
case 2:
fmt.Println(“2”)
default:
     fmt.Println(“def”)
}

 注：加了fallthrough后，会直接运行【紧跟的后一个】case或default语句，不论条件是否满足都会执行，后面的条件并不会再判断了。

 

多重判断语句：

var i = 0
switch {
case i > 0 && i < 10:
      fmt.Println(“i > 0 and i < 10”)
case i > 10 && i < 20:
fmt.Println(“i > 10 and i < 20”)
default:
     fmt.Println(“def”)
}

1.3.2 for 语句

for i := 0 ; i < 100; i++ {
    fmt.Printf(“i=%d\n”, i)
}

for range语句（用来遍历数组、slice、map、chan）：

str := “hello world,中国”
for i, v := range str {
     fmt.Printf(“index[%d] val[%c] len[%d]\n”, i, v, len([]byte(v)))
}

 1.3.3 defer的用途

• 当函数返回时，先执行return，后执行defer语句。因此，可以用来做资源清理、关闭句柄、锁的释放、数据库连接释放。
• 多个defer语句，按先进后出的方式执行。
• defer语句中的变量，在defer声明时就决定了。

 func a() {
          i := 0
          defer fmt.Println(i)
          i++
          return
} 

关闭文件句柄：

func read() {
   file := open(filename)
   defer file.Close()
   //其他操作
}

锁资源的释放：

func read() {
   mc.Lock()
   defer mc.Unlock()
   //其他操作
}

数据库连接释放：

func read() {
   conn := openDatabase()
   defer conn.Close()
   //其他操作
}