一、語法結(jié)構(gòu)
golang源碼采用UTF-8編碼?？崭癜ǎ嚎瞻?，tab，換行，回車。
- 標識符由字母和數(shù)字組成（外加'_')，字母和數(shù)字都是Unicode編碼。
- 注釋：
/* This is a comment; no nesting */
// So is this.
二、字面值(literals)類似C語言中的字面值，但數(shù)值不需要符號以及大小標志:
23
0x0FF
1.234e7類似C中的字符串，但字符串是Unicode/UTF-8編碼的。同時，/xNN總是有2個數(shù)字；/012總是3；兩個都是字節(jié)：
"/xFF" // 1 byte
"/u00FF" // 1 Unicode char, 2 bytes of UTF-8
原生字符串：`/n/.abc/t/` == "//n//.abc//t//"
三、語法概述
golang基本上就是類C的語法，但使用反轉(zhuǎn)的類型和聲明，并使用關(guān)鍵字作為每個聲明的開頭。
var a int
var b, c *int // 注意與C的不同
var d []int
type S struct { a, b int }
基本的控制結(jié)構(gòu)也十分熟悉：
if a == b { return true } else { return false }
for i = 0; i < 10; i++ { … }
注意：沒有圓括號，但需要大括號。
后續(xù)會有更多有關(guān)這方面的內(nèi)容。
四、分號
分號作為語句終止符號，但：
- 如果前一個符號是語句的結(jié)尾，那詞法分析程序?qū)⒆詣釉谛形膊迦胍粋€分號
- 注意：比JavaScript的規(guī)則更清晰和簡單
因此，下面的程序不需要分號：
package main
const three = 3
var i int = three
func main() { fmt.Printf("%d/n", i) }
在實際中，Go源碼在for和if子句之外幾乎都沒有用到分號。
五、數(shù)值類型
golang數(shù)值類型(numeric types)是原生內(nèi)置的，也是為大家所熟知的：
int uint
int8 uint8 = byte
int16 uint16
int32 uint32 float32 complex64
int64 uint64 float64 complex128
還有uintptr，一個大小足夠存儲一個指針的數(shù)值。
這些都是互不相同的類型；int不等于是int32，即便是在一個32位的機器上。
沒有隱式類型轉(zhuǎn)換(不過不要恐慌)。
Bool
普通的布爾類型bool，取值true和false(預定義的常量)。
if語句等使用布爾表達式。
指針類型和整型不是布爾類型。
string
原生內(nèi)置的string類型代表不可改變的字節(jié)數(shù)組，即文本。string類型是用長度定界的，而不是以結(jié)尾0終止的。
字符串字面值是string類型。
和整型一樣不可改變?？芍匦沦x值，但不能修改其值。
正如"3"總是3，"hello"也總是"hello"。
Go語言對字符串操作提供了良好的支持。
六、表達式(Expressions)
大多都是類C語言的操作符。
二元操作符：
優(yōu)先級 操作符 備注
5 * / % << >> & &^ &^是位清理操作符
4 + – | ^ ^是異或(xor)
3 == != < <= > >=
2 &&
1 ||
一元操作符包括：& ! * + – ^(外加用于通信的<-)
一元操作符^是求補碼/反碼操作。
Go vs. C表達式
可以讓C程序員驚喜的是：
更少的優(yōu)先級層次(應該容易)。
^替代了~
++和–不再是表達式操作符(x++是一個語句，不是表達式；*p++是(*p)++，而不是*(p++))
&^是新操作符，在常量表達式中很有用
<<和>>等需要一個無符號的移位計數(shù)。
無驚喜的是：
賦值操作與所期望的一樣：+= <<= &^=等
表達式總體看起來相似(下標、函數(shù)調(diào)用等)
例子：
+x
23 + 3*x[i]
x <= f()
^a >> b
f() || g()
x == y + 1 && <-ch > 0
x &^ 7 // x with the low 3 bits cleared
fmt.Printf("%5.2g/n", 2*math.Sin(PI/8))
7.234/x + 2.3i
"hello, " + "world" // concatenation
// no C-like "a" "b"
數(shù)值轉(zhuǎn)型
將一個數(shù)值從一個類型轉(zhuǎn)換為另一個類型稱為一次轉(zhuǎn)型，其語法形式有點類似函數(shù)調(diào)用：
uint8(intVar) //截斷到相應的大小
int(float64Var) //片段截斷
float64(intVar) //轉(zhuǎn)為float64
一些涉及string類型的轉(zhuǎn)型：
string(0×1234) // == "/u1234"
string(sliceOfBytes) // bytes -> bytes
string(sliceOfInts) // ints -> Unicode/UTF-8
[]byte("abc") // bytes -> bytes
[]int("日本語") // Unicode/UTF-8 -> ints
切片(slice)與數(shù)組相關(guān)，稍后會有更多相關(guān)內(nèi)容。
七、常量
數(shù)值常量是"理想數(shù)"：沒有大小或標志，因此沒有U、L或UL作結(jié)尾。
077 // 八進制
0xFEEDBEEEEEEEEEEEEEEEEEEEEF //十六進制
1 << 100
下面是整數(shù)和浮點數(shù)值，字面值的語法決定其類型：
1.234e5 // 浮點
1e2 // 浮點
3.2i // 浮點虛數(shù)
100 // 整數(shù)
常量表達式
浮點和整型常量可以任意組合，最終表達式的類型由常量的類型決定。操作自身也取決于類型。
2*3.14 // 浮點: 6.28
3./2 // 浮點：1.5
3/2 // 整型：1
3+2i // 復數(shù)：3.0 + 2.0i
// 高精度
const Ln2 = 0.69314718055994530941723212145817656807
const Log2E = 1/Ln2
數(shù)值的表示范圍足夠大(目前最大用1024位表示)。
理想數(shù)的結(jié)果
Go語言允許無需顯式轉(zhuǎn)型的情況下使用常量，前提是常量值可以被其類型表示(沒有必要進行轉(zhuǎn)型；其值表示起來沒問題)：
var million int = 1e6 //float語法在這里可以使用
math.Sin(1)
常量必須可以被其類新表示。例如：^0的值為-1，不在0-255的范圍內(nèi)。
uint8(^0) //錯誤：-1無法用uint8類型表示
^uint8(0) //OK
uint8(350) //錯誤：350無法用uint8類型表示
uint8(35.0) //OK: 35
uint8(3.5) //錯誤：3.5無法用uint8類型表示
八、聲明
golang聲明以一個關(guān)鍵字開頭(var, const，type和func)，并且與C中的聲明次序相反：
var i int
const PI = 22./7.
type Point struct { x, y int }
func sum(a, b int) int { return a + b }
為何要以相反次序聲明呢？早期的一個例子：
var p, q *int
p和q的類型都是*int。并且函數(shù)讀起來更佳，并且與其他聲明一致。還有一個原因，馬上道來。
Var
變量聲明以var開頭。
它們可以有一個類型或一個初始化表達式；至少應有一個或二者都有。初始化表達式應該與變量匹配(還有類型！)。
var i int
var j = 365.245
var k int = 0
var l, m uint64 = 1, 2
var nanoseconds int64 = 1e9 // float64 constant!
var inter, floater, stringer = 1, 2.0, "hi"
分派var
總是輸入var讓人生厭。我們可以通過括號讓多個變量聲明成為一組：
var (
i int
j = 356.245
k int = 0
l, m uint64 = 1, 2
nanoseconds int64 = 1e9
inter, floater, stringer = 1, 2.0, "hi"
)
這種形式適用于const,type, var，但不能用于func。
=:"短聲明"
在函數(shù)內(nèi)(只有在函數(shù)內(nèi)這一種情況下)，下面形式的聲明：
var v = value
可以被縮短成：
v := value
(這就是另外一個名字、類型倒序的原因)
類型就是值的類型(對于理想數(shù)，相應的類型是int或float64或complex128)
a, b, c, d, e := 1, 2.0, "three", FOUR, 5e0i
這種形式的聲明使用很頻繁，并且在諸如for循環(huán)初始化表達式中也可以使用。
Const
常量聲明以const開頭。
它們必須有一個常量表達式，可在編譯期間求值，作為初始化表達式，可以擁有一個可選的類型修飾符。
const Pi = 22./7.
const AccuratePi float64 = 355./113
const beef, two, parsnip = "meat", 2, "veg"
const (
Monday, Tuesday, Wednesday = 1, 2, 3
Thursday, Friday, Saturday = 4, 5, 6
)
Iota
常量聲明可以使用計數(shù)器：iota，每個const塊中的iota都從0開始計數(shù)，在每個隱式的分號(行尾)自增。
const (
Monday = iota // 0
Tuesday = iota // 1
)
速記：重復上一個類型和表達式。
const (
loc0, bit0 uint32 = iota, 1<<iota //0，1
loc1, bit1 //1，2
loc2, bit2 //2，4
)
Type
類型聲明以type開頭。
我們后續(xù)會學習更多類型，不過先這里舉幾個例子：
type Point struct {
x, y, z float64
name
string
}
type Operator func(a, b int) int
type SliceOfIntPointers []*int
我們稍后會回到函數(shù)。
New
內(nèi)置函數(shù)new用于分配內(nèi)存。其語法類似一個函數(shù)調(diào)用，以類型作為參數(shù)，與C++中的new類似。返回一個指向已分配對象的指針。
var p *Point = new(Point)
v := new(int) // v的類型為*int
稍后我們將看到如何構(gòu)建切片(slice)
Go語言中沒有用于內(nèi)存釋放的delete或free。Go具備垃圾回收功能。
賦值
賦值是容易和熟悉的：
a = b
但Go還支持多項賦值：
x, y, z = f1(), f2(), f3()
a, b = b, a //交互a,b的值
函數(shù)支持多個返回值(稍后有更多細節(jié))：
nbytes, error := Write(buf)
九、控制結(jié)構(gòu)
與C類似，但很多地方有不同。
Go支持if、for和switch。
正如之前說的，無需小括號，但大括號是必要的。
如果將它們看為一組，它們的用法很規(guī)律。例如，if、for和switch都支持初始化語句。
控制結(jié)構(gòu)的形式
后續(xù)會有細節(jié)，但總體上：
if和switch語句以1元素和2元素形式呈現(xiàn)，后面詳細講解。
for循環(huán)具有1元素和3元素的形式：
1元素形式等價于C語言中的while：
for a {}
3元素形式等價于C語言中的for：
for a;b;c {}
在所有這些形式里，任何元素都可以是空。
if
基本形式是大家所熟知的，但已經(jīng)沒有了"else懸掛"問題了：
if x < 5 { less() }
if x < 5 { less() } else if x == 5 { equal() }
支持初始化語句；需要分號。
if v := f(); v < 10 {
fmt.Printf("%d less than 10/n", v)
} else {
fmt.Printf("%d not less than 10/n", v)
}
與多元函數(shù)一起使用更有益處：
if n, err = fd.Write(buf); err != nil { … }
省略條件意為true，在這里沒有什么用。但在for，switch語句中尤其有用。
for
基本形式是大家所熟知的：
for i := 0; i < 10; i++ { … }
省略條件意為true:
for ;; { fmt.Printf("looping forever") }
而且你還可以省略分號：
for { fmt.Printf("Mine! ") }
不要忘記多項賦值：
for i,j := 0,N; i < j; i,j = i+1,j-1 {…}
(Go中沒有像C中那樣的逗號操作符)
switch細節(jié)
switch與C中的switch有些類似。
不過，有一些語法和語義的重要不同之處：
- 表達式不必一定是常量，甚至可以不必是int。
- 沒有自動的fall through
- 但作為替代，語法上，最后的語句可以為fallthrough
- 多case可以用逗號分隔
switch count%7 {
case 4,5,6: error()
case 3: a *= v; fallthrough
case 2: a *= v; fallthrough
case 1: a *= v; fallthrough
case 0: return a*v
}
Switch
Go中的switch要遠比C中的強大。常見的形式：
switch a {
case 0: fmt.Printf("0")
default: fmt.Printf("non-zero")
}
switch表達式可以是任意類型，如果為空，則表示true。結(jié)果類似一個if-else鏈：
a, b := x[i], y[j]
switch {
case a < b: return -1
case a == b: return 0
case a > b: return 1
}
或
switch a, b := x[i], y[j]; { … }
Break，continue等
break和continue語句的工作方式與C中的類似。
它們可以指定一個label并影響外層結(jié)構(gòu)：
Loop: for i := 0; i < 10; i++ {
switch f(i) {
case 0, 1, 2: break Loop
}
g(i)
}
是的，那是一個goto。
十、函數(shù)
函數(shù)以func關(guān)鍵字開頭。
如果有返回類型，返回類型放在參數(shù)的后面。return的含義和你期望的一致。
func square(f float64) float64 { return f*f }
函數(shù)支持返回多個值。這樣，返回類型就是一個括號包圍的列表。
func MySqrt(f float64) (float64, bool) {
if f >= 0 { return math.Sqrt(f), true }
return 0, false
}
空標識符
如果你只關(guān)心MySqrt函數(shù)返回的第一個值？你仍然需要將第二個值放在一個地方。
解決方法：使用空標識符_(下劃線)。它是預聲明的，可以被賦予任何無用的值。
// Don't care about boolean from MySqrt.
val, _ = MySqrt(foo())
在空標識符其他的適用場合中，我們?nèi)匀粫故舅?/p>
帶結(jié)果變量(result variable)的函數(shù)
如果你給結(jié)果參數(shù)命名了，你可以將它當作實際變量使用。
func MySqrt(f float64) (v float64, ok bool) {
if f >= 0 { v,ok = math.Sqrt(f), true }
else { v,ok = 0,false }
return v,ok
}
結(jié)果變量被初始化為"0"(0，0.0,false等。根據(jù)其類型；稍后有更多有關(guān)內(nèi)容)
func MySqrt(f float64) (v float64, ok bool) {
if f >= 0 { v,ok = math.Sqrt(f), true }
return v,ok
}
空返回
最后，一個沒有返回表達式的return將返回結(jié)果變量的當前值。下面是另外兩個MySqrt的版本：
func MySqrt(f float64) (v float64, ok bool) {
if f >= 0 { v,ok = math.Sqrt(f), true }
return // must be explicit
}
func MySqrt(f float64) (v float64, ok bool) {
if f < 0 { return } // error case
return math.Sqrt(f),true
}
0是什么
Go中的內(nèi)存都是被初始化了的。所有變量在執(zhí)行之前的聲明時被初始化。如果沒有顯式的初始化表達式，我們將使用對應類型的"0值"。下面的循環(huán)：
for i := 0; i < 5; i++ {
var v int
fmt.Printf("%d ", v)
v = 5
}
將打印0 0 0 0 0。
0值取決于類型：數(shù)值是0；布爾是false；空字符串是""；指針，map、切片、channel是nil；結(jié)構(gòu)體是0等。
Defer
defer語句負責在其所在的函數(shù)返回時執(zhí)行一個函數(shù)(或方法)。其參數(shù)在到達defer語句那個時刻被求值；其函數(shù)在返回時被執(zhí)行。
func data(fileName string) string {
f := os.Open(fileName)
defer f.Close()
contents := io.ReadAll(f)
return contents
}
在關(guān)閉文件描述符、解互斥鎖等場合十分有用。
每Defer執(zhí)行一個函數(shù)
Go按按后入先出(LIFO)次序執(zhí)行一組defer函數(shù)。
func f() {
for i := 0; i < 5; i++ {
defer fmt.Printf("%d ", i)
}
}
上面代碼將輸出4 3 2 1 0。你可以在最后關(guān)閉所有文件描述符以及解鎖所有互斥鎖。
用defer跟蹤代碼：
func trace(s string) { fmt.Println("entering:", s) }
func untrace(s string) { fmt.Println("leaving:", s) }
func a() {
trace("a")
defer untrace("a")
fmt.Println("in a")
}
func b() {
trace("b")
defer untrace("b")
fmt.Println("in b")
a()
}
func main() { b() }
不過我們可以實現(xiàn)的更靈巧一些。
參數(shù)當即求值，defer稍后執(zhí)行
func trace(s string) string {
fmt.Println("entering:", s)
return s
}
func un(s string) {
fmt.Println("leaving:", s)
}
func a() {
defer un(trace("a"))
fmt.Println("in a")
}
func b() {
defer un(trace("b"))
fmt.Println("in b")
a()
}
func main() { b() }
函數(shù)字面值
和在C中一樣，函數(shù)不能在函數(shù)內(nèi)部聲明。但函數(shù)字面值卻可以被賦值給變量。
func f() {
for i := 0; i < 10; i++ {
g := func(i int) { fmt.Printf("%d",i) }
g(i)
}
}
函數(shù)字面值是閉包(closure)
函數(shù)字面值實際上是閉包。
func adder() (func(int) int) {
var x int
return func(delta int) int {
x += delta
return x
}
}
f := adder()
fmt.Print(f(1))
fmt.Print(f(20))
fmt.Print(f(300))
輸出1 21 321 – f中的x累加。
