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 \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
}
