（1）、字符串的操作
1.1、strings包的使用
1.1.1、字符串的首尾字符的判断
strings.HasPrefix(s string, prefix string) bool ：判断字符串s是否以prefix开头
- strings.HasSuffix(s string, suffix string) bool ：判断字符串s是否以suffix结尾
范例：自动在输入的url前面加上 “http://” 末尾加上 “/”
package main import ( "fmt" "strings" // "strconv" ) func main(){ var n string fmt.Println("Input Your Web Urls:") fmt.Scanf("%s",&n) n=http_ch(n) n=http_ch_end(n) fmt.Printf("Your url is ========> [%s]",n) } //自动在web的URL前面添加 "http://"" func http_ch(url string) string { if strings.HasPrefix(url,"http://"){ return url } else { return fmt.Sprintf("http://%s",url) } } //自动在web的URL末尾添加 "/" func http_ch_end(url string) string { if strings.HasSuffix(url,"/"){ return url } else { return fmt.Sprintf("%s/",url) } }1.1.2、其他字符串的判断
1.strings.Index(s string, str string) int
判断str在s中首次出现的位置，如果没有出现，则返回-1
2.strings.LastIndex(s string, str string) int
判断str在s中最后出现的位置，如果没有出现，则返回-1
3.==strings.Replace(str string, old string, new string, n int)==
字符串替换
str_a="hello wid" result:=strings.Replace(str_a,"i","or")执行后，result的值为
hello word4.strings.Count(str string, substr string)int
计算substr字符在字符串str中出现的次数
5.strings.Repeat(str string, count int)string
将str字符串重复count次
6.strings.ToLower(str string)string
将字符串全部转为小写
7.strings.ToUpper(str string)string
将字符串全部转为大写
1.1.3、去掉字符串指定字符
1.strings.TrimSpace(str string)
去掉字符串首尾空白字符（类似python的.strip()方法）
2.strings.Trim(str string, cut string)
去掉字符串首尾cut字符
3.strings.TrimLeft(str string, cut string)
去掉字符串首cut字符
4.strings.TrimRight(str string, cut string)
去掉字符串尾cut字符
1.1.4、字符串的切割
1.strings.Field(str string)
返回str空格分隔的所有子串的slice（类似python的.split()方法）
strings.Field('jk iu 123')==结果为>>>>["jk","iu","123"]2.strings.Split(str string, split string)
返回str split分隔的所有子串的slice
strings.Split('jk#iu#123','#')==结果为>>>>["jk","iu","123"]第一种Field方法相当于：strings.Split(str string, ” “)
1.1.5、字符串的拼接
strings.Join(s1 []string, sep string)
用sep把s1中的所有元素链接起来
1.2、strconv包的使用
- strconv.Itoa(i int)
把一个整数i转成字符串
- strconv.Atoi(str string)(int, error)
把一个字符串转成整数
var str_b string = "1980" num,err := strconv.Atoi(str_b) if err !=nil { //输入错误时，执行这步。比如：当str_b为"1980x"时会执行这步 fmt.Printf("你应该输入一个整数类似的字符串,%s",err) } fmt.Println(num)
（2）、数据类型
2.1、时间类型
时间类型在time包中，ime.Time类型，用来表示时间。
- #### 2.1.1、如何获取当前时间？
now := time.Now()
now输出为
2018-08-21 17:32:23.5956001 +0800 CST m=+0.012000001一个完整的时间格式，很明显我们用不了这么多的数据- #### 2.1.2、时间的格式化
方法一 : 使用 time.Now().Day()，time.Now().Minute()，time.Now().Month()，time.Now().Year() 这些方法，别可以输入当前的 日、分、月、年，然后可以使用printf格式化的输出：
例如：
package main import ( "time" "fmt" ) func main() { fmt.Printf("%d-%02d-%02d",time.Now().Year(),time.Now().Month(),time.Now().Day()) //%02d表示至少使用2个位数表示 }输出结果为：
2018-08-19方法二 :* 使用time.Now()自带的Format方法，Format里面是时间格式显示模板，并且模板内的年必须是2006、月必需是01、日必需是02、时必需是15（或3）、分必需是04。模板展示的效果才生效。然后根据Format模板
里面的格式来显示日期不要问我模板内展示的日期为什么必需要用 2006年01月02日15时04分，据说是go语言诞生的时间，我可以吐槽下有点自恋吗 -.-!
time.Now().Format(“2006-01-02”) : 表示使用 “年-月-日” 的方式来显示,显示结果为
2018-08-19
time.Now().Format(“20060102”) : 表示使用 “年月日” 的方式来显示,显示结果为201808192.1.3、时间的常量
time.Duration 用来表示纳秒
time.second 用来表示秒
其他常量：
const ( Nanosecond Duration = 1 //纳秒 Microsecond = 1000 * Nanosecond //微秒 Millisecond = 1000 * Microsecond //毫秒 Second = 1000 * Millisecond //秒 Minute = 60 * Second //分 Hour = 60 * Minute //时
2.2、指针类型
和C语言里的指针一样，指针存储了变量的内存地址并指向变量
- #### 2.2.1、指针的声明
var <指针名称> [指针类型]*
指针类型表示指针要指向什么类型的变量。范例：
var p1 *int //一个执行整数类型的指针 var p2 *string //一个执行字符串类型的指针- #### 2.2.1、指针的赋值
指针存储的是变量的地址，因此应该把变量的内存地址赋给指针，
如何获取变量的内存地址
和C语言里面一样，使用 “&” 这个取址符号来取变量的地址,比如取a变量的内存地址就是>>> “&a”
指针的赋值：
var p1 *int int_a :=10 p1 = &int_a指针执行变量的值
指针存储了变量的内存地址，使用 “*” 号可以将指针指向变量的值，比如上面的赋值范例，使用
*p1就表示执行变量int_a的值，就是10。var p1 *int int_a :=10 p1 = &int_a fmt.Println(*p1)结果为
10指针传入函数
func main() { var p1 *int int_a :=10 p1 = &int_a mac(p1) fmt.Println(int_a) } func mac(p *int){ *p = 20 return }执行结果为
20请注意指针传入函数时，对指针指向的值的改变也会应用到变量中，此时指针指向的值在函数中已经不是局部变量了
（3）、流程控制
3.1、if判断
格式1，简单的判断:
if <条件> {
…执行语言
}
格式2，带else的判断:
if <条件> {
…执行语言
} else {
…执行语句
}格式3，带else if的的判断:
if <条件> {
…执行语言
} else if <条件> {
…执行语句
} else if <条件> {…执行语句
} else {
…执行语句
}else if可以写很多个
3.2、switch判断
if判断中的else if饱受诟病，当然switch就是为解决此来的。switch大体上分为2种写法：
需要注意除非有关键字 fallthrough ，否则在执行一个满足的case条件的语句后，整个语句结束
写法1范例：
var i=0 switch i { case 0: fmt.Println("equa 0") //fallthrough 表示向下执行一个case条件内的语句 case 1： fmt.Println("equa 1") case 3,4,5： fmt.Println("equa 3 or 4 or 5") default: fmt.Println("equa 0") }switch后面有变量，case后面只能是值的形式
写法2范例：
var i=0 switch { case i==0: fmt.Println("equa 0") case i>0： fmt.Println("more than 0") case i<0 && i !=-5： //可以使用逻辑与/或表示多条件 fmt.Println("less than 0 but not equa -5") default: fmt.Println("equa 0") }switch后面无变量，case后面是条件判断的形式
3.3、for循环
- #### 3.3.1、for循环的写法
go的for循环和c语言的十分类似，只是没有小括号，并且需要注意下变量的赋值（以 := 的方式赋值）
格式： for 初始化语句; 条件判断; 变量修改 { 循环语句块 }
范例：
//输出从1到100的整数 for i:=1;i<=100;i++ { //i++相当于i=i+1 fmt.Println(i) }for循环写法二 for 条件判断 {}
此格式多用于无限循环（不是死循环，内部你得有个break跳出循环的关键字和触发此关键字的条件）情况：
//输出从1到100的整数 var i=1 for { fmt.Println(i) i=i+1 if i>100{ break } }- #### 3.3.2、for循环对数组、slice、map、chan的遍历
for循环配合range关键字能实现对数组、slice、map、chan的遍历，使用范例：
var str1="abcde" //字符串是特殊的数组 for i,j:=range str1{ //i表示下标；j表示元素，这里是字符 fmt.Println(i,string(j)) //string将字符转为字符串，否则是ACII码的形式- #### 3.3.3、for循环中的流程控制
break、continue
break表示终止整个循环。continue表示停止本次循环，继续下一次的循环
for i:=0;i<100;i++{ if i == 25 { //i值为25时，停止本次循环，从26开始继续循环 continue } if i > 50{ //i值大于50时，终止循环 break } fmt.Println(i) }上面范例执行后，只输出0到50的整数，除了25
goto 和 label 语句
label是一个大写的英文标识符，通常和goto、continue关键字组合使用来控制程序的流程
func main() { //continue 到label LABEL1: for i := 0; i <= 5; i++ { for j := 0; j <= 5; j++ { if j == 4 { continue LABEL1 回到 LABEL1这个lable，然后向下执行 } fmt.Printf("i is: %d, and j is: %d\n", i, j) } } //goto到label i := 0 HERE: print(i) i++ if i == 5 { return } goto HERE //回到HERE这个lable，然后向下执行。 }
（4）、函数
go中的函数不支持重载，一个包不能有两个名字一样的函数。并且和python一样，函数可以赋给变量： func def1(){...} ... c:=def1 函数def1只是表示了一个内存地址。
4.1、函数的声明
声明语法： ==func 函数名 (参数列表) [(返回值列表)] { …函数体… }==
(返回值列表)是写上返回值的类型（也可以写上形式返回值），函数的参数可以有多个，返回值也一样可以有多个。函数的声明范例如下：
func add() { //简单的函数声明 ... } func add(a int,b int) { //带参数的函数声明 ... } func add(a int,b int) int { //带2个整数参数、带1个整数返回值的函数声明 ... } func add(a ,b int) (int,int){ //带2个整数参数（参数类型相同时，可以简写）、带2个整数返回值的函数声明 ... } func add(a ,b int,c string) str1 sting { //带2个整数参数1个字符串参数，带一个字符串返回值的函数声明。并且函数体中可以将返回值赋予str1 ... }4.2、函数的值参数传递和引用参数传递
无论是值传递，还是引用传递，传递给函数的都是变量的副本，不过，值传递是值的拷贝。引用传递是地址的拷贝，一般来说，地址拷贝更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能
越低。关于值参数传递和引用参数传递的范例：
package main import "fmt" func modify(a int) { //值传递 a = 100 } func modify_ar(a *int) { //引用传递,传入的是指针 *a = 100 //修改指针指向的地址内的值 } func main() { a := 8 fmt.Println(a) //值为8 modify(a) //因为是值传递，函数内为局部变量，因此不会修改全局a变量的值 fmt.Println(a) //值仍然为8 modify_ar(&a) //引用传递，传入的是变量的内存地址，函数体内如果对指向地址内的值修改，则被传入地址的变量值也会改变 fmt.Println(a) //值变为了100 }4.3、go函数的“高级函数”
go函数的形式参数可以为一个函数，需要指定“函数参数”的类型，如 函数的传入参数类型和传出参数类型，只需要类型（int、float32、string）即可
“函数参数”的格式： ==func (参数类型) 返回参数类型==
范例：
func oper (a func(int,int) int,b int,c int) int { //此函数形式参数a的类型为函数类型 return a(b,c) }上面范例只要将符合的传入函数传入oper就可以了，传入函数只要有2个整形参数，并且返回一个整数类型的值就符合要求,比如下面的函数就可以作为传入函数：
func add(a,b int) int { return a+b } result:=oper(add,10,20)使用type自定义数据类型
函数的传入参数为函数时，使用类似“func(int,int) int”的格式表示晓得比较复杂，如果需要的传入函数比较复杂的话，可能要写很长的函数格式，因此可以使用 “type” 关键字来定义一个“函数 ”数据类型
(因为函数也是一种数据类型)：type my_def func(int,int) int //定义一个函数数据类型 func oper (a my_def,b int,c int) int { //此函数形式参数a的类型不是系统自带的类型，而是自定义的my_def类型,而my_def是一个函数数据类型 return a(b,c) }4.4、go函数中的“defer”延缓
go函数体中，有“defer”关键字，关键字后面跟的操作将会暂停执行，在接下来的函数体内其他操作结束后，再来操作defer关键字后面的操作。
func example(a,b int) { defer fmt.Printf("%d",a+b) //遇到defer就暂停后面的操作，等待下面语句的操作完成后再来操作 fmt.Printf("%d+%d=",a,b) } func main(){ example(10,20) }执行结果：
10+20=30上面的范例中，函数在执行时，遇到了defer 关键字，因此 “fmt.Printf(“%d”,a+b)” 暂时不执行，而往下执行下面的“fmt.Printf(“%d+%d=”,a,b)”，执行完后，函数体内没有其他的操作了，再返回去执行defer后面的“defer fmt.Printf(“%d”,a+b)”
如果函数中有多个“defer”关键字，则 最先使用 “defer” 的最后执行
defer的用途
defer使得函数具有延缓执行的特性，非常适合添加在那些程序结束后必须要进行的步骤，比如打开一个文件操作后在最后必须关闭句柄。这在具有多个流程判断的程序中非常好用
//关闭文件句柄 func file_oper(){ file := open(c:\log.txt) defer file.Close() if ... { ... return } ... } //锁资源释放 func read() { mc.Lock() defer mc.Unlock() //其他操作 } //数据库连接释放 func read() { conn := openDatabase() defer conn.Close() //其他操作 }4.5、函数的可变参数
go函数参数可以允许输入任意多个参数，参数的个数是动态的可变的。在函数定义时，形式参数使用“arg…<参数类型>”表示可以传入动态个数的参数，函数体中，传入的参数都存在arg这个数组中。这个和python函数的动态参数
def function1(*a)比较类似，函数体中，所有传入的参数都在a这个元组内可变参数
var sum int func add_args(a int,args...int) int { //第一位置是1个整数类型的参数，后面的参数个数动态随机 for i:=0;i<len(args);i++{ //如何遍历动态参数 sum:=sum+agrs[i] } return a+sum }4.6、匿名函数
不必声明函数的名称，直接声明然后就调用。被传入的参数写在匿名函数最后
func main() { func(a int,b int) { //匿名函数，直接打印结果 fmt.Println(a+b) }(10,20) //传入的参数10和20 }执行结果
30
相关代码
package main
import (
"fmt"
)
type my_def func(int,int) int
func main() {
fmt.Println(oper(sub,90,80))
fmt.Println(args(10,11,12,12,33,40))
func(a int,b int) {
fmt.Println(a+b)
}(10,20)
example(10,20)
}
func sub(a,b int) int{
return a*b
}
func oper(a my_def,b,c int) int {
return a(b,c)
}
func args(a int,args...int) int {
var sum int
for i:=0;i<len(args);i++{
sum=sum+args[i]
}
return a+sum
}
func example(a,b int) {
defer fmt.Printf("%d",a+b) //遇到defer就暂停后面的操作，等待下面语句的操作完成后再来操作
fmt.Printf("%d+%d=",a,b)
}执行结果
7200
118
30
10+20=30
678
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
