2.1.變數定義

（1）第一個程式helloworld

package main

import(
	"fmt"
)

func main() {
	fmt.Println("helloworld")
}

（2）變數的初始值

如果定義一個變數，沒有賦值，會有一個預設的初始值

package main

import(
	"fmt"
)

func variableZeroValue(){
	//定義兩個變數，沒有賦值
	var a int
	var s string
	fmt.Printf("%d %q\n",a,s)   //格式化輸出
}

func main() {
	fmt.Println("helloworld")
	variableZeroValue()        //a,s初始值：0 ""
}

（3）變數的定義和賦值　

package main

import(
	"fmt"
)

func variableInitialValue(){
	//變數的定義和賦值
	var a, b int = 3,4
	var s string = "derek"
	fmt.Println(a,b,s)
}

func variableShorter(){
	//用冒號
	d,e,f := 5,false,"zhang"
	fmt.Println(d,e,f)
}

func main() {
	variableInitialValue()     // 3 4 derek
	variableShorter()         // 5 false zhang
}

（4）使用var()集中定義變數

package main

import(
	"fmt"
)

//集中定義變數
var (
	aa = 2
	bb = true
	cc = "jack"
)

func main() {

	fmt.Println(aa,bb,cc)     // 2 true jack
}

 總結

• 使用var關鍵字：var s1,s2 string = "zhang","derek"
• 讓編譯器自動選擇型別：var a,b,i,s1,s2 = true,false,3,"hello","world"
• 使用冒號等於定義變數：a,b,i,s1,s2 := true,false,3,"hello","world",只能在函式內使用

2.2.內建變數型別

（1）型別

• bool,string
• (u)int,(u)int8,(u)int16,(u)int32,(u)int64,unitptr
• byte,rune
• float32,float64,complex64,comlex128

（2）強制型別轉換

package main

import(
	"fmt"
	"math"
)

func main() {
	var a,b int = 3,4
	// Sqrt必須接收float64型別，先把a,b平方的和轉換成float64型別，然後在把結果轉換成int型別
	var c int = int(math.Sqrt(float64(a*a + b*b)))
	fmt.Println(c)    //5
}

2.3.常量與列舉

const數值如果不指定型別可以作為各種型別使用，也可以指定型別。

（1）常量的定義

package main

import(
	"fmt"
)

func main() {
	//不指定型別，則可以作為各種型別使用
	const a,b = 3,4
	//指定為string型別，則為指定的型別
	const str string  = "derek"
	//可以放在括號不用每次寫const
	const (
		c = false
		d = "jack"
	)
	fmt.Println(a,b,str)     //3 4 derek
	fmt.Println(c,d)         //false jack
}

（2）列舉型別

package main

import(
	"fmt"
)

func main() {
	const (
		java = 0
		python =1
		golang = 2
	)
	fmt.Println(java,python,golang)     //0 1 2
}

（3）使用iota自增值列舉型別

package main

import(
	"fmt"
)

func main() {
	const (
		java = iota    //iota表示這組const自增值
		python
		golang
		javascript
	)
	fmt.Println(java,python,golang,javascript)     //0 1 2 3
}

2.4.條件語句

（1）if語句

if語句條件裡面不需要括號

package main

import(
	"fmt"
	"io/ioutil"
)

func main() {
	const filename = "C:\\Users\\86158\\Desktop\\awesomeProject\\src\\abc.txt"
	//ioutil.ReadFile:返回兩個值，一個是讀出的檔案內容，一個是error資訊
	//if的條件裡可以賦值
	if contents,err := ioutil.ReadFile(filename); err != nil{
		fmt.Println(err)
	}else {
		fmt.Printf("%s\n",contents)
	}
	//if條件裡賦值的變數的作用域就在if語句裡，像下面這樣在if外面訪問則報錯
	fmt.Println(contents)
}

（2）switch語句

• switch後可以沒有表示式
• switch不需要break
• 可以直接switch多個條件

package main

import(
	"fmt"
)

func grade(score int) string{
	g := ""
	switch {
	case score < 0 || score > 100:
		//報錯資訊
		panic(fmt.Sprintf("錯誤的分數：%d",score))
	case score < 60:
		g = "D"
	case score < 80:
		g = "C"
	case score < 90:
		g = "B"
	case score <= 100:
		g = "A"
 	}
	return g
}

func main() {
	fmt.Println(grade(2))
	fmt.Println(grade(70))
	fmt.Println(grade(83))
	fmt.Println(grade(101))     //panic: 錯誤的分數：101
}

2.5.迴圈

for

• for的條件裡不需要括號
• for的條件裡可以省略初始條件，結束條件，遞增表示式

package main

import "fmt"

func main() {
	sum := 0
	for i :=1; i <= 100; i++{
		sum += i
	}
	fmt.Println(sum)
}

2.6.函式

特點：

• 返回值型別寫在最後面
• 可返回多個值
• 函式可以作為引數
• 沒有預設引數和可選引數

（1）基本用法

package main

import "fmt"

//函式名（函式引數，引數型別）返回值型別
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("unsupport operation: " + op)
	}
}

func main() {
	fmt.Println(eval(3,5,"+"))      //8
	fmt.Println(eval(3,5,"*"))     //15
	fmt.Println(eval(3,5,"gg"))    //panic: unsupport operation: gg
}

（2）兩個返回值

package main

import "fmt"

//返回兩個值
func div(a,b int) (q,r int){
	return a / b, a % b
}

func main() {
	//接收兩個值
	q,r := div(13,3)
	fmt.Println(q,r)       //4 1
}

　只接收一個返回值

package main

import "fmt"

//返回兩個值
func div(a,b int) (q,r int){
	return a / b, a % b
}

func main() {
	//如果只想接收一個返回值，可以用“_”
	q,_ := div(13,3)
	fmt.Println(q)       //4 
}