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 條件{
}

if 條件{
}else{
}

if 條件{
}else if 條件{
}else{
}

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宣告時就決定了 

轉自https://www.cnblogs.com/zhaof/p/7072122.html