var v1 int
var v2 string
var v3 [10]int // 数组
var v4 []int // 数组切片
var v5 struct {
    f   int
}
var v6 *int // 指针
var v7 map[string]int // map， key为string类型， value为int类型
var v8 func(a int) int

package main
import "fmt"
func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */
   ip = &a  /* 指针变量的存储地址   20818a220*/
   fmt.Printf("a 变量的地址是: %x\n", &a  )
   /* 指针变量的存储地址  20818a220*/
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )
   /* 使用指针访问值  20 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )

 布尔类型： bool。
 整型： int8、 byte、 int16、 int、 uint、 uintptr等。
 浮点类型： float32、 float64
 复数类型： complex64、 complex128。
 字符串： string。
 字符类型： rune。
 错误类型： error。
此外， Go语言也支持以下这些复合类型：
 指针（pointer）
 数组（array）
 切片（slice）
 字典（map）
 通道（chan）
 结构体（struct）
 接口（interface）

for i := 0; i < len(array); i++ {
fmt.Println("Element", i, "of array is", array[i])
}

for i, v := range array {
fmt.Println("Array element[", i, "]=", v)
}

package main
import "fmt"
func modify(array [10]int) {
array[0] = 10 // 试图修改数组的第一个元素
fmt.Println("In modify(), array values:", array)
}
func main() {
array := [5]int{1,2,3,4,5} // 定义并初始化一个数组
modify(array) // 传递给一个函数，并试图在函数体内修改这个数组内容
fmt.Println("In main(), array values:", array)
}
该程序的执行结果为：
In modify(), array values: [10 2 3 4 5]
In main(), array values: [1 2 3 4 5]

基于数组创建

// 先定义一个数组
var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// 基于数组创建一个数组切片
var mySlice []int = myArray[:5]
------------------------------------
var mySlice []int = myArray[:]    基于myArray所有元素创建数组切片
var mySlice [] int = myArray[:5]  基于myArray前5个元素创建数组切片
var mySlice [] int = myArray[5:] 基于myArray第5个后面的所有元素创建数组切片

直接创建

创建一个初始元素个数为5的数组切片，元素初始值为0：
mySlice1 := make([]int, 5)
创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：
mySlice2 := make([]int, 5, 10)
直接创建并初始化包含5个元素的数组切片：
mySlice3 := []int{1, 2, 3, 4, 5}

cap()函数返回的是数组切片分配的空间大小，而len()函数返回的是数组切片中当前所存储的元素个数。数组切片支持Go语言内置的cap()函数和len()函数。

copy（）内容复制
slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置 

// PersonInfo是一个包含个人详细信息的类型
type PersonInfo struct {
ID string
Name string
Address string
}
变量声明
var myMap  map[string]  PersonInfo
创建 
myMap = make(map[string] PersonInfo)
myMap = make(map[string] PersonInfo, 100)  指定存储能力
赋值
myMap["1234"] = PersonInfo{"1", "Jack", "Room 101,..."}
删除
delete(myMap, "1234")
查找
value, ok := myMap["1234"]
if ok { // 找到了
// 处理找到的value
}

if a < 5 {
return 0
} else {
return 1
}
关于条件语句，需要注意以下几点：
 条件语句不需要使用括号将条件包含起来()；
 无论语句体内有几条语句，花括号{}都是必须存在的；
 左花括号{必须与if或者else处于同一行；
 在if之后，条件语句之前，可以添加变量初始化语句，使用;间隔；
 在有返回值的函数中，不允许将“最终的” return语句包含在if...else...结构中，否则会编译失败

switch i {
case 0:
fmt.Printf("0")
case 1:
fmt.Printf("1")
case 2:
fallthrough
case 3:
fmt.Printf("3")
case 4, 5, 6:
fmt.Printf("4, 5, 6")
default:
fmt.Printf("Default")
}
在使用switch结构时，我们需要注意以下几点：
 左花括号{必须与switch处于同一行；
 条件表达式不限制为常量或者整数；
 单个case中，可以出现多个结果选项；
 与C语言等规则相反， Go语言不需要用break来明确退出一个case；
 只有在case中明确添加fallthrough关键字，才会继续执行紧跟的下一个case；
 可以 不设定switch之 后的条 件表达式， 在此种情况 下，整个switch结构与 多个
if...else...的逻辑作用等同。

func Foo(param int)(n int, err error) {
// ...
}
调用时的代码建议按如下方式处理错误情况：
n, err := Foo(0)
if err != nil {
// 错误处理
} else {
// 使用返回值n
}


func Stat(name string) (fi FileInfo, err error) {
var stat syscall.Stat_t
err = syscall.Stat(name, &stat)
if err != nil {
return nil, &PathError{"stat", name, err}
}
return fileInfoFromStat(&stat, name), nil
} 

//defer 执行一些清理和维护性的工作defer语句的调用是遵照
//先进后出的原则，即最后一个defer语句将最先被执行。

func CopyFile(dst, src string) (w int64, err error) {
srcFile, err := os.Open(src)
if err != nil {
return
}
defer srcFile.Close()
dstFile, err := os.Create(dstName)
if err != nil {
return
}
defer dstFile.Close()
return io.Copy(dstFile, srcFile)
}