LiteIDE開發(fā)工具簡明使用指南(Go語言基礎(chǔ)學(xué)習(xí))
我要評論谷歌系統(tǒng)所使用的編程語言Go，近年來發(fā)展的越來越成熟、方便易用?，F(xiàn)在，我們可以通過使用LiteIDE讓Go語言編程變得更加簡單。
第一步 語言基礎(chǔ)
數(shù)據(jù)、類型、函數(shù)、控制
Go語言是一個很容易上手同時功能無比強大的編程語言。你可以將它看做是C的現(xiàn)代版，至于更多的東西，還有待你自己去發(fā)掘。Go語言有著清晰簡明的靜態(tài)語法結(jié)構(gòu)，但它表現(xiàn)出來的確是一種動態(tài)的效果。它還可以編譯成本地代碼，但卻像解釋性語言那樣去工作。
總的來說，Go語言是一門完全值得你去嘗試的語言，同時本文將告訴你一切你上手這門語言所需要知識。在第二部分，我們將重點分析Go語言是如何處理對象和并發(fā)的。
安裝
安裝和配置Go語言，你只需要下載合適的二進(jìn)制文件至正確的位置，再為Go工具定位那些文件所在的目錄路徑就好了。
如果你使用的是OSX或Windows操作系統(tǒng)，那么你可以使用安裝包來完成這一些列工作。
在Windows下，我推薦MSI安裝包，這個安裝包雖然還在試驗中，但其實它的表現(xiàn)非常不錯，它能迅速地為你完成配置工作。 你需要的只是根據(jù)你的系統(tǒng)下載32位或64位安裝包然后在你的電腦上運行就好了。
安裝程序會默認(rèn)在C:\Go目錄進(jìn)行安裝。
你可以通過下面的小程序驗證環(huán)境是否搭建完成：
package main
import "fmt"
func main() {
fmt.Printf("hello, world\n")
}
你可以使用記事本或其他文本編輯器編輯上面這段代碼，并將代碼保存為hello.go文件。然后打開終端，輸入：
go run hello.go
接下來你就可以進(jìn)行LiteIDE的安裝并嘗試運行程序了。
不管從什么方面來說，LiteIDE并不是編寫Go程序的必備工具，你所需要的只是一個編輯器而已。這樣說的確沒錯，但是對于一個新人，一個好的IDE可以使他更容易上手一門語言，并迅速投入開發(fā)。
美中不足的是，LiteIDE沒有使用手冊。
你可以從下面的網(wǎng)址上下載tar或zip壓縮包
https://code.google.com/p/golangide/
下載完成后將其解壓至合適的目錄。如果你是用的是Windows，那你可能需要使用7z來解壓。
如此簡潔的安裝過程必然不會為你創(chuàng)建快捷方式，因此你可能需要打開...\liteide\bin然后找到liteide.exe并手動創(chuàng)建快捷方式。
打開LiteIDE后你會看到歡迎界面：
現(xiàn)在我們暫時無需理會這些組件，讓我們先從一個簡單的小程序開始。
在工具欄上選擇File->New或直接在歡迎界面上點擊New按鈕，在彈出的對話框中選擇Go1 Command Project。LiteIDE將為你創(chuàng)建一個Go控制臺工程，工程目錄放在C:/Go/src下。如果你為你的項目起名Hello，那你的代碼文件將被放在 C:/Go/src/Hello下。
LiteIDE會預(yù)先為你在工程目錄下創(chuàng)建main.go和doc.go文件。main.go文件中包含以下內(nèi)容： </p> <p>// Hello project main.go
package main
import (
"fmt"
)
func main() {
fmt.Println("Hello World!")
}
你可以點擊工具欄上藍(lán)色的編譯執(zhí)行按鈕BR運行代碼。你可以在在Build菜單中的B和BR按鈕菜單中找到更多的關(guān)于編譯和執(zhí)行代碼的命令。
如果你運行了你的程序，你可以在底部的編譯輸出（Build Output）窗口中看到程序運行結(jié)果。
如果程序沒有運行，那么很有可能是你創(chuàng)建的工程類型不對或者文件路徑錯誤。
LiteIDE中還有很多功能等待你去發(fā)掘，不過目前為止的這些已經(jīng)足夠我們使用Go語言了。
變量和簡單數(shù)據(jù)類型
Go語言包含了你所期望的所有從uint8 到 float64的簡單數(shù)據(jù)類型。
uint8 無符號8位 整型數(shù)(0 到 255)
uint16 無符號16位 整型數(shù)(0 到 65535)
uint32 無符號32位 整型數(shù)(0 到 4294967295)
uint64 無符號 64位 整型數(shù)(0 到 18446744073709551615)</p> <p>
int8 8位 整型數(shù)(-128 到 127)
int16 16位 整型數(shù)(-32768 到 32767)
int32 32位 整型數(shù)(-2147483648 到 2147483647)
int64 64位 整型數(shù)(-9223372036854775808 到 9223372036854775807)</p> <p>
float32 IEEE-754 32位 浮點數(shù)
float64 IEEE-754 64位 浮點數(shù)</p> <p>
complex64 復(fù)數(shù) 32位實數(shù)+32位虛數(shù)
complex128 復(fù)數(shù) 64位實數(shù)+64位虛數(shù)</p> <p>
byte uint8的別稱
rune int32的別稱
最大的驚喜就在于，Go語言支持復(fù)數(shù)類型的數(shù)據(jù):
var z complex64
z = 1.0 + 2.0i
fmt.Println(z)
如果你想知道rune是什么，那么當(dāng)你知道rune被用來存儲一個Unicode字符的時候，這個問題也就應(yīng)該迎刃而解了吧。換句話說，rune在Go語言中等價于字符（char）類型。
當(dāng)然你也可以使用uint、int卷二uintptr這些依賴于系統(tǒng)類型（32位或64位）的整數(shù)類型。
另外一個新穎的地方，當(dāng)你定義一個變量的時候，你變量的后面對其類型進(jìn)行定義，而不是在前面。
當(dāng)你在定義中初始化了變量，你無需對變量指定數(shù)據(jù)類型。如果在定義的時候未初始化，則變量將會被賦予0值：
var i=0
var x,y float32=1.0,2.0
和數(shù)字類型一樣，Boolean 類型也有相似的特征。
編譯器會完成相應(yīng)的工作。
一個使用Go語言定義和初始化變量的簡單例子：
x,y:=1,2
你也可以定義和使用常量。
數(shù)據(jù)結(jié)構(gòu)
常用的數(shù)據(jù)結(jié)構(gòu)有字符串（strings），數(shù)組（arrays）和結(jié)構(gòu)體（structs），以及另一位頗受歡迎的成員map。
字符串是Unicode編碼，其值不能修改，而其他方面和你想的差不多。
s="Hello"
可以使用len函數(shù)獲取字符串的長度，使用索引操作符[0]可以訪問字符串中的字符。Go語言中的字符串類型相當(dāng)簡陋，但使用stirng package可以實現(xiàn)類似其他語言字符串的所有功能。
數(shù)組（arrays）以中括號（[]）聲明，索引從零開始。例如：
var buff [32]byte
fmt.Println(buff[10])
多維數(shù)組通過數(shù)組的數(shù)組實現(xiàn)，
var buff [32][32]byte
fmt.Println(buff[10][0])
數(shù)組（array）不是動態(tài)的，不能動態(tài)分配大小。但可以使用切片（slice）實現(xiàn)同樣的效果。切片包含數(shù)組（array）的一部分，可以動態(tài)變更大小。
結(jié)構(gòu)體（structs）與其他語言類似，如下：
func main() { </p> <p> type point struct {
x, y int
}
var p = point{10, 10}
fmt.Println(p.x)
}
上例聲明了新的結(jié)構(gòu)體類型，包括兩個成員x和y。在main函數(shù)中創(chuàng)建并初始化了該結(jié)構(gòu)體類型的實例（instance）。Go語言通常不使用術(shù)語“實例（instance）”，而更喜歡使用術(shù)語“值（value）”，所以你是創(chuàng)建了該類型的一個值（value）。
結(jié)構(gòu)體定義中可以嵌套結(jié)構(gòu)體作為成員。初始化器（initializer）{10,10}是結(jié)構(gòu)體literal(譯注：literal可以理解為立即數(shù)，見維基)。在結(jié)構(gòu)體literal中也可以使用成員名例如{X:10}。
這是我們首次介紹Go類型，關(guān)于這個話題之后還有更多內(nèi)容。
最后一個數(shù)據(jù)類型是Map，等價于其他語言中的hash map，關(guān)聯(lián)數(shù)組（associative array）或者字典（dictionary）。
給定鍵的類型以及值的類型就能創(chuàng)建Map。如果從來沒有使用過關(guān)聯(lián)數(shù)組，那就把它想象成一個數(shù)組，數(shù)組的值不是通過索引訪問，而是通過通用類型的鍵訪問。例如。：
var m = make( map[string]int)
m["mike"] = 10
m["lucy"] = 30
fmt.Println(m["lucy"])
顯示結(jié)果是30.
make函數(shù)是能夠基于Type(類型)創(chuàng)建Value（值)（譯注：可以理解為實例）的兩個函數(shù)之一，要詳細(xì)了解它，我們需要學(xué)習(xí)更多關(guān)于類型的內(nèi)容。
類型
在Go語言中，類型特指一系列的值和操作。Go語言的類型起到的作用與眾所周知的面向?qū)ο蟮脑O(shè)計語言（Java、C++）有很大的不同，它沒有所謂的層次劃分、沒有類的概念也不存在繼承。類型是可以被推斷出來的，如：Go使用鴨子類型。
你可以用一個立即數(shù)（literal ）或指定的類型來定義一個類型變量，以達(dá)到類型重用的目的。
自定義類型是由一些小的數(shù)據(jù)類型整合而成的，如數(shù)組、結(jié)構(gòu)體、指針、很熟、接口、片、map和channel。
定義類型的方法:
type 類型名 數(shù)據(jù)類型
例：
type myint int
定義myint為一個整型類型。如果你想創(chuàng)建一個擴展類型，重新定義之前聲明過的類型的數(shù)據(jù)類型也很常用，實現(xiàn)的函數(shù)和方法我們之后再講。
更為通常的做法，你可以使用某些數(shù)據(jù)類型組成你自定義的類型:
type point struct {
x, y int
}
這就是一個新的類型結(jié)構(gòu)。
你也可以聲明數(shù)組類型：
type myarray [20]int
你可以在定義類型時使用自定義類型：
type point struct {
x, y int
}
type arrayPoints [10]point
這就創(chuàng)建了一個point類型的數(shù)組。
你可以自行探索其他的類型定義方式。接下來我們要做的是理解Go能用這些類型完成什么工作？
類型主要被用于下面兩個方面：
類型檢測
和
創(chuàng)建值
類型檢測很常見——你只能賦予你定義的變量與之相同類型的值。在編譯時編譯器會依此對靜態(tài)類型進(jìn)行檢查。
例:
var c myint
c = "string"
上面的代碼編譯將不會通過。但下面的代碼：
var c myint
c = 1
將會通過編譯。因為“c”和“1”都是整型數(shù)據(jù)。
類型所做的第二件事：在你用類型聲明變量時構(gòu)造對應(yīng)類型的變量。如：
var i int
或
var p point
但對于slice（片）、map和channel來說他們必須使用make函數(shù)創(chuàng)建對應(yīng)類型的值。
var m = make( map[string]int)
make函數(shù)是Go語言支持的兩個分配函數(shù)中的一個，另一個是new函數(shù)。make函數(shù)創(chuàng)建了一個指定類型的值，并把該值得指針返回給變量。在大多數(shù)地方，Go中的指針與C中的指針使用方法類似。
你可以使用*引用一個指針的值，也可以用&獲取值得地址。但是，Go和C的指針也存在差異，這種區(qū)別在于Go語言不存在指針計算。在Go語言中，指針存在的意義是讓你可以用引用的方式在函數(shù)之間傳遞參數(shù)。 如果你有一個類型T，那么*T就是一個指向類型T的指針。
舉一個new函數(shù)的例子:
var add= new(int)
在這里，new函數(shù)創(chuàng)建了一個整型變量并放回了它的地址存放在add中。變量add的類型為*int。
如果你寫出如下語句
fmt.Print(add)
那么你將得到這個整型值得地址。那么，為了打印這個整型變量的值，我們需要這樣書寫打印語句：
fmt.Print(*add)
就像之前提到過的那樣，你可以直接使用類型的值而無需給這個類型命名：
var p struct {
x, y int
}
如果你不需要重用這個類型，那么這樣做也是可以的。
函數(shù)
Go不是一種基于類并且有層次結(jié)構(gòu)的語言，也不使用通常的方式處理對象。如果你僅僅打算實現(xiàn)一個函數(shù)，那就不用考慮有關(guān)對象的內(nèi)容。函數(shù)就是一個值（Values），是“一等對象“。
如下，聲明一個函數(shù)
var myFunc = func(a, b int) int {
return a + b
}
可以指定參數(shù)類型和返回值類型，如果指定了返回值類型，則函數(shù)中必須有return語句。
函數(shù)值（value）被賦值給了變量myFunc。也可以按照通常的方式定義函數(shù)，這是變量myFunc就是函數(shù)的名稱。
func myFunc(a, b int) int {
return a + b
}
無論那種方式，函數(shù)都可以使用下面的方式調(diào)用：
fmt.Println(myFunc(1, 2))
可以在return語句中返回多個值，并且可以在函數(shù)頭中指定返回值的名稱。
例如：
func myFunc(a, b int) (sum int) {
sum = a + b
return
}
sum就是函數(shù)的返回值。
返回多個值也很簡單：
func myFunc(a, b int) (int, int) {
return a + b, a - b
}
必須全部接收函數(shù)的兩個返回值：
x,y := myFunc2(1, 4)
fmt.Println(x,y)
其他語言中可以選擇只接收一個返回值，但在Go語言中不可以。
傳值——指針
所有的形參都是以傳值的方式傳入，所以對形參做的任何改變都不會影響實參。例如：
func myFunc(a, b int) int {
a = 1
return a + b
}
函數(shù)中對形參a的賦值語句，對實參沒有任何影響。就是說
x, y := 2, 3
var sum = myFunc(x, y)
fmt.Println(sum, x)
顯示結(jié)果是4和2。x的值沒有變化。
如果想要改變實參的值，就需要傳入指針（譯注：即傳地址或傳引用）作為參數(shù)。例如，變更函數(shù)定義如下：
func myFunc(a *int, b int) int {
*a = 1
return *a + b
}
參數(shù)a以指針的形式傳入，對a的賦值語句改變a指向的變量。調(diào)用函數(shù)時，我們需要傳入變量的地址作為參數(shù)：
var sum = myFunc(&x, y)
fmt.Println(sum, x)
現(xiàn)在顯示結(jié)果是4和1，x的值變更了。
*和&操作符的用法對C程序員來說是非常熟悉的，這體現(xiàn)了Go語言較為初級的一面。有爭議說在現(xiàn)代語言中所有的參數(shù)都應(yīng)該以傳引用的方式傳入。
如果函數(shù)定義中的參數(shù)是*int類型，而調(diào)用該函數(shù)時沒有使用&操作數(shù)，那么在編譯階段類型檢查時就會報錯，而C語言沒有這個功能。
總之，Go語言的指針類型，可以作為實參傳遞給函數(shù)，但無法在數(shù)據(jù)上耍一些”聰明“的技巧。
作用域和閉包
你可以以嵌套的方式在函數(shù)中定義函數(shù)。在某塊代碼中定義的變量只會在該塊代碼區(qū)域和該代碼區(qū)域內(nèi)的區(qū)域生效。這意味著你可以在函數(shù)之外定義全局變量，那么所有的函數(shù)將都能使用這個變量。
例：
var a1 int = 1
func main() {
fmt.Println(a1)
var a2 int = 2
var myFunc = func() int {
return a2
}
fmt.Println(myFunc())
}
在這個例子中，a1是一個全局變量，可以被所有函數(shù)訪問。a2在main函數(shù)內(nèi)定義，因此它可以被main函數(shù)和main中的myFunc函數(shù)訪問。
Go同樣支持閉包。如果你在一個函數(shù)中定義了另一個函數(shù)，那么這個在內(nèi)部的函數(shù)將能夠訪問外部函數(shù)的變量，即使外部函數(shù)已經(jīng)終止運行。在外部函數(shù)停止后保持內(nèi)部函數(shù)的唯一方法是將其作為一個返回值返回給外部函數(shù)。
例:
func myFunc() func() int {
var a int = 1
return func() int {
return a
}
}
在這里，內(nèi)部函數(shù)以func() int的方式返回給外部函數(shù)。函數(shù)和它的內(nèi)容都是以類型的方式返回的。返回的函數(shù)將會返回外部函數(shù)定義的變量的值，這就是閉包的作用。
因此
myClosure := myFunc()
fmt.Println(myClosure())
輸出結(jié)果為 1.
每個閉包都有一份與自己綁定的變量副本，閉包不會實現(xiàn)不同函數(shù)副本之間的數(shù)據(jù)共享。
Go 控制
現(xiàn)在我們已經(jīng)了解過了數(shù)據(jù)、類型和函數(shù)。接下來我們將討論另一個重要的問題：Go語言提供的控制語句。
實際上，Go語言只提供了很少的控制結(jié)構(gòu)，它極大簡化了控制語句的使用。
Go語言是一種塊結(jié)構(gòu)的編程語言，它使用"{}"將一組代碼組成塊。如果你一直在奇怪其他編程語言中經(jīng)常使用的“;”去了哪里，我可以很明確的告訴你，在Go中它依然存在，只是在編譯過程中它會自動為你加上“;”。如果你也在代碼末尾加上分號，那么編譯器將會認(rèn)為它們是不需要的字符，從而自動剔除這些分號。
for循環(huán)是Go語言中的唯一一種循環(huán)。for循環(huán)可以被用來創(chuàng)建條件循環(huán)和枚舉循環(huán)。
for循環(huán)具有下面這種形式:
for 條件{
操作
}
需要注意的是，你無需將循環(huán)的條件置于一對大括號“{}”中。循環(huán)將會在不滿足條件時終止。循環(huán)將會在每次執(zhí)行循環(huán)體前檢查條件是否滿足，因此循環(huán)體可以被執(zhí)行0次或很多次，類似于while循環(huán)。
例：
i:=0
for a<10 {
fmt.print(a)
a=a+1
}
你可以通過使用for true {" 或者 "for {" 來創(chuàng)建一個不會終止的循環(huán)。
枚舉循環(huán)與其他類似C的語言基本相同:
for 表達(dá)式1 ; 條件 ; 表達(dá)式3{
操作
}
表達(dá)式1會在循環(huán)開始前執(zhí)行一次，表達(dá)式3會在每次循環(huán)體執(zhí)行結(jié)束后執(zhí)行一次，條件語句會在每次循環(huán)體執(zhí)行之前被檢查，如果為true則繼續(xù)執(zhí)行循環(huán)。
例:
for i:=0; i<10; i++ {
fmt.print(a)
}
你可以在for表達(dá)式中加入任何語句，但前提是你得加入分號以區(qū)分你的語句屬于表達(dá)式的哪個部分。但也有一種情況例外，你創(chuàng)建的條件表達(dá)式無需條件語句。
你也可以在for表達(dá)式中反復(fù)申明數(shù)組、片、字符串、map或channel中的值，用法與其他語言中的for循環(huán)類似。
例如：
var array= [] int {1,2,3,4}
for i,v:= range array {
fmt.print(i,v)
}
for表達(dá)式的循環(huán)次數(shù)取決于索引和數(shù)組的大小，好比這里的i和v。
在Go語言中，還存在另外兩種控制語句。if語句除了沒有大括號包圍的條件語句外，與其他語言中的if語句基本相同。
例：
if a<0 {
fmt.print("Negative")
} else {
fmt.print("Positive")
}
else條件不是必須的，但一對大括號必須完整：
if a<0 {
fmt.print("Negative")
}
你也可以通過使用else if創(chuàng)建一個符合條件表達(dá)式：
if a<0 {
fmt.print("Negative")
} else if a==0 {
fmt.print("Zero")
} else {
fmt.print("Positive")
}
你也可以在if主體內(nèi)容執(zhí)行之前執(zhí)行初始化語句:
if a:=myfunc() a<0 {
fmt.print("Negative")
}
所有在條件語句中創(chuàng)建的變量，只在條件表達(dá)式中適用。
另一種條件表達(dá)式為switch，它的存在是為了應(yīng)對在一個條件中有較多選項的情況。如：
switch a {
case 0,1:
fmt.print("a is 0 or 1)
case 2.3:
fmt.print("a is 2 or 3)
default:
fmt.print("a is some other value")
}
你也可以用下面的方式書寫條件語句：
case a<0:
在Go語言中，你無須用break跳出條件選擇。如過你想從一個case進(jìn)入接著的另一個case，那么你可以使用fallthrough語句 （注：fallthrough表示繼續(xù)執(zhí)行下面的Case而不是退出Switch）。case語句是按順序執(zhí)行的，一旦有相對應(yīng)的情況，執(zhí)行完case中的語句后程序?qū)詣诱{(diào)用break跳出選擇，因此default選項往往被放在最后。
除了對值和條件的匹配，你可以對類型進(jìn)行匹配，如：
switch a.type{
case int:
fmt.print("a is an int")
case float64:
fmt.print("a is a float")
default:
fmt.print("some other type")
}
最后，你可以使用break終止循環(huán)或continue終止當(dāng)前循環(huán)并直接進(jìn)入下一次循環(huán)，break也可以被用于switch語句中。
雖然Go語言中也有g(shù)oto語句，但這還是不講為好。
相關(guān)文章
WebStorm如何調(diào)試Vue項目? webstorm配置vue開發(fā)環(huán)境指南
WebStorm 支持多種調(diào)試工具，包括瀏覽器的開發(fā)者工具，但本文主要講解的是使用 WebStorm 自帶的調(diào)試功能2025-04-15
VSCode和webstorm怎么設(shè)置綠色護(hù)眼背景? 綠豆沙背景色的設(shè)置方法
護(hù)眼色一定程度能保護(hù)眼睛，緩解疲勞，VSCode和webstorm這兩款常用的軟件怎么設(shè)置護(hù)眼色呢？詳細(xì)請看下文介紹2025-04-15- WebStorm本身已經(jīng)足夠強大，但一些優(yōu)秀的插件能錦上添花，顯著提升開發(fā)效率，詳細(xì)請看下文介紹2025-04-15
如何安裝配置WebStorm? WebStorm安裝與使用全方位指南
WebStorm軟件在前端和后端開發(fā)領(lǐng)域都備受青睞，很多朋友不知道該怎么下載安裝，下面我們就來看看詳細(xì)的安裝配置教程2025-04-15Webstorm怎么配置? Webstorm入門之軟件配置教程
WebStorm是一款功能強大的集成開發(fā)環(huán)境（IDE），支持各種前端開發(fā)技術(shù)，今天我們就來看看Webstorm的配置教程2025-04-15Webstorm怎么設(shè)置字體大小/背景顏色/背景圖片?
WebStorm 允許您自定義界面顏色，以創(chuàng)建更個性化和美觀的工作空間，今天我們就來看看Webstorm改變字體大小、背景顏色、設(shè)置背景圖片的方法2025-04-15
VScode上安裝PlatformIO插件能成功安裝，嘗試卸載VScode并刪除插件，這些錯誤仍然存在，下面我們就來看看這個問題的解決辦法2025-04-03
提升代碼搜索效率! VSCode里DeepSeek插件安裝與配置指南
今天我們將向大家介紹如何在Visual Studio Code中安裝并配置 DeepSeek 插件，幫助你更高效地進(jìn)行代碼搜索2025-04-07提升你的編程效率! VSCode的初級使用教程超詳細(xì)版
VSCode是一款免費且開源的代碼編輯器，因其強大的功能和良好的用戶體驗而廣受歡迎，本文將詳細(xì)介紹 VSCode 的基本使用方法，并通過插圖幫助你更好地理解2025-04-03- 今天我們來聊聊如何安裝和配置VS Code，讓它成為你編程路上的得力助手，這個過程其實很簡單，只要跟著我的步驟走，你絕對能搞定2025-04-03
