变量声明
//通用形式，指定变量名，变量类型，变量值 var name int = 99 fmt.Println(name) //指定变量名，以及变量类型，未指定值的时候默认是类型零值 var age int //可以后面赋值 age = 88 fmt.Println(age) //短变量声明，指定变量名，以及变量的值，而变量类型会自动由值的类型决定。 gender := "male" //gender变量的类型是string fmt.Println(gender) //变量列表 要求：左右两边变量名与值的数量相同 //先定义，然后赋值 var x, y, z int //x,y,z都是int类型 x, y, z = 1, 2, 4 fmt.Println(x, y, z) //先定义，同时赋值 var o, p, q = "abc", true, 3.14 fmt.Println(o, p, q) //使用短变量的变量列表形式，需要注意，左边至少有一个新变量声明，否则报错 o, r, s, t := "changed", "xyz", false, 99 fmt.Println(o, r, s, t)
注意，在函数中（包括自己定义的函数或者主函数中）声明的变量如果没有使用，在编译的时候，会报错。
在函数外面定义全局变量不能使用短变量形式。
常量
const x = 13 const p int = 13 const pp, ppp = 1, 2 const ( i = 10 ii = 20 )
在声明常量的时候，必须指定值，否则出错。
声明在函数中的常量不使用，并不会报错，只有声明的变量或者导入的包未使用才会报错。
注意下面这个用法：
const ( i = 1 ii iii = 2 iiii ) fmt.Println(i, ii, iii, iiii)// 1 1 2 2
定义多个常量时，如果某个变量没有执行值，那么就会沿用上一个常量的值。
const与iota
在和const联用时，iota的作用是：iota初始值为0，每出现一个常量，iota就加1
const ( i = iota ii iii = 4 iiii = iota ) fmt.Println(i, ii, iii, iiii) //0 1 4 3
数据类型
基本数据类型：string、bool、intX、floatX
复合数据类型：array、struct
引用类型：point、slice、map、func、channel
接口类型：interface
运算符
和其他语言一样，注意--、 ++只能后置，即只能i++、i--。
逻辑运算符||、&&、！，这3个运算符左右两边的表达式必须是bool型，不能是int或者string类型。
类型强制转换
在两种类型的变量相互赋值或者进行比较时，Go语言不会像其他语言一样进行隐式转换，所以必须进行显式地转换。
所以下面两种做法是不可行的：
var f1 float32 = 3.14 var f2 float64 = 6.28 //类型不同，不能进行比较，会报错 // fmt.Println(f1 == f2) //类型不同，不能进行运算 f3 := f1 - f2 fmt.Println(f3)
解决方法：
var f1 float32 = 3.14 var f2 float64 = 6.28 //进行强制转换 f := float32(f2) fmt.Println(f1 == f) //false f3 := f1 - f fmt.Println(f3) //0
复数
c := complex(3, 4) fmt.Println(real(c), imag(c))//3 4
布尔值
注意bool值的true或者false，并不会自动转换为整型的1或者0。
字符型
单引号只能用来表示单个字符，不能用来括字符串。
双引号技能括单个字符，又能括字符串。
a := 'ab' //wrong b := 'x' //correct c := "y" //correct d := "abc" //correct
字符串
str1 := "你 " str2 := "好" //使用 + 进行字符串拼接 str3 := str1 + str2 //你 好 fmt.Println(str3) length := len(str1) //使用len()求字符串的长度时，求的是字节数，不是字符数 fmt.Println(length) //4 str := "hello world" //取某一个索引的字符 fmt.Println(str[0]) //104 fmt.Println(string(str[0])) //h //错误用法，不能修改字符串内部的值 //str[0] = "d" //可以改变字符串的值 str = "go to hell" fmt.Println(str) //go to hell
字符串截断
截断格式str[start:end]，左闭右开区间，即end位置的字符不会包含在内。省略start时，默认start为0。省略end时，默认end为字符串长度len(str)。
str := "abcdefg" fmt.Println(str[2:4]) //cd fmt.Println(str[2:]) //cdefg fmt.Println(str[:4]) //abcd
字符串遍历
str := "abcdefg"
length := len(str)
for i := 0; i < length; i++ {
fmt.Println(str[i], string(str[i]))
}
for index, value := range str {
fmt.Println(index, string(value))
}
原生字符串字面值
使用``代替双引号。可以保存内容的格式，原样输出
str := ` menu: 1、 2、 ` fmt.Println(str)
指针
var num int = 10 var p *int = &num // 等价于 //p := &num fmt.Println(num, p, *p) //10 0xc42001a0f0 10
注意事项：
指针的默认值是nil，不是NULL，并且go语言中没有NULL常量
使用&取地址，使用*解引用
不支持C语言类似的指针运算，比如指针自增等。
使用“.”来访问目标成员，不支持“->”运算符
不存在函数指针
结构体指针
package main
import "fmt"
type person struct {
Name string
Age int
}
func main() {
p := &person{"abc", 90}
name := p.Name
//等价于
//name := (*p).Name
fmt.Println(name)
}
数组指针
arr := [3]int{99, 999, 9999}
p := &arr
fmt.Println(arr) //[99 999 9999]
fmt.Println(p) //&[99 999 9999]
fmt.Println(*p) //[99 999 9999]
指针数组
var p [3]*int x, y, z := 1, 11, 111 p[0], p[1], p[2] = &x, &y, &z fmt.Println(p[0], p[1], p[2]) //0xc42001a0f0 0xc42001a0f8 0xc42001a100 fmt.Println(*p[0], *p[1], *p[2]) //1 11 111
二级指针
var num int = 10 p := &num //p保存着num的地址 pp := &p //pp保存着p的地址，即地址的地址 fmt.Println(p, *pp) //0xc42001a0f0 0xc42001a0f0 fmt.Println(&p, pp) //0xc42000c028 0xc42000c028 fmt.Println(*p, **pp) //10 10
type定义类型
使用type关键字定义新的类型名，一般出现在包一级，即函数外部，如果新建的类型名字首字母大写，则在包外可以使用，否则只能在包内使用。
格式：type new_type base_type
注意type和C语言的typedef不同，typedef只是定义别名而已，而Go语言的type不仅定义类型名称，还包括类型的行为。
package main
import "fmt"
type Score int
func (s Score) Pass() bool {
return s >= 60
}
func main() {
var s1 Score = 69
fmt.Println(s1.Pass()) //true
}
虽然使用type关键字定义了一个新的类型，就像上面的Score和int，虽然在底层都是int，底层都是同一个类型，但是：不能直接进行比较、计算，必须要先转换后才可比较和计算。
标准输入输出
Print、Println、Printf
a, b, c := 1, "abc", true
fmt.Println(a, b, c) //1 abc true
fmt.Print(a, b, c, "
") //1abctrue
fmt.Printf("%d,%s,%t
", a, b, c) //1,abc,true
Scan
var (
name string
age int
)
for {
fmt.Println("please intput name,age")
fmt.Scan(&name, &age)
fmt.Println("name:", name, " age:", age, "
")
}
运行结果如下：
please intput name,age abc 30 name: abc age: 30 please intput name,age abc 50 name: abc age: 50 please intput name,age abc 50 xyz 99 name: abc age: 50 please intput name,age name: xyz age: 99
Scanln
var (
name string
age int
score int
)
for {
fmt.Println("please intput name,age,score")
fmt.Scanln(&name, &age, &score)
fmt.Println("name:", name, " age:", age, " score:", score, "
")
}
运行结果如下：
please intput name,age,score abc name: abc age: 0 score: 0 please intput name,age,score abc 30 name: abc age: 30 score: 0 please intput name,age,score abc 30 99 name: abc age: 30 score: 99
Scanf
var (
name string
age int
)
fmt.Println("please intput name,age")
fmt.Scanf("%s %d", &name, &age) //输入时以空格分隔
fmt.Println("name:", name, " age:", age, "
")
fmt.Println("please intput name,age")
fmt.Scanf("%s,%d", &name, &age) //输入时，以逗号分隔
fmt.Println("name:", name, " age:", age, "
")
运行结果
please intput name,age abc 99 name: abc age: 99 please intput name,age xyz 88 name: xyz age: 99
注意，Scan并不会在遇到回车换行的时候结束输入。而Scanln和Scanf都是一旦遇到回车换行，就认为本轮输入（一个Scanln或者Scanf）结束，执行下一个Scanln或者Scanf。当然，缓冲的数据，可以自动赋值。
if选择结构
if score := 61; score > 80 {
fmt.Println("优秀")
} else if score > 60 {
fmt.Println("及格")
} else {
fmt.Println("不及格")
}
注意：花括号不可省，切不可另起一行。如果要声明变量，可以在if后面声明，并用分号分隔，分号后面跟条件。
最最重要的是：if后面的条件必须是bool类型的值或者结果为bool类型的表达式，不可以是整型或者其他类型。
switch选择结构
var length int = 3
switch length {
case len("abc"): //可以是表达式
fmt.Println(3)
case 4:
fmt.Println(4)
default:
fmt.Println(5)
}
//输出
//3
Go语言中的switch case结构中，每一个case条件分支末尾不用加break；
case可以后面的条件可以使变量，也可以是常量，但是有一点：case后面的类型，要和switch后面的类型相同。
fallthrough关键字
var score int = 12
switch score {
case 6:
fallthrough
case 12:
fmt.Println(12)
fallthrough
case 24:
fmt.Println(24)
default:
fmt.Println(36)
}
//输出
//12
//24
如果某个case里面有fallthrough，那么，这个case的紧接着的下一个case条件会默认满足，直接执行写一个case中的语句，并不会判断下一个case的条件是否满足。
case可以这样写
var score int = 12
switch score {
case 6, 12:
fmt.Println(6, "或者", 12)
default:
fmt.Println(36)
}
省略switch后面的表达式，此时相当于if else
var score int = 90
switch {
case score > 80:
fmt.Println("优秀")
fallthrough
case score > 60:
fmt.Println("及格")
default:
fmt.Println("不及格")
}
//输出
//优秀
//及格
for循环
Go语言中没有while循环和do..while循环，只有一个for循环，但是for循环有三种形式，可以替代while循环和do while循环。
for i:=0;i<10;i++{
fmt.Println(i)
}
for {
fmt.Println("这是死循环，相当于while(1)")
}
for i,v := range m{
fmt.Println("同样是死循环")
}
上面三种用法分别对应其他语言中的for循环，while()循环，do..while循环。
在循环中可以使用break和continue来控制循环。