go 基础（二）

strings和strconv使用

1、strings使用

• strings.HasPrefix(s string, prefix string) bool：判断字符串s是否以prefix开头。
• strings.HasSuffix(s string, suffix string) bool：判断字符串s是否以suffix结尾。

上面两个函数代码样例：

package main

import(
	"fmt"
	"strings"
)

func urlProcess(url string) string{
	result := strings.HasPrefix(url, "http://")
	if !result{
		url = fmt.Sprintf("http://%s", url)
	}
	return url
}

func pathProcess(path string) string{
	result := strings.HasSuffix(path, "/")
	if !result{
		path = fmt.Sprintf("%s/", path)
	}
	return path
}

func main () {
	var(
		url string
		path string
	)
	fmt.Scanf("%s%s", &url, &path)
	url = urlProcess(url)
	path = pathProcess(path)
	fmt.Println(url)
	fmt.Println(path)
}

• 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)：字符串替换，如果n<0会替换所有
• strings.Count(str string, substr string)int：字符串计数
• strings.Repeat(str string, count int)string：重复count次str
• strings.ToLower(str string)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, cut string)：去掉字符串首cut字符
• strings.Fields(str string)：返回str空格分隔的所有子串的slice
• strings.Split(str string, split string)：返回str split分隔的所有子串的slice
• strings.Join(s1 []string, sep string)：用sep把s1中的所有元素链接起来

package main

import (
	"strings"
	"fmt"
)

func main(){
	str := "hello world "
	str1 := "   hello world abc    
"
	result := strings.Replace(str, "world", "you", 1)
	fmt.Println("Replace:", result)

	count := strings.Count(str, "l")
	fmt.Println("Count:", count)

	result = strings.Repeat(str, 3)
	fmt.Println("Repeat:", result)

	result = strings.ToLower(str)
	fmt.Println("ToLower:", result)

	result = strings.ToUpper(str)
	fmt.Println("ToUpper:", result)

	result = strings.TrimSpace(str1)
	fmt.Println("TrimSpace:", result)

	result = strings.Trim(str1, "

")
	fmt.Println("Trim:", result)

	result = strings.TrimLeft(str1, " ")
	fmt.Println("TrimLeft:", result)

	result = strings.TrimRight(str1, "

")
	fmt.Println("TrimRight:", result)

	splitResult := strings.Fields(str)
	for i := 0; i < len(splitResult); i ++ {
		fmt.Println("Fields:", splitResult[i])
	}

	splitResult = strings.Split(str, "l")
	for i := 0; i < len(splitResult); i ++ {
		fmt.Println("Split:", splitResult[i])
	}

	joinResult := strings.Join(splitResult, "l")
	fmt.Println("Join:", joinResult)
}

2、strconv使用

• strconv.Itoa(i int)：把一个整数i转成字符串
• strconv.Atoi(str string)(int, error)：把一个字符串转成整数

package main

import (
	"fmt"
	"strconv"
)

func main(){
	str2 := strconv.Itoa(1000)
	fmt.Println("Itoa:", str2)

	number, err := strconv.Atoi(str2)
	if err != nil {
		fmt.Println("can not convert to int", err)
	}
	fmt.Println("Atoi:", number)
}

时间和日期类型

1、time包

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

const (
    Nanosecond  Duration = 1
    Microsecond = 1000 * Nanosecond
    Millisecond  = 1000 * Microsecond
    Second = 1000 * Millisecond
    Minute  = 60 * Second
    Hour  = 60 * Minute
)

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

• time.Now().Day()，time.Now().Minute()，time.Now().Month()，time.Now().Year()

func testTime() {
	for {
		now := time.Now()
		fmt.Printf("type of now is:%T
", now)

		year := now.Year()
		month := now.Month()
		day := now.Day()

		str := fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d
", year, month, day, now.Hour(), now.Minute(), now.Second())
		fmt.Println(str)
		time.Sleep(time.Second)

		fmt.Printf("timestamp:%d
", now.Unix())
	}
}

4、time.Duration用来表示纳秒

package main

import (
	"time"
	"fmt"
)

func test(){
	time.Sleep(time.Millisecond * 100)
}

func main() {
	now := time.Now()
	fmt.Println(now)
	fmt.Println(now.Format("2006/01/02 15:04:05"))  // 获取当前时间
	start := time.Now().UnixNano()
	test()
	end := time.Now().UnixNano()
	fmt.Printf("cost:%d", (end - start)/1000) // 统计一段代码的执行耗时，单位精确到微秒。
}

5、格式化，强制写下面时间，这个是go诞生时间

now := time.Now()
fmt.Println(now.Format(“02/1/2006 15:04:05”))
fmt.Println(now.Format(“02/1/2006 03:04:05”))
fmt.Println(now.Format(“2006/1/02 15:04:05”))
fmt.Println(now.Format(“2006/1/02”))

指针类型

1、普通类型，变量存的就是值，也叫值类型。指针类型存的是地址

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

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

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

 

 5、声明一个指针类型，默认初始化nil

var p *int 

直接赋值*p = 200会报错，它是一个空指针，这个时候可以理解为它只是放入一个地址，它初始值是nil。

nil在Go中相当与其它语言中的NULL、null和None等，在实际的使用中表示某一个变量为空。nil只能赋值给指针、channel、func、interface、map或slice类型的变量。如果将nil赋值给其他变量的时候将会引发panic。

两种方式使用：

方式一：

var p *int
var b int
p = &b
*p = 200

这种方式是将b的内存地址赋值给p，实际上p和b共用一个内存地址的值。因为b声明时默认它的值是0

方式二：

p = new(int)
*p = 1000

使用new关键字分配内存，这种方式*p的默认值是0。

• demo

func test() {
	var p *int //p 默认初始化nil
	var b int
	p = &b
	*p = 200 //b = 200
	
	if (p == &b) {
		fmt.Printf("equal
")
	}

	fmt.Printf("%p %p %p
", p, &b, &p)

	p = new(int)
	fmt.Println(*p)
	*p = 1000
	fmt.Printf("%d
", *p)
	fmt.Printf("%p %p %p
", p, &b, &p)

	if (p == &b) {
		fmt.Printf("equal")
	}

	//指针类型的变量初始化：1. 使用其他变量地址给它赋值。 2. 使用new分配
}

流程控制

1、if / else 分支判断

写法一：

if condition1 {
}

写法二：

if condition1 {
} else {
}

写法三：

if condition1 {
} else if condition2 {
} else if condition3 {
} else {
}

package main

import (
	"strconv"
	"fmt"
)

func main() {
	var str string
	fmt.Scanf("%s", &str)

	number, err := strconv.Atoi(str)
	if err != nil {
		fmt.Println("can not convert to int", err)
		return
	}
	fmt.Println("Atoi:", number)
}

2、switch case语句（不需要break）

语法：

switch var {
case var1:
case var2:
case var3:
default:
}

关键字fallthrough，可以让满足条件分支执行后，继续执行下一个分支。

package main

import "fmt"

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

样例：

package main

import (
	"math/rand"
	"fmt"
)

func main() {
	/*
	随机生成一个0到100的整数n，然后用户在终端，输入数字，如果和n相等，则提示用户猜对了。如果不相等，则提示用户，大于或小于n
	 */
	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")
			flag = true
		case input > n:
			fmt.Println("bigger")
		case input < n:
			fmt.Println("less")
		}
		if flag{
			break
		}
	}
}

3、for 语句

写法一：

for 初始化语句; 条件判断; 变量修改 {
}

package main

import "fmt"

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

func main() {
	Print(6)
}

写法二：

for 条件 {
}

写法三：

for range 语句

func Range(){
	str := "hello world,中国"
	for i, v := range str {
		fmt.Printf("index[%d] val[%c]
", i, v)
	}
}

写法四：break continue语句

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

写法五： 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)
		}
	}
}

4、goto和label 语句

package main

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

go使用中遇到的问题总结

https://segmentfault.com/a/1190000002808365