變量聲明使用 := 方式時，左值必須是未聲明的，否則會出現編譯錯誤
```
package main
import "fmt"
func main() {
var a int = 10
var b int = 20
b := 30
fmt.Print(a, b)
}
```
變量聲明了，就必須要使用，否則會出現編譯錯誤
```
package main
import "fmt"
func main() {
var a int = 10
var b int = 20
fmt.Print(a)
}
```
const修飾符的作用范圍為同時修飾的所有常量
```
package main
import "fmt"
func main() {
const a, b int = 10, 20
a = 10
b = 20
fmt.Print(a, b)
}
```
++自增和- -自減運算符類比C語言，相當于前置的自增和自減，而且go語言中不區分前置或后置
```
package main
import "fmt"
func main(){
var a int = 10
var b int = 20
++a
b++
fmt.Print(a, b)
}
```
格式問題
```
package main
import "fmt"
func main() {
var a int = 30
if a < 20 {
fmt.Print("a<20")
}
else {
fmt.Print("a>=20")
}
}
```
switch的case分支的常量表達式可以同時測試多個值
```
package main
import "fmt"
func main() {
var a int = 10
switch {
case a == 1, a == 2:
fmt.Println("1 or 2")
case a == 10, a == 20:
fmt.Println("10 or 20")
case a == 100, a == 200:
fmt.Println("100 or 200")
default:
fmt.Println("unknow")
}
}
```
函數可以同時返回多個值
```
package main
import "fmt"
func fun(str1 string, str2 string) (string, string) {
return str2, str1
}
func main() {
str1, str2 := fun("world", "hello")
fmt.Println(str1, str2)
}
```
函數也可以成為自定義類型的一個方法
```
package main
import "fmt"
//自定義類型
type student struct {
num int
name string
}
//方法getNum
func (stu student) getNum() int {
return stu.num
}
//方法getName
func (stu student) getName() string {
return stu.name
}
func main() {
var st student
st.num = 10
st.name = "abc"
//對象調用其方法
fmt.Println(st.getNum(), st.getName())
}
```
二維數組的初始化
```
package main
import "fmt"
func main() {
var number = [3][3]int{
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}}
fmt.Println(number)
}
```
二級指針的初始化和使用
```
package main
import "fmt"
func main() {
var i int = 10
var ptr1 *int = &i
var ptr2 **int = &ptr1
fmt.Printf("%d %d %d", i, *ptr1, **ptr2)
}
```
new()和make()的區別
首先 new 是內建函數,內建函數 new 用來分配內存，它的第一個參數是一個類型，不是一個值，它的返回值是一個指向新分配類型零值的指針,代碼如下
```
func newInt() *int {
var i int
return &i
}
someInt := newInt()
```
make也是內建函數，內建函數 make 用來為 slice，map 或 chan 類型分配內存和初始化一個對象，跟 new 類似，第一個參數也是一個類型而不是一個值，跟 new 不同的是，make 返回類型的引用而不是指針，而返回值也依賴于具體傳入的類型。
總結：new 的作用是初始化一個指向類型的指針(*T)，make 的作用是為 slice，map 或 chan 初始化并返回引用(T)。
遍歷一個切片，并將切片的值當成映射的鍵和值存入
```
package main
import "fmt"
func main() {
slice := []int{0, 1, 2, 3}
myMap := make(map[int]*int)
for index, value := range slice {
myMap[index] = &value
}
fmt.Println("=====new map=====")
prtMap(myMap)
}
func prtMap(myMap map[int]*int) {
for key, value := range myMap {
fmt.Printf("map[%v]=%v\n", key, *value)
}
}
```
