变量声明使用 := 方式时，左值必须是未声明的，否则会出现编译错误
```
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)
}
}
```
