1.go的優點

簡潔、快速、安全
並行、有趣、開源
內存管理、數組安全、編譯迅速
對於高性能分佈式系統領域而言，Go 語言無疑比大多數其它語言有着更高的開發效率。

2.語言結構

2.1基礎組成部分

包聲明、引入包、函數、變量、語句 & 表達式、註釋。第一行代碼 package main 定義了包名。你必須在源文件中非註釋的第一行指明這個文件屬於哪個包，如：package main。package main表示一個可獨立執行的程序，每個 Go 應用程序都包含一個名爲 main 的包。例子：

package main

import "fmt"

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

※ 當標識符（包括常量、變量、類型、函數名、結構字段等等）以一個大寫字母開頭，如：Group1，那麼使用這種形式的標識符的對象就可以被外部包的代碼所使用（客戶端程序需要先導入這個包），這被稱爲導出（像面嚮對象語言中的 public）；標識符如果以小寫字母開頭，則對包外是不可見的，但是他們在整個包的內部是可見並且可用的（像面嚮對象語言中的 protected ）。

※ { 大括號的左半邊，不能單獨在一行。

2.2運行程序

兩種方式：

1）進入到hello.go所在目錄中，運行如下命令

$ go run hello.go

2）先生成二進制文件，再運行二進制文件

$ go build hello.go 
$ ls
hello    hello.go
$ ./hello

3.基礎語法

Go 標記：Go 程序可以由多個標記組成，可以是關鍵字，標識符，常量，字符串，符號。也即是一行代碼中能拆分出來的內容。

標識符：標識符用來命名變量、類型等程序實體。一個標識符實際上就是一個或是多個字母(A~Z和a~z)數字(0~9)、下劃線_組成的序列，但是第一個字符必須是字母或下劃線而不能是數字。這點同c語言。

數據類型：用於聲明函數和變量。數據類型的出現是爲了把數據分成所需內存大小不同的數據，編程的時候需要用大數據的時候才需要申請大內存，就可以充分利用內存。

序號	類型和描述
1	布爾型布爾型的值只可以是常量 true 或者 false。一個簡單的例子：var b bool = true。
2	數字類型整型 int 和浮點型 float32、float64，Go 語言支持整型和浮點型數字，並且支持複數，其中位的運算採用補碼。
3	字符串類型: 字符串就是一串固定長度的字符連接起來的字符序列。Go 的字符串是由單個字節連接起來的。Go 語言的字符串的字節使用 UTF-8 編碼標識 Unicode 文本。
4	派生類型: 包括： (a) 指針類型（Pointer） (b) 數組類型 (c) 結構化類型(struct) (d) Channel 類型 (e) 函數類型 (f) 切片類型 (g) 接口類型（interface） (h) Map 類型

語言變量：變量來源於數學，是計算機語言中能儲存計算結果或能表示值抽象概念。變量來源於數學，是計算機語言中能儲存計算結果或能表示值抽象概念。聲明變量的一般形式是使用 var 關鍵字，這點同scala。

//格式
var identifier type
//例子
var a string = "Runoob"

※：1.指定變量類型，如果沒有初始化，則變量默認爲零值。數值類型（包括complex64/128）爲 0，布爾類型爲 false，字符串爲 ""（空字符串）。

※：2.根據值自行判定變量類型。eg：var v_name = value

※：3.省略 var, 注意 := 左側如果沒有聲明新的變量，就產生編譯錯誤。也就是說，要用：=，就不要使用var。

值類型和引用類型：

像 int、float、bool 和 string 這些基本類型都屬於值類型，使用這些類型的變量直接指向存在內存中的值。當使用等號 = 將一個變量的值賦值給另一個變量時，如：j = i，實際上是在內存中將 i 的值進行了拷貝。

你可以通過 &i 來獲取變量 i 的內存地址，例如：0xf840000040。值類型的變量的值存儲在棧中。一個引用類型的變量 r1 存儲的是 r1 的值所在的內存地址（數字），或內存地址中第一個字所在的位置。當使用賦值語句 r2 = r1 時，只有引用（地址）被複制。如果 r1 的值被改變了，那麼這個值的所有引用都會指向被修改後的內容，在這個例子中，r2 也會受到影響。

使用 := 賦值操作符：如果在相同的代碼塊中，我們不可以再次對於相同名稱的變量使用初始化聲明。如果你在定義變量 a 之前使用它，則會得到編譯錯誤 undefined: a。如果你聲明瞭一個局部變量卻沒有在相同的代碼塊中使用它，同樣會得到編譯錯誤。但是全局變量是允許聲明但不使用的。同一類型的多個變量可以聲明在同一行。

語言常量：常量是一個簡單值的標識符，在程序運行時，不會被修改的量。常量中的數據類型只可以是布爾型、數字型（整數型、浮點型和複數）和字符串型。

//格式
const identifier [type] = value
//例子
顯式類型定義： const b string = "abc"
隱式類型定義： const b = "abc"

iota：在 const關鍵字出現時將被重置爲 0(const 內部的第一行之前)，const 中每新增一行常量聲明將使 iota 計數一次(iota 可理解爲 const 語句塊中的行索引)。

    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //獨立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢復計數
            i          //8
    )
//運行結果
0 1 2 ha ha 100 100 7 8

go語言條件語句：

   /* 定義局部變量 */
   var a int = 10
 
   /* 使用 if 語句判斷布爾表達式 */
   if a < 20 {
       /* 如果條件爲 true 則執行以下語句 */
       fmt.Printf("a 小於 20\n" )
   }

Go 語言循環語句：for循環

語法：Go 語言的 For 循環有 3 種形式，只有其中的一種使用分號。

和 C 語言的 for 一樣：

//格式
for init; condition; post { }
//例子
package main

import "fmt"

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

和 C 的 while 一樣：

        // 這樣寫也可以，更像 While 語句形式
        for sum <= 10{
                sum += sum
        }

和 C 的 for(;;) 一樣：

        sum := 0
        for {
            sum++ // 無限循環下去
        }

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

package main
import "fmt"

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

        //[6]int{1, 2, 3, 5} 表示數組長度是6，類型是int，初始化了前4個元素爲{1,2,3,5}
        numbers := [6]int{1, 2, 3, 5}
        for i,x:= range numbers {
                fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
        }  
}

輸出：
0 google
1 runoob
第 0 位 x 的值 = 1
第 1 位 x 的值 = 2
第 2 位 x 的值 = 3
第 3 位 x 的值 = 5
第 4 位 x 的值 = 0
第 5 位 x 的值 = 0

4.Go 語言函數

Go 語言最少有個 main() 函數。

Go 語言函數定義格式如下：

func function_name( [parameter list] ) [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)
}

Go 語言數組：具有相同唯一類型的一組已編號且長度固定的數據項序列。

聲明數組：Go 語言數組聲明需要指定元素類型及元素個數，語法格式如下：

//格式
var variable_name [SIZE] variable_type
//例子
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}

數組元素可以通過索引（位置）來讀取。格式爲數組名後加中括號，中括號中爲索引的值。eg: Element[0] = 100

Go 語言指針：

Go 語言的取地址符是 &，放到一個變量前使用就會返回相應變量的內存地址。

類似於變量和常量，在使用指針前你需要聲明指針。指針聲明格式如下：

格式
var var_name *var-type
例子
var ip *int        /* 指向整型*/

如何使用指針？指針使用流程：定義指針變量，爲指針變量賦值，訪問指針變量中指向地址的值。在指針類型前面加上 * 號（前綴）來獲取指針所指向的內容。當一個指針被定義後沒有分配到任何變量時，它的值爲 nil。

Go 語言結構體

在結構體中我們可以爲不同項定義不同的數據類型。結構體是由一系列具有相同類型或不同類型的數據構成的數據集合。

定義結構體：結構體定義需要使用 type 和 struct 語句。struct 語句定義一個新的數據類型，結構體中有一個或多個成員。type 語句設定了結構體的名稱。結構體的格式如下：

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

eg：
variable_name := structure_variable_type {value1, value2...valuen}

訪問結構體成員：如果要訪問結構體成員，需要使用點號 . 操作符。

參考：

1.網頁資料：https://www.runoob.com/go/go-program-structure.html

【go】學習筆記

1.go的優點

2.語言結構

3.基礎語法

4.Go 語言函數

Go 語言指針：

Go 語言結構體

mac os 新系統配置—— anaconda安裝及管理

【go】學習筆記

【LeetCode】bash統計詞頻率——awk、sort

工作中常用到的一些linux命令

【Python】多線程及例子

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結