Golang 语法速记

// Description: Golang语法与代码格式速记

002	// Author: cxy

003	// Date: 2013-04-01

004	// Version: 0.3

005	// TODO 说明

006

007

008	// TODO package

009

010	// Go是采用语法解析器自动在每行末尾增加分号，所以在写代码的时候可以把分号省略。

011	// Go编程中只有几个地方需要手工增加分号，如: for循环使用分号把初始化，条件和遍历元素分开。在一行中有多条语句时，需要增加分号。

012	// 不能把控制语句(if, for, switch, or select)、函数、方法 的左大括号单独放在一行， 如果你这样作了语法解析器会在大括号之前插入一个分号，导致编译错误。

013

014	// 引用包名与导入路径的最后一个目录一致

015	import "fmt"

016	import "math/rand"

017	fmt.Println(rand.Intn(10))  // 0到10之间的非负伪随机数

018

019	// 用圆括号组合导入包，这是“factored”导入语句

020	import ("fmt"; "math")

021

import (

022

"fmt"

023

"math"

024

)

025	// 导入包可以定义别名，防止同名称的包冲突

026	import n "net/http"

027

import (

028

控制台 "fmt"

029

m "math"

030

)

031	控制台.Println(m.Pi)

032

033	// 首字母大写的名称是被导出的, 首字母小写的名称只能在同一包内访问(同包跨文件也能访问)

034	var In int // In is public

035	var in byte // in is private

036	var 看不见 string // 看不见 is private

037	const Com bool = false // Com is public

038	const 还是看不见 uint8 = 1 // 还是看不见 is private

039	type Integer int // Integer is public

040	type ブーリアン *bool // ブーリアン is private

041	func Export() {...} // Export is public

042	func 导入() {...} // 导入 is private

043	func (me *Integer) valueOf(s string) int {...} // valueOf is private

044	func (i ブーリアン) String() string {...} // String is public

045

046	// Go 的基本类型：

047	┌──────┬─────────┬────────┬─────────┬───────────┬────────────┐

048	│ bool │ string  │        │         │           │            │

049	├──────┼─────────┼────────┼─────────┼───────────┼────────────┤

050	│ int  │ int8    │ int16  │ int32   │ int64     │            │

051	│      │         │        │ rune    │           │            │

052	├──────┼─────────┼────────┼─────────┼───────────┼────────────┤

053	│ uint │ uint8   │ uint16 │ uint32  │ uint64    │ uintptr    │

054	│      │ byte    │        │         │           │            │

055	├──────┼─────────┼────────┼─────────┼───────────┼────────────┤

056	│      │         │        │ float32 │ float64   │            │

057	├──────┼─────────┼────────┼─────────┼───────────┼────────────┤

058	│      │         │        │         │ complex64 │ complex128 │

059	└──────┴─────────┴────────┴─────────┴───────────┴────────────┘

060	// byte 是 uint8 的别名

061	// rune 是 int32 的别名，代表一个Unicode码点

062

063	// 变量声明, 使用var关键字   (Go中只能使用var声明变量，无需显式初始化值）

064	var i int   // i = 0

065	var s string    // s = ""   (Go中的string不存在nil(null)值，默认零值就是空串 "" 或 ``)

066	var e error // e = nil, error是Go的内建接口类型，不是基本类型。

067

068	// var 语句声明了一个变量的列表，类型在变量名之后

069	var a,b,c int   // a = 0, b = 0, c = 0

070

var (

071	a int   // a = 0

072	b string    // b = ""

073	c uint  // c = 0

074

)

075

076	// 变量定义时初始化赋值，每个变量对应一个值

077	var a int = 0

078	var a,b int = 0, 1

079

080	// 初始化使用表达式时，可以省略类型，变量从初始值中获得类型

081	var a = 'A' // a int32

082	c := 1 + 2i // c complex128

083	var a,b = 0, "B"    // a int, b string

084	a, b := 0, "B"  // a int, b string

085	c := `formatted

086	string`    // c string

087

088	// := 结构不能使用在函数外，函数外的每个语法块都必须以关键字开始

089

090	// 常量可以是字符、字符串、布尔或数字类型的值，数值常量是高精度的值

091	const x int = 3

092

const (

093	a byte = 'A'

094	b string = "B"

095	c bool = true

096

d int = 4

097	e float32 = 5.1

098	f complex64 = 6 + 6i

099

)

100

101	// 未指定类型的常量由常量值决定其类型

102	const a = 0 // a int

103

const (

104	b = 2.3 // b float64

105	c = true    // c bool

106

)

107

108	// 自动枚举常量 iota

109	// iota的枚举值可以赋值给数值兼容类型

110	// 每个常量单独声明时, iota不会自动递增(无意义)

111	const a int = iota  // a = 0

112	const b int = iota  // b = 0

113	const c byte = iota // c = 0

114	const d uint64 = iota   // d = 0

115

116	// 常量组合声明时, iota每次引用会逐步自增, 初始值为0,步进值为1

117

const (

118	a uint8 = iota  // a = 0

119	b int16 = iota  // b = 1

120	c rune = iota   // c = 2

121	d float64 = iota    // d = 3

122	e uintptr = iota    // e = 4

123

)

124

125	// 枚举的常量都为同一类型时, 可以使用简单序列格式.

126

const (

127	a = iota    // a int32 = 0

128	b           // b int32 = 1

129	c           // c int32 = 2

130

)

131

132	// 枚举序列中的未指定类型的常量会跟随序列前面最后一次出现类型定义的类型

133

const (

134	a byte = iota   // a uint8 = 0

135	b               // b uint8 = 1

136	c               // c uint8 = 2

137	d rune = iota   // d int32 = 3

138	e               // e int32 = 4

139	f               // f int32 = 5

140

)

141

142	// iota自增值只在一个常量定义组合中有效,跳出常量组合定义后iota值归0

143

const (

144	a = iota    // a int32 = 0

145	b           // b int32 = 1

146	c           // c int32 = 2

147

)

148

const (

149	e = iota    // e int32 = 0  (iota重新初始化并自增)

150	f           // f int32 = 1

151

)

152

153	// 定制iota序列初始值与步进值 (通过数学公式实现)

154

const (

155	a = (iota + 2) * 3  // a int32 = 0  (a=(0+2)*3) 初始值为6,步进值为3

156	b                   // b int32 = 3  (b=(1+2)*3)

157	c                   // c int32 = 6  (c=(2+2)*3)

158	d                   // d int32 = 9  (d=(3+2)*3)

159

)

160

161	// 数组声明带有长度信息，数组的长度固定

162	var a [3]int = [3]int{0, 1, 2}  // a = [0 1 2]

163	var b [3]int = [3]int{} // b = [0 0 0]

164	var c = [3]int{}    // c = [0 0 0]

165	d := [3]int{}   // d = [0 0 0]

166	fmt.Printf("%T\t%#v\t%d\t%d\n", d, d, len(d), cap(d))   // [3]int   [3]int{0, 0, 0} 3   3

167	// 使用...自动计算数组初始数据的长度

168	var a = [...]int{0, 1, 2}

169	x := [...][3]int{{0, 1, 2}, {3, 4, 5}}

170

171	// slice 指向数组的值，并且同时包含了长度信息

172	var a []int

173	fmt.Printf("%T\t%#v\t%d\t%d\n", a, a, len(a), cap(a))   // []int    []int(nil)  0   0

174	var a = new([]int)

175	fmt.Printf("%T\t%#v\t%d\t%d\n", a, a, len(*a), cap(*a)) // *[]int   &[]int(nil) 0   0

176	var b = make([]int, 0)

177	fmt.Printf("%T\t%#v\t%d\t%d\n", b, b, len(b), cap(b))   // []int    []int{} 0   0

178	var c = make([]int, 3, 10)

179	fmt.Printf("%T\t%#v\t%d\t%d\n", c, c, len(c), cap(c))   // []int    []int{} 3   10

180	var d []int = []int{0, 1, 2}

181	fmt.Printf("%T\t%#v\t%d\t%d\n", d, d, len(d), cap(d))   // []int    []int{0, 1, 2}  3   3

182

183	// slice 可以重新切片，创建一个新的 slice 值指向相同的数组

184	s := []int{0, 1, 2, 3, 4}

185	fmt.Println(s[1,3]) // [1 2]    (截取从开始索引到结束索引-1 之间的片段)

186	fmt.Println(s[:4])  // [0 1 2 3]

187	fmt.Println(s[1:])  // [1 2 3 4]

188	fmt.Println(s[1:1]) // []

189

190	// 向slice中添加元素

191	s := make([]string, 3)

192	s = append(s, "a")

193

194

195	// map 在使用之前必须用 make 来创建（不是 new）；一个值为 nil 的 map 是空的，并且不能赋值

196	var m map[int]int

197	m[0] = 0    // × runtime error: assignment to entry in nil map

198	fmt.Printf("type: %T\n", m) // map[int]int

199	fmt.Printf("value: %#v\n", m)   // map[int]int(nil)

200	fmt.Printf("value: %v\n", m)    // map[]

201	fmt.Println("is nil: ", nil == m)   // true

202	fmt.Println("length: ", len(m)) // 0，if m is nil, len(m) is zero.

203

204	var m map[int]int = make(map[int]int)

205	m[0] = 0    // 插入或修改元素

206	fmt.Printf("type: %T\n", m)     // map[int]int

207	fmt.Printf("value: %#v\n", m)       // map[int]int(0:0)

208	fmt.Printf("value: %v\n", m)        // map[0:0]

209	fmt.Println("is nil: ", nil == m)   // false

210	fmt.Println("length: ", len(m))     // 1

211

212	m = map[int]int{

213

0:0,

214	1:1,    // 最后的逗号是必须的

215

}

216	m = map[string]S{

217	"a":S{0,1},

218	"b":{2,3},  // 类型名称可省略

219

}

220	a := m["a"] // 取值

221	a, ok := m["a"] // 取值, 并通过ok(bool)判断key对应的元素是否存在.

222	delete(m, "a")  // 删除key对应的元素.

223

224	// 结构体（struct）就是一个字段的集合， type 定义跟其字面意思相符

225	type S struct {

226

A int

227	B, c string

228

}

229

type (

230	A struct {

231

s *S

232

}

233	B struct {

234

A   // 组合

235

}

236

)

237	// 结构体文法表示通过结构体字段的值作为列表来新分配一个结构体。

238	var s S = S{0, "1", "2"}

239	// 使用 Name: 语法可以仅列出部分字段。（字段名的顺序无关。）

240	var s S = S{A: 0, B: "1"}

241	var s S = S{}

242	// 特殊的前缀 & 构造了指向结构体文法的指针。

243	var s *S = &S{0, "1", "2"}

244

245	// 表达式 new(T) 分配了一个零初始化的 T 值，并返回指向它的指针

246	var s *S = new(S)

247	// 有指针，但是没有指针运算，结构体字段使用点号来访问

248	// 结构体字段可以通过结构体指针来访问。通过指针间接的访问是透明的

249	fmt.Println(s.A)

250	fmt.Println((*s).A)

251

252	// TODO interface

253	type IF interface {

254

a()

255

}

256

257	// TODO chanel

258

259	// TODO error

260

261	// if 语句 小括号 ( )是可选的，而 { } 是必须的。

262	if (i < 0)       // 编译错误.

263	println(i)

264

265	if i < 0     // 编译错误.

266	println(i)

267

268	if (i < 0) { // 编译通过.

269	println(i)

270

}

271	if i < 0 {

272	println(i)

273

} else {

274	println(i)

275

}

276

277	// 可以在条件之前执行一个简单的语句，由这个语句定义的变量的作用域仅在 if/else 范围之内

278	if (i := 0; i < 1) { // 编译错误.

279	println(i)

280

}

281

282	if i := 0; (i < 1) { // 编译通过.

283	println(i)

284

}

285

286	if i := 0; i < 0 {   // 使用gofmt格式化代码会自动移除代码中不必要的小括号( )

287	println(i)

288	} else if i == 0 {

289	println(i)

290

} else {

291	println(i)

292

}

293

294	// if语句作用域范围内定义的变量会覆盖外部同名变量,(与方法函数内局部变量覆盖全局变量相同)

295	a, b := 0, 1

296	if a, b := 3, 4; a > 1 && b > 2 {

297	println(a, b)   // 3 4

298

}

299	println(a, b)   // 0 1

300

301

302	// 只有一种循环结构，for 循环。可以让前置、后置语句为空，或者全为空

303	for i := 0; i < 10; i++ {...}

304	for i := 0; i < 10; {...}

305	for ; i < 10; i++ {...}

306	for ; i < 10; {...}

307	for i < 10 {...}

308	for ; ; {...}

309

for {...}

310

311	// 小括号 ( )是可选的，而 { } 是必须的。

312	for (i := 0; i < 10; i++) {...}  // 编译错误.

313	for i := 0; (i < 10); i++ {...}  // 编译通过.

314	for (i < 10) {...}   // 编译通过.

315

316	// TODO continue

317

318	// TODO for range

319

320	// TODO switch

321	// TODO fallthrough break

322	// TODO type assertion

323

324	// TODO select

325

326	// TODO goto

327

328	// 函数可以没有参数或接受多个参数

329	func f() {...}

330	func f(a int) {...}

331	func f(a int, b byte) {...}

332	func f(a ...int) {...}  // 可变参数

333	func f(a int, b bool, c ...string) {...}

334	// 函数可以返回任意数量的返回值

335	func f() int {

336

return 0

337

}

338	func f() int, string {

339	return 0, "A"

340

}

341	// 函数返回结果参数，可以像变量那样命名和使用

342	func f() a int, b string {

343

a = 1

344

b = "B"

345	return  // 或者 return a, b

346

}

347

348	// 当两个或多个连续的函数命名参数是同一类型，则除了最后一个类型之外，其他都可以省略

349	func f(a,b,c int) {...}

350	func f() a,b,c int {...}

351	func f(a,b,c int) x,y,z int {...}

352

353	// 函数也是值，可以将函数赋值给变量

354	var f (func(i int) int) = func(i int) int {

355

return i

356

}

357	fmt.Println(f(3))   // 3

358	var f func() int = func() int {

359

return 0

360

}

361	fmt.Println(f())    // 0

362	var f func() = func() {...}

363	var f = func() {...}

364	f := func() {...}

365

366	// TODO defer

367

368	// TODO 方法

369

370	// TODO 内建函数

371

append

372

cap

373

close

374

complex

375

copy

376

delete

377

imag

378

len

379

make

380

new

381

panic

382

print

383

println

384

real

385

recover

386

387	// TODO 并发

388	go func() {...}