1.包

每个go程序都是由包组成的

2.变量

• var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后
• var 语句可以出现在包或函数级别

package main

import "fmt"

var c, python, java bool

func main() {
	var i int
	fmt.Println(i, c, python, java)
}

2.1 变量的初始化

• 变量声明可以包含初始值，每个变量对应一个。
• 如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型
  短变量声明
• 在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。
• 函数外的每个语句都必须以关键字开始（var, func 等等），因此 := 结构不能在函数外使用

2.2 基本类型

bool 
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr

byte  //uint的别名

rune //int32的别名

float32 float64
complex64 complex128

package main

import (
	"fmt"
	"math/cmplx"
)

var (
	ToBe   bool       = false
	MaxInt uint64     = 1<<64 - 1
	z      complex128 = cmplx.Sqrt(-5 + 12i)
)

func main() {
	fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)
	fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
	fmt.Printf("Type: %T Value: %v\n", z, z)
}

2.3 零值

• 没有明确初始值的变量声明会被赋予它们的 零值。

• 零值是：
  数值类型为 0，
  布尔类型为 false，
  字符串为 ""（空字符串）

package main

import "fmt"

func main() {
	var i int
	var f float64
	var b bool
	var s string
	fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

2.4 类型转换

表达式 T(v) 将值 v 转换为类型 T。

一些关于数值的转换：

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

2.5 常量

• 常量的声明与变量类似，只不过是使用 const 关键字
• 常量可以是字符、字符串、布尔值或数值
• 常量不能用 := 语法声明

const name = "scyrc"
const sex =  "male"

3.函数

func add(x int ,y int) int {
  return x +y
}

// 省略参数类型
func add (x, y int) int {
  return x + y
}

//多值返回
func swap(x ,y string) (string, string){
  return y, x
} 

// 命名返回值
func split(sum int)(x, y int){
  x = sum* 4/9
  y = sum -x 
  return
}

4.1 控制流程语句

4.1for循环

Go 只有一种循环结构：for 循环。
基本的 for 循环由三部分组成，它们用分号隔开：
初始化语句：在第一次迭代前执行
条件表达式：在每次迭代前求值
后置语句：在每次迭代的结尾执行
初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。

一旦条件表达式的布尔值为 false，循环迭代就会终止

package main
import(
"fmt"
)
func main(){
  var sum =0
  for var i=0; i<10; i++{
    sum += i  
  }
fmt.Println(i) 
}

4.2 if

Go 的 if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 { } 则是必须的

package main

import (
	"fmt"
	"math"
)

func sqrt(x float64) string {
	if x < 0 {
		return sqrt(-x) + "i"
	}
	return fmt.Sprint(math.Sqrt(x))
}

func main() {
	fmt.Println(sqrt(2), sqrt(-4))
}

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。
该语句声明的变量作用域仅在 if 之内

func pow(x, n, lim float64) float64 {
	if v := math.Pow(x, n); v < lim {
		return v
	}
	return lim
}

4.3 switch

• switch 是编写一连串 if - else 语句的简便方法。它运行第一个值等于条件表达式的 case 语句。
• Go 的 switch 语句类似于 C、C++、Java、JavaScript 和 PHP 中的，不过 Go 只运行选定的 case，而非之后所有的 case。 实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。 除非以 fallthrough 语句结束，否则分支会自动终止。
• Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数

package main

import (
	"fmt"
	"runtime"
)

func main() {
	fmt.Print("Go runs on ")
	switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("OS X.")
	case "linux":
		fmt.Println("Linux.")
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf("%s.\n", os)
	}
}

4.4 defer

• defer 语句会将函数推迟到外层函数返回之后执行
• 推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用
• 推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用

package main

import "fmt"

func main() {
	defer fmt.Println("world")

	fmt.Println("hello")
}