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

golang基礎之三-字符串，時間，流程控制，函數