Go學習

時間 2019-11-09

標籤學習简体版

原文原文鏈接

Go學習

Go語言優點

可直接編譯成機器碼，不依賴其餘庫。
靜態類型語言
語言層面支持併發
內置runtime，支持垃圾回收
簡單易學，Go語言的做者都有C的基因，那麼Go天然而然就有了C的基因，那麼Go關鍵字是25個，可是表達能力很強大，幾乎支持大多數其餘語言見過的特性：繼承、重載、對象等
豐富的標準庫
內置強大的工具，Go語言裏面內置了不少工具鏈，最好的應該是gofmt工具，自動化格式化代碼，可以讓團隊review變得如此的簡單，代碼格式如出一轍，想不同都很困難。
跨平臺編譯
內嵌C支持，Go裏面也能夠直接包含C代碼，利用現有的豐富的C庫。數據庫

Go適合用來作什麼
服務器編程
分佈式系統，數據庫代理器
網絡編程
內存數據庫編程

標準命令概述
build:用於編譯給定的代碼包或Go語言源碼文件及其依賴包。
clean:用於清除執行其餘Go命令後遺留的目錄和文件。
doc:用於執行godoc命令以打印指定代碼包。
env:用於打印go語言環境信息
fix:用於執行gotoo fix命令以修正給定代碼包的源碼文件中包含的過期語法和代碼調用。
fmt:用於執行gofmt命令以格式化給定代碼包中的源碼文件。
get：用於下載和安裝給定代碼包及其依賴包
list:用於顯示給定代碼包的信息。
run：用於編譯並運行給定的命令源碼文件。
install:編譯包文件並編譯整個程序。
test:用於測試給定的代碼包。
tool:用於運行Go語言的特殊工具。
version:用於顯示當前安裝的Go語言的版本信息。數組

第一個Go程序

package main

import (
    "fmt"
)
func main(){
    fmt.Println("hello world")
}

關鍵字

break
default
func
interface
select
case
defer
go
map
struct
chan
else
goto
package
switch
const
fallthrough
if
range
type
continue
for
import
return
var

內建常量：
true false iota nil服務器

內建類型：int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex128 complex64 bool byte rune string error網絡

內建函數：make len cap new append copy close delete complex real imag panic recover併發

變量

var v1 int
var v2 int
//一次定義多個變量
var v3,v4,v5 int

var (
    v10 int
    v11 int
)

var v1 int = 10
var v2 = 10
v3 := 10
var v11,v22,v23 = 1, 2, 3

基礎數據類型

類型	名稱	長度	零值	說明
bool	布爾類型	1	false	其值不爲真就是假，不能夠用數字表明true或false
byte	字節型	1	0	uint8別名
rune	字符類型	4	0	專用於存儲unicode編碼，等價於uint32
int,uint	整型	4或8	0	32位或64位
int8,uint8	整型	1	0	-128~127，0~255
int16,uint16	整型	2	0	-32768~32767，0~65535
int32,uint32	整型	4	0	-21億~21億，0~42億
int64,uint64	整型	8	0
float32	浮點型	4	0.0	小數位精確到7位
float64	浮點型	8	0.0	小數位精確到15位
complex64複數類型	8
complex128複數類型	16
uintptr整型	4或8			以存儲指針的uint32或uint64整數
string	字符串	""		utf-8字符串

使用fmt包來格式化字符串

fmt.Printf()格式字符串：
|打印格式|含義|
|---|---|
|%%|一個%字面量|
|%b|一個二進制整數值（基數爲2），或者是一個用科學計數法表示的指數爲2的浮點數|
|%c|字符型。能夠把輸入的數字按照ASCII碼相應轉換位對應的字符|
|%e|以科學技術法e表示的浮點數或者複數值|
|%E|以科學計數法E表示的浮點數或者複數值|
|%f|以標準計數法表示的浮點數或者複數值|
|%g|以%e或者%f表示的浮點數或者複數，任何一個以最爲緊湊的方式輸出|
|%G|以%E或者%f表示的浮點數或者複數，任何一個都以最爲緊湊的方式輸出|
|%o|一個以八進制表示的數字（基數爲8）|
|%p|以十六進制（基數爲16）表示的一個值的地址，前綴爲0x，字母使用小寫的a-f表示|
|%T|使用Go語法輸出的值的類型|app

類型轉換

Go語言中不容許隱式轉換，全部類型轉換必須顯示聲明，並且轉換隻能發生在兩種相互兼容的類型之間。分佈式

var ch byte = 97
var a int = int(ch)

類型別名

type bigint int64 // int64類型更名爲bigint
var x bigint = 100
type (
    myint int
    mystr string
)

流程控制

Go語言支持最基本的三種程序運行結構：順序結構、選擇結構、循環結構。函數

if語句

if工具

var a int = 3
if a == 3{
    fmt.Println("a==3")
}
//支持一個初始化表達式，初始化子句和條件表達式直接須要用分號分隔
if b := 3; b == 3{
    fmt.Println("b == 3")
}

if...else

if a := 3; a == 4{

}else{
    fmt.Println("a != 4")
}

switch語句
Go裏面switch默認至關於每一個case最後帶有break,匹配成功後不會自動向下執行其餘case,而是跳出整個switch，可是可使用fallthrough強制執行後面的case代碼：

var score int = 90
switch score{
    case 10:
        fmt.Println("遊戲")
    case 80:
        fmt.Println("靚號")
    default:
        fmt.Println("差")
}

可使用任何類型或表達式做爲條件語句：

switch s1 := 90; s1{
    case 90:
        fmt.Println("優秀")
    default:
        fmt.Println("通常")
}
var s2 int = 90
switch {
    case s2 >= 90:
        fmt.Println("優秀")
    case s2 >=80
        fmt.Println("發的")
}

循環語句
for

var i, sum int
for i = 1; i <= 100; i++{
    sum += i
}
fmt.Println("sum =", sum)

range

s := "abc"
for i := range s{
    fmt.Printf("%c\n", s[i])
}
for _, c := range s{
    fmt.Println("%c\n", c)
}

跳轉語句
break和continue

for i := 0; i < 100; i++{
    if 2 == i{
        continue
    }
}

goto

func main(){
    LABEL:
    for i := 0; i < 100; i++{
        for {
            fmt.Println(i)
            goto LABEL
        }
    }
}

自定義格式

Go語言函數定義格式：

func FuncName(/*參數列表*/) (o1 type1, o2 type2/*返回類型*/){
    //函數體
    return v1, v2
}

延遲調用defer

defer做用
關鍵字defer用於延遲一個函數或者方法的執行

func main(){
    fmt.Println("this is a test")
    defer fmt.Println("this is a defer")
}

多個defer執行順序
若是一個函數中多個defer語句，他們會以LIFO（後進先出）的順序執行。哪怕函數或某個延遲調用發生錯誤，這些調用依舊會被執行。

獲取命令行參數

package main

import (
    "fmt"
    "os"
)
func main(){
    args := os.Args
    if args == nil || len(args) < 2{
        fmt.Println("err:xxx ip port")
        return
    }
    ip := args[1]
    port := args[2]
}

複合類型

類型	名稱	長度	默認值	說明
pointer	指針		nil
array	數組	0
slice	切片		nil	引用類型
map	字典	n	nil	引用類型
struct	結構體

複合類型-指針

默認值nil,沒有NULL常量
操做符「&」取變量地址，"*"經過指針訪問目標對象
不支持指針運算，不支持"->"運算符，直接用"."訪問目標成員

package main

import (
    "fmt"
)
func main(){
    var a int = 10
    fmt.Printf("&a = %p", &a)

    var p *int = nil
    p = &a
    fmt.Printf("p = %p\n", p)
    fmt.Printf("a = %d,*p = %d\n", a, *p)
    *p = 111
    fmt.Printf("a = %d, *p = %d\n", a, *p)
}

new函數
表達式new(T)將建立一個T類型的匿名變量，所作的是爲T類型的新值分配並清零一塊內存空間，而後將這塊內存空間的地址做爲結果返回，而這個結果就是指向這個新的T類型值的指針值，返回的指針類型爲*T.

package main

import (
    "fmt"
)
func main(){
    var p1 *int
    p1 = new(int)
    fmt.Println("*p1 = ", *p1)
    p2 := new(int)
    *p2 = 111
    fmt.Println("*p2 = ", *p2)
}

符合類型-數組

數組是指一系列同一類型數據的集合。數組中包含的每一個數據被稱爲數組元素，一個數組包含的元素個數被稱爲數組的長度。
數組長度必須是常量，且是類型的組成部分。[2]int 和 [4]int是不一樣類型。
操做數組
數組的每一個元素能夠經過索引下標來訪問，索引下標的範圍是從0開始到數組長度減1的位置。

package main

import (
    "fmt"
)

func main(){
    var a [10] int
    for i := 0; i < 10; i++{
        a[i] = i + 1
        fmt.Println(i, a[i])
    }

    for i, v := range a{
        fmt.Println(i, v)
    }
}

內置函數len和cap都返回數組長度