Go 從入門到精通（三）字元串，時間，流程控制，函數

一、strings和strconv的使用

strings

strings.HasPrefix(s string,preffix string) bool:

判斷字元串s是否以prefix開頭

stirngs.HasSuffix(s string,suffix string) bool:

判斷字元串s是否以suffix結尾

strings.Index(s string,str string) int:

判斷str在s中首次出現的位置，如果沒有出現，則傳回-1

strings.LastIndex(s string,str string) int:

判斷str在s中最後出現的位置，如果沒有出現，則傳回-1

strings.Replace(str string,old string,new string,n int):

字元串替換

strings.Count(str string,count int)string:

字元串計數

strings.Repeat(str string,count int) string:

重複count次str

strings.ToLower(str string)

轉換為小寫

strings.ToUpper(str string)string:

轉換為大寫

strings.TrimSpace(str string):

去掉字元串首位空白字元

strings.Trim(str string,cut string):

去掉字元串首尾cut字元

strings.TrimLeft(str string,cut string):

去掉字元串首部cut字元

strings.TrimRight(str string,cunt string):

去掉字元串尾部cut字元

strings.Field(str string):

傳回str空格分隔的所有子串的slice

string.Split(str string,split string):

傳回str split分割的所有子串的slice

strings.Join(s1 []string,sep string):

用sep把s1中的所有元素連接配接起來

strconv

scronv.Itoa(i int):把一個整數轉換成字元串

scronv.Atio(str string)(int,errror):

把一個字元串轉換成整數

二、Go中時間和日期類型

目前時間：now:= time.Now()

time.Now().Day()

time.Now().Minute()

time.Now().Month()

time.Now().Year()

time.Duration用來表示納秒

一些常用的時間常量

const (

Nanosecond Duration = 1

Microsecond =1000 * Nanosecond

Millisecond =1000 * Microsecond

Second =1000 * Millisecond

Minute =60 * Second

Hour =60 * Minute

)

格式化

package main

import "fmt"

func main() {
    var a int = 10
    //通過&a列印a的指針位址
    fmt.Println(&a)
    //定義一個指針類型的變量p
    var p *int
    //講a的指針位址複制給p
    p = &a
    fmt.Println(*p)
    //給指針p指派
    *p = 100
    fmt.Println(a)
}      

三、指針類型

普通的類型，變量存的就是值，也叫值類型

擷取變量的位址，用&，

指針類型，變量存的是一個位址，這個位址存的才是真正的值

擷取指針類型所指向的值，用*,例如：var *p int, 使用 *p擷取p指向值

通過下面的代碼例子了解：

package main

import "fmt"

func main() {
    var a int = 10
    fmt.Println(&a)

    var p *int
    p = &a
    fmt.Println(*p)
    *p = 100
    fmt.Println(a)
}      

四、流程控制

if else 分支判斷

常見格式類型如下：

if 條件{

}

}else{

}else if 條件{

switch case

文法格式：

switch var {
    case var1:
    case var2:
    case var3:
    default:

}      

如果滿足了var1 想要穿透下一個需要添加fallthrough

例子如下：

package main

import "fmt"

func main() {
    var a int = 0

    switch a {
    case 0:
        fmt.Println("a 等于0")
        fallthrough
    case 1:
        fmt.Println("a等于1")
    default:
        fmt.Println("a等于預設值")
    }

}      

如果我們沒有添加fallthrough隻會列印a等于0,但是現在回把case1中的列印内容也列印出來

同樣這裡我們需要知道case 後面是可以寫條件的

for語句

文法

for 初始化變量；條件判斷；變量修改{

一個簡單的例子

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

for循環的其他幾種常見寫法

for 條件 {

死循環的寫法

for {

for range語句

通過一個例子了解：

str := "hello 世界"
for i,v := range str{
    fmt.Printf("index[%d] val[%c] len[%d]\n",i,v,len([]byte(string(v))))
}      

這裡需要注意的一個問題是，range str傳回的是兩個值，一個是字元串的下标，一個是字元串中單個的字元

goto 和label語句

package main

import "fmt"

func main() {
    LABEL1:for i:=0;i<5;i++{
        for j:=0;j<5;j++{
            if j == 4{
                continue LABEL1
            }
            fmt.Printf("i is :%d and j is:%d\n",i,j)
        }
    }
}      

代碼中我們在continue 後面添加了一個LABEL1這樣當循環比對到j等于4的時候，就會跳出循環，重新回到最外成i的循環，而如果沒有LABEL1則就會跳出j的本次循環，執行j++進入到j的下次循環

我們接着看goto的用法，但是代碼中我們不建議使用goto

package main

import "fmt"

func main() {
    i :=0
    HEAR:
    fmt.Println(i)
    i++
    if i == 5{
        return
    }
    goto HEAR
}      

break 和continue

一句話解釋：break是終止整個循環，continue是終止此次循環

五、函數詳解

聲明文法

func 函數名 (參數清單) [(傳回清單)]{

一些常見的寫法例子

func add(){

func add(a int,b int){

func add(a int,b int) int {

func add(a int,b int) (int,int) {

func add(a,b int)(int,int){

go函數的特點

1. 不支援重載，一個包不能包含連個名字一樣的函數
2. 函數是一等公民，函數也是一種類型，一個函數可以指派給變量
3. 匿名函數
4. 多傳回值

其他幾個概念可能都好了解，我們這裡主要說說第二條，函數也是一種類型，一個函數可以指派給變量

通過下面的例子示範

package main

import "fmt"

type add_func func(int,int) int


func add(a,b int) int {
    return a+b
}

func operator(op add_func,a int,b int) int {
    return op(a,b)
}
func main() {
    c := add
    fmt.Println(c)
    sum := operator(c,100,200)
    fmt.Println(sum)
}      

這裡通過type自定義了一個add_func類型

函數參數傳遞方式

這裡主要有兩種方式：值傳遞，引用傳遞

無論是值傳遞還是引用傳遞，傳遞給函數的都是變量的副本，不過值傳遞的是值的拷貝，引用傳遞傳遞的是位址的拷貝，一般來說，位址拷貝更為高效，而值拷貝取決于拷貝的對象的大小，對象越大，則性能越低

命名傳回值的名字

通過下面的例子了解：

func add_sum(a,b int)(c int){
    c = a + b
    return 
}      

下劃線辨別符，用來忽略傳回值

可變參數

表示0個或多個參數

fucn add(arg...int) int{

表示1個或多個參數

func add(a int,arg...int) int {

其中arg是一個slice,我們可以通過arg[index]擷取參數

通過len(arg)可以判斷參數的個數

defer用途

1. 當函數傳回時，執行defer語句，是以，可以用來做資源清理
2. 多個defer語句，按先進後廚的方式執行
3. defer語句中變量，在defer聲明時就決定了

package main
import "fmt"

func main() {
    a:=0
    defer fmt.Println("defer---->",a)
    a++
    fmt.Println(a)

}      

結果會在最後列印defer---->0 ，這裡就展現了defer語句中變量，在defer聲明時就決定了 

所有的努力都值得期許，每一份夢想都應該灌溉！