go 基础（二）

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Go›Go教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

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    \n"
	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, "\n\r")
	fmt.Println("Trim:", result)

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

	result = strings.TrimRight(str1, "\n\r")
	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\n", now)

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

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

		fmt.Printf("timestamp:%d\n", 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\n")
	}

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

	p = new(int)
	fmt.Println(*p)
	*p = 1000
	fmt.Printf("%d\n", *p)
	fmt.Printf("%p %p %p\n", 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\n", &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]\n", 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]\n", 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\n", 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

鲜花

握手

雷人

路过

鸡蛋

该文章已有0人参与评论

请发表评论

全部评论

专题导读

More+

Go语言从入门到放弃(设置 go get 为国内源)发布时间：2022-07-10

60_Go基础_1_27字符串常用方法发布时间：2022-07-10

客服电话

电子邮件

go 基础（二）

strings和strconv使用

时间和日期类型

指针类型

流程控制

go使用中遇到的问题总结

请发表评论

全部评论

上一篇：

下一篇：

关于我们

产品与服务

解决方案

139-2527-9053