1、标识符
标识符首字母大写：
定义标识符如（常量、变量、类型、函数名、结构字段，接口）如果以一个大写字母开头，如：Group1，哪么使用这种形式
的标识符的对象就可以被外部包的代码所使用（要使用需要先导入这个包），这种定义被称为导出（如c++类的public）。
标识符首字母小写：
以小写字母开头，则对包外是不可见的，但是在整个包的内部是可见可访问的（如c++类的protected）。
注意要分清是否跨包
2、例子
package main
//全小写，未导出
var x, y int
var ( // 这种因式分解关键字的写法一般用于声明全局变量
a int
b bool
)
//定义并赋值，多变量定义
var c, d int = 1, 2
var e, f = 123, "hello"
func main(){
//下面这种变量的定义只能出现在函数体内，不能用来定义全局变量
//自动推导变量的类型，用 := 来赋值，像c++的auto变量
g, h:= 123, "hello"
//打印出来看看
println(x, y, a, b, c, d, e, f, g, h)
}3、全局变量允许声明但不使用
局部变量声明了必须要使用，否则编译不过，局部变量不能重新声明。
同一个包内全局变量不能重名
pointer类型的默认值为nil
4、空白标识符 _ 也被用于抛弃值，如值5在：_,b = 5, 7 中被抛弃。这种主要用于函数返回多个值，只需要其中某个值。
标识符 _ 实际上是一个只写变量，你不能得到它的值。这样做是因为go 语言中你必须使用所有被声明的变量。
例：
func swap(x,y int){
return y, x
}
func main(){
a,b:=1,2
_,b = swap(a,b) //这里抛弃了a的值
}5、常量可以用len()，cap()，unsafe.Sizeof()常量计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：
package main
import "unsafe"
const ( //常量定义
a = "abc"
b = len(a) //只有在常量中可以使用系统函数len()
c = unsafe.Sizeof(a)
)
func main(){
println(a, b, c)
}6.iota 标识符
iota，特殊常量，可以认为是一个可以被编译器修改的常量。
在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。
代码：
package main
import "fmt"
func main(){
const (
a=iota //0，const开始的第一个
b //1
c //2
d = "ha" //独立值，"ha" iota += 1
e //"ha" iota += 1
f = 100 //100 iota += 1
g //100 iota += 1
h = iota //7，恢复计算
i //8
)
fmt.Println(a,b,c,d,e,f,g,h,i) //0 1 2 ha ha 100 100 7 8
}7、指针变量、变量地址
package main
import "fmt"
func main(){
var a int = 4
var b int32
var c float32
var ptr* int
//运算符实例
fmt.Printf("第1行 - a 变量类型为 = %T\n", a)
fmt.Printf("第2行 - b 变量类型为 = %T\n", b)
fmt.Printf("第3行 - c 变量类型为 = %T\n", c)
// & * 运算符实例
ptr = &a
fmt.Printf("a 的值为 %d\n", a)
fmt.Printf("*ptr 值为 %d\n", *ptr)
a=5
fmt.Printf("ptr 为 %d\n", ptr)
fmt.Printf("*ptr 值为 %d\n", *ptr)
*ptr=7
fmt.Println(*ptr,a) //7 7
}8、if 不强制加括号
package main
import "fmt"
func main() {
var a int = 100;
if a < 20 {
fmt.Printf("a 小于 20\n");
} else if (a > 100) { //括号可加可不加
fmt.Printf("a > 100\n");
} else {
fmt.Printf("其它");
}
}9、for 循环
package main
import "fmt"
func main(){
var b int = 15
var a int
numbers:= [6]int{1,2,3,5} //数组，初始化
for a:=0; a<10; a++ {
fmt.Printf("a 的值为 %d\n", a) //递增循环
}
for a< b { //条件循环
a++
fmt.Printf("a 的值为 %d\n", a)
}
for i,x:= range numbers { //range可以对 slice(切片)、map、数组，字符串等进行迭代循环
fmt.Printf("第 %d位 x 的值 =%d\n", i,x)
}
for {
fmt.Printf("无限循环")
}
}goto 不推荐使用
package main
import "fmt"
func main() {
var a int = 10
LOOP: for a < 20 {
if a == 15 {
a = a +1
goto LOOP
}
fmt.Printf("a的值为：%d\n", a)
a++
}
}10、函数
package main
import "fmt"
//函数 名称 参数列表 返回参数表
func swap(x int, y string) (string, int) {
return y, x
}
func swap1(x, y string) (string, string) {
return y, x
}
func swap2(y string) string {
return y
}
func main() {
a, b:= swap(1, "test")
fmt.Println(a, b)
}11、闭包
package main
import "fmt"
func getSequence() func() int { //返回值为一个函数
i:= 0
return func() int { //内部函数，修改了临时变量 i的值
i+=1
return i
}
}
func main() {
//nextNumber 为一个函数， 函数 i 为 0
nextNumber:= getSequence()
fmt.Println(nextNumber()) //i=1
fmt.Println(nextNumber()) //i=2
fmt.Println(nextNumber()) //i=3 这里返回的函数nextNumber保存了内部变量i的值修改
nextNumber1:= getSequence()
fmt.Println(nextNumber1()) //i=1
fmt.Println(nextNumber1()) //i=2
}12、函数方法
package main
import "fmt"
//定义一个结构体
type Circle struct {
radius float64
}
func main() {
var c1 Circle
c1.radius = 10.00
fmt.Println("Area of Circle(c1) = ", c1.getArea())
}
//该方法 属于 Circle 类型对象中的方法，this Circle其中this类似于类的this指针
func (this Circle) getArea() float64 {
return 3.14 * this.radius * this.radius
}14、数组
package main
import "fmt"
func main() {
var n [10] int //定义一个长度为10的数组
var i, j int
//初始化数组元素
for i=0; i<10; i++ {
n[i] = i + 100 //设置元素为 i + 100
}
//输出每个数组元素的值
for j = 0; j< 10; j++ {
fmt.Printf("Element[%d] = %d\n", j, n[j])
}
}17、切片
package main
import "fmt"
func main() {
var numbers = make([]int,3,5)
printSlice(numbers)
s:=[]int {1,2,3}
printSlice(s)
var numbers1 []int
printSlice(numbers1)
if (numbers1== nil) {
fmt.Println("切片是空的")
}
fmt.Println("s[1:3] ==", s[1:3]) //打印切片从索引1（包含）到索引3（不包含）的值
fmt.Println("s[:3] ==", s[:3]) //默认从下限0开始打印
fmt.Println("s[2:] ==", s[2:]) //默认上限为0，从索引2（包含）开始打印
numbers=append(numbers,0,1,2,3,4,5,6) //追加
fmt.Println(numbers,cap(numbers))
//创建切片 numbersc 是之前切片的两倍容量
numbersc:= make([]int, len(numbers), (cap(numbers))*2)
//拷贝 numbers 的内容到 numbersc
copy(numbersc,numbers)
fmt.Println(numbersc)
}
func printSlice(x[] int) {
fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}18、map
package main
import "fmt"
func main() {
var countryCapitalMap map[string]int //key:string value:int
countryCapitalMap = make(map[string]int) //创建map
//map插入值
countryCapitalMap["France"] = 1
countryCapitalMap["Italy"] = 2
countryCapitalMap["Japan"] = 3
countryCapitalMap["India"] = 4
delete(countryCapitalMap,"India"); //删除key
//遍历
for key,val:= range countryCapitalMap {
fmt.Println("capital of %s num:%d\n", key,val)
}
//查看是否存在
captial, ok:= countryCapitalMap["United States"]
if (ok) {
fmt.Println("Capital of United States is", captial)
}else {
fmt.Println("Capital of United States is not Find")
}
}19、接口
package main
import "fmt"
//定义一个接口
type Phone interface {
call()
}
type NokiaPhone struct { //诺基亚
}
func (nokia NokiaPhone) call() { //实现call接口方法
fmt.Println("I am Nokia, I can call you!")
}
type IPhone struct { //苹果
}
func (iPhone IPhone) call() { //实现call接口方法
fmt.Println("I am iPhone, I can call you!")
}
func main() {
var phone Phone
phone = new(NokiaPhone)
phone.call()
phone = new(IPhone)
phone.call()
}