go語言一天入門（上）

 第一個go程序

package main

import "fmt"

func main() {
    /* 這是我的第一個簡單的程序 */
    fmt.Println("Hello, World!")
}

• 第一行代碼 package main 定義了包名。你必須在源文件中非註釋的第一行指明這個文件屬於哪個包，如：package main。package main表示一個可獨立執行的程序，每個 Go 應用程序都包含一個名爲 main 的包。
• 下一行 import "fmt" 告訴 Go 編譯器這個程序需要使用 fmt 包（的函數，或其他元素），fmt 包實現了格式化 IO（輸入/輸出）的函數。
• 下一行 func main() 是程序開始執行的函數。main 函數是每一個可執行程序所必須包含的，一般來說都是在啓動後第一個執行的函數（如果有 init() 函數則會先執行該函數）。
• 下一行 /*...*/ 是註釋，在程序執行時將被忽略。單行註釋是最常見的註釋形式，你可以在任何地方使用以 // 開頭的單行註釋。多行註釋也叫塊註釋，均已以 /* 開頭，並以 */ 結尾，多行註釋一般用於包的文檔描述或註釋成塊的代碼片段。
• 下一行 fmt.Println(...) 可以將字符串輸出到控制檯，並在最後自動增加換行字符 \n。
• 當標識符（包括常量、變量、類型、函數名、結構字段等等）以一個大寫字母開頭，如：Group1，那麼使用這種形式的標識符的對象就可以被外部包的代碼所使用（客戶端程序需要先導入這個包），這被稱爲導出（像面嚮對象語言中的 public）；標識符如果以小寫字母開頭，則對包外是不可見的，但是他們在整個包的內部是可見並且可用的（像面嚮對象語言中的 protected ）。

數據類型

Go語言的基本類型有：

• bool
• string
• int、int8、int16、int32、int64
• uint、uint8、uint16、uint32、uint64、uintptr
• byte // uint8 的別名
• rune // int32 的別名 代表一個 Unicode 碼
• float32、float64
• complex64、complex128

變量

Go語言是靜態類型語言，因此變量（variable）是有明確類型的，編譯器也會檢查變量類型的正確性。

1）聲明變量的一般形式是使用 var 關鍵字：var name type

Go和許多編程語言不同，它在聲明變量時將變量的類型放名稱後。這樣做的好處就是可以避免像C語言中那樣含糊不清的聲明形式，例如：int* a, b; 。其中只有 a 是指針而 b 不是。如果你想要這兩個變量都是指針，則需要將它們分開書寫。而在 Go 中，則可以和輕鬆地將它們都聲明爲指針類型：var a, b *int

多變量聲明

var (
    a int
    b string
    c []float32
    d func() bool
    e struct {
        x int
    }
)

 

2）除 var 關鍵字外，還可使用更加簡短的變量定義和初始化語法。

名字 := 表達式

需要注意的是，簡短模式（short variable declaration）有以下限制：

• 定義變量，同時顯式初始化。
• 不能提供數據類型。
• 只能用在函數內部。

和 var 形式聲明語句一樣，簡短變量聲明語句也可以用來聲明和初始化一組變量：

i, j := 0, 1

3）根據值自行判定變量類型。

package main
import "fmt"
func main() {
    var d = true
    fmt.Println(d)
}

算術運算符

package main

import "fmt"

func main() {

   var a int = 21
   var b int = 10
   var c int

   c = a + b
   fmt.Printf("第一行 - c 的值爲 %d\n", c )
   c = a - b
   fmt.Printf("第二行 - c 的值爲 %d\n", c )
   c = a * b
   fmt.Printf("第三行 - c 的值爲 %d\n", c )
   c = a / b
   fmt.Printf("第四行 - c 的值爲 %d\n", c )
   c = a % b
   fmt.Printf("第五行 - c 的值爲 %d\n", c )
   a++
   fmt.Printf("第六行 - a 的值爲 %d\n", a )
   a=21   // 爲了方便測試，a 這裏重新賦值爲 21
   a--
   fmt.Printf("第七行 - a 的值爲 %d\n", a )
}

第一行 - c 的值爲 31
第二行 - c 的值爲 11
第三行 - c 的值爲 210
第四行 - c 的值爲 2
第五行 - c 的值爲 1
第六行 - a 的值爲 22
第七行 - a 的值爲 20

位運算符

位運算符對整數在內存中的二進制位進行操作。

下表列出了位運算符 &, |, 和 ^ 的計算：

 

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

 

假定 A = 60; B = 13; 其二進制數轉換爲：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

 

運算符	描述	實例
&	參與運算的兩數各對應的二進位相與。	(A & B) 結果爲 12, 二進制爲 0000 1100
|	參與運算的兩數各對應的二進位相或	(A | B) 結果爲 61, 二進制爲 0011 1101
^	參與運算的兩數各對應的二進位相異或，當兩對應的位相異時，結果爲1。	(A ^ B) 結果爲 49, 二進制爲 0011 0001
<<	左移n位就是乘以2的n次方。 其功能把"<<"左邊的運算數的各二進位全部左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0。	A << 2 結果爲 240 ，二進制爲 1111 0000

 賦值運算符

下表列出了所有Go語言的賦值運算符。

運算符	描述	實例
=	簡單的賦值運算符，將一個表達式的值賦給一個左值	C = A + B 將 A + B 表達式結果賦值給 C
+=	相加後再賦值	C += A 等於 C = C + A
-=	相減後再賦值	C -= A 等於 C = C - A
*=	相乘後再賦值	C *= A 等於 C = C * A
/=	相除後再賦值	C /= A 等於 C = C / A
%=	求餘後再賦值	C %= A 等於 C = C % A
<<=	左移後賦值	C <<= 2 等於 C = C << 2
>>=	右移後賦值	C >>= 2 等於 C = C >> 2
&=	按位與後賦值	C &= 2 等於 C = C & 2
^=	按位異或後賦值	C ^= 2 等於 C = C ^ 2
|=	按位或後賦值	C |= 2 等於 C = C | 2

 

其他運算符

 

運算符	描述	實例
&	返回變量存儲地址	&a; 將給出變量的實際地址。
*	指針變量。	*a; 是一個指針變量

以下實例演示了其他運算符的用法：

實例

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* 運算符實例 */
   fmt.Printf("第 1 行 - a 變量類型爲 = %T\n", a );
   fmt.Printf("第 2 行 - b 變量類型爲 = %T\n", b );
   fmt.Printf("第 3 行 - c 變量類型爲 = %T\n", c );

   /*  & 和 * 運算符實例 */
   ptr = &a     /* 'ptr' 包含了 'a' 變量的地址 */
   fmt.Printf("a 的值爲  %d\n", a);
   fmt.Printf("*ptr 爲 %d\n", *ptr);
}

以上實例運行結果：

第 1 行 - a 變量類型爲 = int
第 2 行 - b 變量類型爲 = int32
第 3 行 - c 變量類型爲 = float32
a 的值爲  4
*ptr 爲 4

運算符優先級

由上至下代表優先級由高到低：

優先級	運算符
5	* / % << >> & &^
4	+ - | ^
3	== != < <= > >=
2	&&
1	||

循環

普通for循環

package main

import "fmt"

func main() {
        sum := 0
        for i := 0; i <= 10; i++ {
                sum += i
        }
        fmt.Println(sum)
}

 foreach

這種格式的循環可以對字符串、數組、切片等進行迭代輸出元素。

package main
import "fmt"

func main() {
        strings := []string{"google", "runoob"}
        for i, s := range strings {
                fmt.Println(i, s)
        }


        numbers := [6]int{1, 2, 3, 5} 
        for i,x:= range numbers {
                fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
        }  
}

 

函數

func function_name( [parameter list] ) [return_types] {
   函數體
}

• func：函數由 func 開始聲明
• function_name：函數名稱，函數名和參數列表一起構成了函數簽名。
• parameter list：參數列表，參數就像一個佔位符，當函數被調用時，你可以將值傳遞給參數，這個值被稱爲實際參數。參數列表指定的是參數類型、順序、及參數個數。參數是可選的，也就是說函數也可以不包含參數。
• return_types：返回類型，函數返回一列值。return_types 是該列值的數據類型。有些功能不需要返回值，這種情況下 return_types 不是必須的。
• 函數體：函數定義的代碼集合。

/* 函數返回兩個數的最大值 */
func max(num1, num2 int) int {
   /* 聲明局部變量 */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

返回多個值

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Google", "Runoob")
   fmt.Println(a, b)
}

引用傳參

package main

import "fmt"

func main() {
   /* 定義局部變量 */
   var a int = 100
   var b int= 200

   fmt.Printf("交換前，a 的值 : %d\n", a )
   fmt.Printf("交換前，b 的值 : %d\n", b )

   /* 調用 swap() 函數
   * &a 指向 a 指針，a 變量的地址
   * &b 指向 b 指針，b 變量的地址
   */
   swap(&a, &b)

   fmt.Printf("交換後，a 的值 : %d\n", a )
   fmt.Printf("交換後，b 的值 : %d\n", b )
}

func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保存 x 地址上的值 */
   *x = *y      /* 將 y 值賦給 x */
   *y = temp    /* 將 temp 值賦給 y */
}

數組

聲明：

語法格式如下：

var variable_name [SIZE] variable_type

以上爲一維數組的定義方式。例如以下定義了數組 balance 長度爲 10 類型爲 float32：

var balance [10] float32

初始化：

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

初始化數組中 {} 中的元素個數不能大於 [] 中的數字。

如果忽略 [] 中的數字不設置數組大小，Go 語言會根據元素的個數來設置數組的大小：

 var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

該實例與上面的實例是一樣的，雖然沒有設置數組的大小。

 balance[4] = 50.0

初始化二維數組：

a = [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引爲 0 */
 {4, 5, 6, 7} ,   /*  第二行索引爲 1 */
 {8, 9, 10, 11},   /* 第三行索引爲 2 */
}

注意：以上代碼中倒數第二行的 } 必須要有逗號，因爲最後一行的 } 不能單獨一行，也可以寫成這樣：

a = [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引爲 0 */
 {4, 5, 6, 7} ,   /*  第二行索引爲 1 */
 {8, 9, 10, 11}}   /* 第三行索引爲 2 */

指針

和c一樣

package main

import "fmt"

func main() {
   var a int= 20   /* 聲明實際變量 */
   var ip *int        /* 聲明指針變量 */

   ip = &a  /* 指針變量的存儲地址 */

   fmt.Printf("a 變量的地址是: %x\n", &a  )

   /* 指針變量的存儲地址 */
   fmt.Printf("ip 變量儲存的指針地址: %x\n", ip )

   /* 使用指針訪問值 */
   fmt.Printf("*ip 變量的值: %d\n", *ip )
}

a 變量的地址是: 20818a220
ip 變量儲存的指針地址: 20818a220
*ip 變量的值: 20

空指針判斷：

if(ptr != nil)     /* ptr 不是空指針 */
if(ptr == nil)    /* ptr 是空指針 */

多重指針： 

package main

import "fmt"

func main() {

   var a int
   var ptr *int
   var pptr **int

   a = 3000

   /* 指針 ptr 地址 */
   ptr = &a

   /* 指向指針 ptr 地址 */
   pptr = &ptr

   /* 獲取 pptr 的值 */
   fmt.Printf("變量 a = %d\n", a )
   fmt.Printf("指針變量 *ptr = %d\n", *ptr )
   fmt.Printf("指向指針的指針變量 **pptr = %d\n", **pptr)
}

變量 a = 3000
指針變量 *ptr = 3000
指向指針的指針變量 **pptr = 3000