Go 从入门到精通（三）字符串，时间，流程控制，函数详解编程语言

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 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 i++{ 

 for j:=0;j 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函数的特点

不支持重载，一个包不能包含连个名字一样的函数 函数是一等公民，函数也是一种类型，一个函数可以赋值给变量

其他几个概念可能都好理解，我们这里主要说说第二条，函数也是一种类型，一个函数可以赋值给变量

通过下面的例子演示

package main 

import "fmt" 

type add_func func(int,int) int 


这里主要有两种方式：值传递，引用传递

无论是值传递还是引用传递，传递给函数的都是变量的副本，不过值传递的是值的拷贝，引用传递传递的是地址的拷贝，一般来说，地址拷贝更为高效，而值拷贝取决于拷贝的对象的大小，对象越大，则性能越低

命名返回值的名字

通过下面的例子理解：

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用途