运行：go run xxx.go
编译：go build xxx.go 生成可执行文件
程序开始：package main
引入包：import “fmt” 或者 import (
“fmt"
“os"
)
注意：Println不支持，Printf才支持%式的输出
变量和常量：
在函数外声明变量用：var a 或者 var (
a int
b str = “hi"
)
在函数里用： := 声明，如 t := 10
注：在go里，声明变量可以不声明类型，可以通过值来自动推断
常量定义 ： 用const关键字 const s string = “hi” 或者 const(
s string = “hi"
pi float32 = 3.1415926
)
数组：
var a [5]int 定义长度为5的值为int类型的数组
var b [3]int{1, 2, 3}定义长度为3，值为int类型的1，2，3 结果为 =》[1, 2, 3]
用len()方法返回数组的长度
数组切片操作：
var a [5]int
或者 a := [5]int{0,1,2,3,4}
a[2:4]从2到4，不包括4
a[:4]从0到4，不包括4
a[2:]从2到最后包括2
条件语句：
if len(a) == 5 {
….
} else {
….
}
switch a {
case a[0] >0 ：
….
case a[2] == 2 :
….
default:
….
}
注意go语言中switch语句没有break,因为go里的casa不会下穿
循环语句：
for i := 0; i < 5; i++ {}
range关键字循环数组，map等
i := [3]int{2, 3, 4}
for a, v := range i {
fmt.Println(a)
fmt.Println(v)
}
死循环：
for {}
map
package main
import"fmt"
func main(){
m := make(map[string]int) //使用make创建一个空的map
m["one"] = 1
m["two"] = 2
m["three"] = 3
fmt.Println(m) //输出 map[three:3 two:2 one:1] (顺序在运行时可能不一样)
fmt.Println(len(m)) //输出 3
v := m["two"] //从map里取值
fmt.Println(v) // 输出 2
delete(m, "two")
fmt.Println(m) //输出 map[three:3 one:1]
m1 := map[string]int{"one": 1, "two": 2, "three": 3}
fmt.Println(m1) //输出 map[two:2 three:3 one:1] (顺序在运行时可能不一样)
for key, val := range m1{
fmt.Printf("%s => %d
", key, val)
/*输出：(顺序在运行时可能不一样)
three => 3
one => 1
two => 2*/
}
}
指针
var i int= 1
var pInt *int= &i
//输出：i=1 pInt=0xf8400371b0 *pInt=1
fmt.Printf("i=%d pInt=%p *pInt=%d
", i, pInt, *pInt)
*pInt = 2
//输出：i=2 pInt=0xf8400371b0 *pInt=2
fmt.Printf("i=%d pInt=%p *pInt=%d
", i, pInt, *pInt)
i = 3
//输出：i=3 pInt=0xf8400371b0 *pInt=3
fmt.Printf("i=%d pInt=%p *pInt=%d
", i, pInt, *pInt)
Go具有两个分配内存的机制，分别是内建的函数new和make。他们所做的事不同，所应用到的类型也不同，这可能引起混淆，但规则却很简单。
内存分配
new 是一个分配内存的内建函数，但不同于其他语言中同名的new所作的工作，它只是将内存清零，而不是初始化内存。new(T)为一个类型为T的新项目分配了值为零的存储空间并返回其地址，也就是一个类型为*T的值。用Go的术语来说，就是它返回了一个指向新分配的类型为T的零值的指针。
make(T, args)函数的目的与new(T)不同。它仅用于创建切片、map和chan（消息管道），并返回类型T（不是*T）的一个被初始化了的（不是零）实例。这种差别的出现是由于这三种类型实质上是对在使用前必须进行初始化的数据结构的引用。例如，切片是一个具有三项内容的描述符，包括指向数据（在一个数组内部）的指针、长度以及容量，在这三项内容被初始化之前，切片值为nil。对于切片、映射和信道，make初始化了其内部的数据结构并准备了将要使用的值。如：
下面的代码分配了一个整型数组，长度为10，容量为100，并返回前10个数组的切片
make([]int, 10, 100)
以下示例说明了new和make的不同。
varp *[]int = new([]int) // 为切片结构分配内存；*p == nil；很少使用 varv []int = make([]int, 10) // 切片v现在是对一个新的有10个整数的数组的引用 // 不必要地使问题复杂化： var p *[]int = new([]int) fmt.Println(p) //输出：&[] *p = make([]int, 10, 10) fmt.Println(p) //输出：&[0 0 0 0 0 0 0 0 0 0] fmt.Println((*p)[2]) //输出： 0 // 习惯用法: v := make([]int, 10) fmt.Println(v) //输出：[0 0 0 0 0 0 0 0 0 0]
以上内容是平凡公子本人的一些学习笔记和总结，感谢学习时所看到的各篇文章的作者！