go 学习之路

Posted 2020-10-31 人生苦短，我用python

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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\n", (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")
	}
}

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\n", &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：终端打印如下图形

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]\n", 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\n", 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，先进后出方式执行(栈)

example：关闭文件句柄

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

以上是关于go 学习之路的主要内容，如果未能解决你的问题，请参考以下文章

《Go语言精进之路》读书笔记 | 使用Go语言原生编码思维来写Go代码

Go 学习之路：Println 与 Printf 的区别

《Go语言精进之路》读书笔记 | 理解Go语言代码块与作用域

[原创]java WEB学习笔记61：Struts2学习之路--通用标签 property，uri，param,set,push,if-else,itertor,sort,date,a标签等(代码片段

《Go语言精进之路》读书笔记 | 使用无类型常量简化代码