go 学习之路（三）

一、strings和strconv使用

1、strings.HasPrefix(s string,prefix string) bool :判断字符串s是否以prefix开头

2、stings.HasSuffix(s string,suffix string) bool:判断字符串s是否以suffix结尾

3、strings.Index(s string,str string) int: 判断str在s中首次出现的位置，如果没有，返回-1

4、strings.LastIndex(s string,str string) int:判断str在s中最后出现的位置，如果没有，返回-1

5、strings.Replace(str string, old string, new string, n int)：字符串替换

6、strings.Count(str string, substr string)int：字符串计数

7、strings.Repeat(str string, count int)string：重复count次str

8、strings.ToLower(str string)string：转为小写

9、strings.ToUpper(str string)string：转为大写

package main

import (
	"fmt"
	"strings"
)

//判断字符串以xx开头
func judge_prefix(str string) string {
	var str_change string
	if strings.HasPrefix(str, "http://") == false {
		str_change = "http://" + str
	}
	return str_change
}

//判断字符串以xx结尾
func judge_suffix(str string) string {
	var str_change string
	if strings.HasSuffix(str, "/") == false {
		str_change = str + "/"
	}
	return str_change
}

//字符串中s首次出现的位置，没有返回-1
func str_index(str string, show_str string) int {
	result := strings.Index(str, show_str)
	return result
}

//字符串替换，n代表字符串出现第一次，-1表示全部替换
func replace(str string, old string, new string, n int) string {
	result := strings.Replace(str, old, new, n)
	return result
}

//字符串中出现某字符串的次数
func count(str string, substr string) int {
	result := strings.Count(str, substr)
	return result
}

func main() {
	url := judge_prefix("baidu.com")
	path := judge_suffix("go_dev")
	index := str_index("llohehe", "he")
	replace := replace("hellohehe", "he", "wo", -1)
	count := count("hellohehe", "he")
	fmt.Println("url", url)
	fmt.Println("path", path)
	fmt.Println("index", index)
	fmt.Println("replace", replace)
	fmt.Println("count", count)
}

　　

strings.TrimSpace(str string)：去掉字符串首尾空白字符
strings.Trim(str string, cut string)：去掉字符串首尾cut字符
strings.TrimLeft(str string, cut string)：去掉字符串首cut字符
strings.TrimRight(str string, cut string)：去掉字符串首cut字符
strings.Field(str string)：返回str空格分隔的所有子串的slice
strings.Split(str string, split string)：返回str split分隔的所有子串的slice
strings.Join(s1 []string, sep string)：用sep把s1中的所有元素链接起来
strconv.Itoa(i int)：把一个整数i转成字符串
strconv.Atoi(str string)(int, error)：把一个字符串转成整数

package main

import (
	"fmt"
	"strings"
	"strconv"
)

//去空格
func removeSpace(str string) string {
	result := strings.TrimSpace(str)
	return result
}

//字符串首尾remove某字符
func removeStr(str string, cut string) string {
	result := strings.Trim(str, cut)
	return result
}

func removeLeft(str string, cut string) string {
	result := strings.TrimLeft(str, cut)
	return result
}

func main() {
	removeSpace := removeSpace("  xxx  ")
	removeStr := removeStr("abbaaaaaaacdab", "ab")
	removeLeft := removeLeft("abbacdab", "ab")
	strSplit("abc,def,ghi", ",")
	fmt.Println(removeSpace)
	fmt.Println(removeStr)
	fmt.Println(removeLeft)
	splitResult := strings.Split(str,"l")
	str2 = strings.Join(splitResult,"l")
	str2 = strconv.Itoa(1000)
	number,err := strconv.Atoi(str2)
	if err != nil{
		fmt.Println("can not convert to int",err)
	}
}

　　

时间和日期类型

1、time包

2、time.Time类型，用来表示时间

3、获取当前时间，now  :=time.Now()

4、time.Now().Day()，time.Now().Minute()，time.Now().Month()，time.Now().Year()

5、格式化，fmt.Printf(“%02d/%02d%02d %02d:%02d:%02d”, now.Year()…)

example：获取当前时间，并格式化成2018/04/07 16:09:00格式

package main

import (
	"fmt"
	"time"
)

func main() {
	now := time.Now()
	fmt.Println(now.Format("2006/01/02 15:04:05"))
}

　

example：获取程序执行时间

package main

import (
	"fmt"
	"time"
)

func test() {
	time.Sleep(time.Millisecond * 100)
}
func main() {
	start := time.Now().UnixNano()
	test()
	end := time.Now().UnixNano()
	fmt.Printf("cost:%d us
", (end-start)/1000)
}

　　

指针类型

1、普通类型，变量存的就是值，也叫值类型

2、获取变量的地址，用&，比如： var a int, 获取a的地址：&a

3、指针类型，变量存的是一个地址，这个地址存的才是值

4、获取指针类型所指向的值，使用：*，比如：var *p int, 使用*p获取p指向的值

package main

import (
	"fmt"
)

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

	var p *int //p是指针，存的是地址
	p = &a // p=a的地址
	*p = 100 //a的地址所指向的值赋值100
	fmt.Println(a) //a输出100
}

　　

流程控制

1、if / else分支判断

package main

import (
	"fmt"
)

func main() {
	bool1 := true
	if bool1 {
		fmt.Printf("the value is true")
	} else {
		fmt.Printf("the value is false")
	}
}

　

if的条件可以赋值，赋值的变量作用域就在这个if语句里

if contents, err := ioutil.ReadFile(filename); err != nil {
	fmt.Println(err)
} else {
	fmt.Printf("%s
", contents)
}

example：从终端读取输入，并转成整数，如果转成整数出错，则输出错误，否则输出该整数

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var str string
	fmt.Scanf("%s", &str)
	number, err := strconv.Atoi(str)
	if err != nil {
		fmt.Println("conver failed,err:", err)
		return
	}
	fmt.Println(number)
}

　　

2、switch case语法

switch var{

　　case var1：

　　case var2：

　　case var3：

　　default：

}

package main

import (
	"fmt"
)

func main() {
	var a int = 10
	switch a {
	case 0:
		fmt.Println("a is equal 0")
	case 10:
		fmt.Println("a is equal 10")
	default:
		fmt.Println("a is equal default")
	}
}

　　

fallthrough穿透执行

example：猜数字，写一个程序，随机生成一个0到100的整数n，然后用户在终端输入数字，如果和n相等，则提示用户猜对了。如果不相等，则提示用户，大于或小于n

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	var n int
	n = rand.Intn(100)
	for {
		var input int
		fmt.Scanf("%d
", &input)
		flag := false
		switch {
		case input == n:
			fmt.Println("you are right")
			break
			flag = true
		case input > n:
			fmt.Println("bigger")
		case input < n:
			fmt.Println("less")
		}
		if flag {
			break
		}
	}
}

　　

for

写法1 for 初始化语句；条件判断；变量修改

example：终端打印如下图形

A

AA

AAA

AAAA

AAAAA

package main

import (
	"fmt"
)

func Print(n int) {
	for i := 1; i < n+1; i++ {
		for j := 0; j < i; j++ {
			fmt.Printf("A")
		}
		fmt.Println()
	}
}

func main() {
	Print(10)
}

　　

写法2：for 条件{

}

写法3：for range 语法

package main

import (
	"fmt"
)

func main() {
	str := "hello,world,中国"
	for i, v := range str {
		if i > 2 {
			continue
		}
		if i > 3 {
			break
		}
		fmt.Printf("index[%d] val[%c] len[%d]
", i, v, len([]byte(string(v))))
	}

}

　　

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
", i, j)
		}
	}
}

package main

import (
	"fmt"
)

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

　　

函数

申明语法

func 函数名  （参数列表） 返回值  { }

golang函数特点：

　　不支持重载，一个包不能有两个名字一样的函数

　　函数是一等公民，函数也是一种类型，一个函数可以赋值给变量

　　匿名函数

　　多返回值

example1：

package main

import (
	"fmt"
)

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

func main() {
	c := add //函数赋值给变量
	fmt.Println(c)
	sum := c(10, 20)
	fmt.Println(sum)
}

　　

example2：定义函数类型

package main

import (
	"fmt"
)

type add_func func(int, int) int

func sub(a, b int) int {
	return a - b
}

func operator(op add_func, a, b int) int {
	return op(a, b)
}

func main() {
	c := sub
	fmt.Println(c)
	sum := operator(c, 100, 200)
	fmt.Println(sum)
}

　　

函数参数传递方式：

　　map、slice、chan、指针、interface默认引用方式传递

函数能对返回值命名

可变参数

example：支持一个或多个int相加或string拼接

func add(a int, arg ...int) int {
	var sum int
	sum += a
	for i := 0; i < len(arg); i++ {
		sum += arg[i]
	}
	return sum
}

func content(a string, arg ...string) string {
	var result string = a
	for i := 0; i < len(arg); i++ {
		result += arg[i]
	}
	return result
}

func main() {
	// result := add(10, 3, 4)
	result := content("hello", " ", "world")
	fmt.Println(result)
}

　　

defer用途：

　　当函数返回时，执行defer语句，用来资源清理

　　多个defer，先进后出方式执行(栈)

defer在函数结束时才被执行，不合理的使用方式会浪费更多资源

案例：循环处理多个日志文件时，导致文件关闭时间延长

package main

import (
	"log"
	"os"
	"fmt"
)

func main(){
	for i:=0;i<1000;i++{
		path := fmt.Sprintf("./log/%d.txt",i)

		f,err :=os.Open(path)
		if err != nil {
			log.Println(err)
			continue
		}
		defer f.Close()
	}
}

关闭操作只有在main函数结束后才会执行，并不是每一次循环结束后执行

将循环和处理分离

package main

import (
	"fmt"
	"log"
	"os"
)

func main() {
	do := func(n int) {
		path := fmt.Sprintf("./log/%d.txt", n)

		f, err := os.Open(path)
		if err != nil {
			log.Println(err)
		}
		defer f.Close()
	}

	for i := 0; i < 1000; i++ {
		do(i)
	}
}

　　

example：关闭文件句柄

func read() {
	file :=open(filename)
	defer file.close()
}

　　

package main

import (
	"fmt"
)

func test() []func() {
	var s []func()
	for i := 0; i < 2; i++ {
		s = append(s, func() { //将多个匿名函数添加到列表
			fmt.Println(i)
		})
	}
	return s //返回匿名函数列表
}

func main() {
	for _, f := range test() { //迭代执行所有的匿名函数
		f()
	}
}

　　

上述代码输出

2
2

　　

添加匿名函数到列表时并未执行，当main执行这些函数时，读取得是环境变量i最后一次循环的值，i=2，内存地址一样

package main

import (
	"fmt"
)

func test() []func() {
	var s []func()
	for i := 0; i < 2; i++ {
		x := i　　//x每次循环都重新定义，并不是重新赋值
		s = append(s, func() { //将多个匿名函数添加到列表
			fmt.Println(x)
		})
	}
	return s //返回匿名函数列表
}

func main() {
	for _, f := range test() { //迭代执行所有的匿名函数
		f()
	}
}

　　

输出

0
1

　　

内存地址不一样

错误处理

package main

import (
	"errors"
	"fmt"
	"log"
)

var errDivByZero = errors.New("division by zero")

func div(x, y int) (n int, err error) {
	if y == 0 {
		return 0, errDivByZero
	}
	return x / y, nil
}
func main() {
	z, err := div(5, 2)
	if err == errDivByZero {
		log.Fatalln(err)
	}
	fmt.Println(z)
}