golang（3）：strings和strconv使用 & 时间和日期类型 & 指针类型 & 流程控制 & 函数

strings和strconv使用

. strings.HasPrefix(s string, prefix string) bool： // 判断字符串s是否以prefix开头 。
 
. strings.HasSuffix(s string, suffix string) bool： // 判断字符串s是否以suffix结尾。
 
. 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)：                // 去掉字符串首尾空白字符；\n 也会去掉
    strings.Trim(str string, cut string)：        // 去掉字符串首尾cut字符
        func Trim(s string, cutset string) string
            ---> 去掉字符串s中首部以及尾部与字符串cutset中每个相匹配的字符,如:
            ---> s="hello yes",cutset="he",那么s的结果为:"ello yes"
    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转成字符串 <---> fmt.Sprintf("%d",str)
 
. strconv.Atoi(str string)(int, error)：    // 把一个字符串转成整数

示例代码1：

package main
 
import (
    "fmt"
    "strings"
)
 
func urlProcess(url string) string {
    result := strings.HasPrefix(url,"http://")    // strings.HasPrefix(变量,匹配内容) 返回一个 bool 值
    if !result{
    url = fmt.Sprintf("http://%s",url)
    }
    return url
}
 
func pathProcess(path string) string {
    result := strings.HasSuffix(path,"/")   // strings.HasSuffix(变量,匹配内容) 返回一个 bool 值
    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)
 
}
 
// 运行结果：
[root@NEO example01_string01]# go run main/main.go
10.0.0.8/login f:/learning
http://10.0.0.8/login
f:/learning/
[root@NEO example01_string01]# 

# 示例代码2：

package main
 
import (
    "fmt"
    "strings"
    "strconv"
)
 
func main(){
    str := "  hello world abc    \n"
 
    result := strings.Replace(str,"abc","neo",)    // 字符串替换
    fmt.Println("Replace:",result)
 
    count := strings.Count(str,"o")    // 字符串计数
    fmt.Println("Count:",count)
 
    result = strings.Repeat(str,)    // 把字符串重复几次、拼接到一起
    fmt.Println("Repeat:",result)
 
    result = strings.ToLower(str)    // 变成小写
    fmt.Println("ToLower:",result)
 
    result = strings.ToUpper(str)    // 变成大写
    fmt.Println("ToUpper:",result)
 
    result = strings.TrimSpace(str)     // 去掉字符串首尾空白字符；\n 也会去掉
    fmt.Println("TrimSpace:",result)
 
    result = strings.Trim(str," \n\r")    // 去掉字符串首尾 cutset 字符
    fmt.Println("Trim:",result)
 
    result = strings.TrimLeft(str," \n\r")  // 去掉左侧
    fmt.Println("TrimLeft:",result)
 
    result = strings.TrimRight(str," \n\r")  // 去掉右侧
    fmt.Println("TrimRight:",result)
 
    splitResult := strings.Fields(str)    // 以空格为分隔符切割字符串，返回数组
    for i := ; i<len(splitResult);i++ {
    fmt.Printf("fieldsResult[%d]=%s\n",i,splitResult[i])
    }
 
    splitResult = strings.Split(str,"o")  // 以"o"为分隔符切割字符串，返回数组
    for i := ; i<len(splitResult);i++ {
        fmt.Printf("splitResult[%d]=%s\n",i,splitResult[i])
    }
 
    str2 := strings.Join(splitResult,"o")    // 拼接字符串
    fmt.Println("Join:",str2)
 
    str2 = strconv.Itoa()    // 数字转字符串
    fmt.Println("Itoa:",str2)
 
    num,err := strconv.Atoi(str2) // 字符串转数字；有两个返回值
 
    if err != nil {
    fmt.Println("can not convert to int",err)
    return
    }
    fmt.Println("Atoi:",num)
 
}
 
// 编译后执行结果如下：
[root@NEO project]# go build -o bin/example01_string02 go_dev/day03/example01_string02/main
[root@NEO project]# bin/example01_string02
Replace:   hello world neo    
 
Count:
Repeat:   hello world abc
  hello world abc
  hello world abc    
 
ToLower:   hello world abc    
 
ToUpper:   HELLO WORLD ABC    
 
TrimSpace: hello world abc
Trim: hello world abc
TrimLeft: hello world abc    
 
TrimRight:   hello world abc
fieldsResult[]=hello
fieldsResult[]=world
fieldsResult[]=abc
splitResult[]=  hell
splitResult[]= w
splitResult[]=rld abc    
 
Join:   hello world abc    
 
Itoa:
Atoi:
[root@NEO project]# 

Go中的时间和日期类型

. time包
. time.Time类型，用来表示时间
. 获取当前时间， now := time.Now()
. time.Now().Day()，time.Now().Minute()，time.Now().Month()，time.Now().Year()
. 格式化，fmt.Printf(“%02d/%02d/%02d %02d:%02d:%02d”, now.Year()…)
. time.Duration用来表示纳秒
. 一些常量：
    const (
        Nanosecond  Duration =  * Nanosecond
        Microsecond          =  * Nanosecond
        Millisecond          =  * Microsecond
        Second               =  * Millisecond
        Minute               =  * Second
        Hour                 =  * Minute
    )
. 格式化：
    now := time.Now()
    fmt.Println(now.Format(“// ::”))
    fmt.Println(now.Format(“// :”))
    fmt.Println(now.Format(“//”))

示例3：
写一个程序，获取当前时间，并格式化成 2017/06/15 08:05:00 形式
写一个程序，统计一段代码的执行耗时，单位精确到微秒。

// 示例代码如下：
package main
 
import (
    "fmt"
    "time"
)
 
func test_runtime(){
    time.Sleep(time.Millisecond * )      // 停 100 毫秒
}
 
func main (){
    now := time.Now()
    // 方式一
    fmt.Printf("%02d/%02d/%02d %02d/%02d/%02d\n",now.Year(),now.Month(),now.Day(),now.Hour(),now.Minute(),now.Second())
 
    // 方式二： time 自带一个 Format() 函数
    fmt.Println(now.Format("2006-01-02 15:04:05"))
 
    start := time.Now().UnixNano()    // 获取当前时间戳（纳秒级）
    test_runtime()
    end := time.Now().UnixNano()
 
    fmt.Printf("runtime:%d us\n",(end-start)/)
}
 
// 运行结果如下：
[root@NEO example01_string03]# go run main/main.go
// //
-- ::
runtime: us
[root@NEO example01_string03]#

指针类型

. 普通类型，变量存的就是值，也叫值类型
. 获取变量的地址，用&，比如： var a int, 获取a的地址：&a
. 指针类型，变量存的是一个地址，这个地址存的才是值
. 获取指针类型所指向的值，使用：*，比如：var *p int, 使用*p获取p指向的值

示例4：
写一个程序，获取一个变量的地址，并打印到终端。
写一个函数，传入一个int类型的指针，并在函数中修改所指向的值。在main函数中调用这个函数，并把修改前后的值打印到终端，观察结果

// 示例代码如下：
package main
 
import (
    "fmt"
)
 
func pointer_val(p *int){    // 该函数的参数p需要传入一个地址
    *p =     // 修改 指针p 指向的值
}
 
func main(){
    str := "hello world"
    fmt.Println("addr=",&str)
 
    num :=
    var p *int       // 声明一个 int 类型的指针；p 里面存的是地址
    p = &num   // 给指针类型的变量赋值时，需要赋值一个地址（&变量）；取出指针 p 所指向的值 ---> *p
    fmt.Println("p=",p)
    fmt.Println("pointer_val_before=",*p)
    pointer_val(p)    // p 参数是一个地址
    fmt.Println("pointer_val_after=",*p)
}
 
// 运行结果如下：
[root@NEO example03_pointer01]# go run main/main.go
addr= 0xc0000101e0
p= 0xc0000120b0
pointer_val_before=
pointer_val_after=
[root@NEO example03_pointer01]# 

流程控制

# if语句：
// 1、
if condition1 {
}
 
// 2、
if condition1 {
 
} else {
 
}
 
// 3、
if condition1 {
 
} else if condition2 {
 
} else if condition3 {
} else {
}
 
# switch case 语句
// 语法：
switch var {     // var 就变量
case var1:
case var2:
case var3:
default:
}
 
// 形式1：
var i =
switch i {
case :
    fallthrough        // fallthrough 具有 穿透 的作用
case :
    fmt.Println(“”)    // go  switch 的 case 后不需要加 break
case ,,,:
    fmt.Println(“”)
default:
     fmt.Println(“def”)
}
 
// 形式2：
var i =
switch {
case i >  && i < :
    fmt.Println(“i >  and i < ”)
case i >  && i < :
    fmt.Println(“i >  and i < ”)
default:
    fmt.Println(“def”)
}

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

// 示例代码：
package main
 
import (
    "fmt"
    "math/rand"
)
 
func main(){
   var n int
   n = rand.Intn()    // 生成随机数
 
   for {
    flag := false
    var input int
    fmt.Scanf("%d\n",&input)   // %d\n --> 以 换行作为分隔符
 
    switch {
    case input == n:
        fmt.Println("you are right")
        flag = true
    case input > n:
        fmt.Println("bigger")
    default:
        fmt.Println("smaller")
    }
    if flag {
        break
    }
   }
 
} 

for 语句

// 方式一：
for 初始化语句; 条件判断; 变量修改 {
 
}
 
// 方式二：
for  条件 {
}
 
// 方式三：for range 语句 --> 用来遍历数组、slice、map、chan
str := "hello world,中国"
for i, v := range str {        // i表示下标， v 表示值
    fmt.Printf("index[%d] val[%c] len[%d]\n", i, v, len([]byte(string(v))))        // len([]byte(string(v))) --> 表示字符的长度
}
 
// 方式四：
str := “hello world,中国”
for i, v := range str {
    if i >  {
         continue
    }
    if (i > ) {
         break
    }
    fmt.Printf(“index[%d] val[%c] len[%d]\n”, i, v, len([]byte(string(v))))
}
 
// 方式五：goto 和 label 语句
// label语句1：
package main
import "fmt"
func main() {
LABEL1:            // label语法 ---> 字符:
    for i := ; i <= ; i++ {
        for j := ; j <= ; j++ {
            if j ==  {
                continue LABEL1        // 会跳转到 LABEL1 处继续执行
            }
            fmt.Printf("i is: %d, and j is: %d\n", i, j)
        }
    }
}
 
// goto label 语句2：
package main
 
func main() {
    i :=
HERE:
    print(i)
    i++
    if i ==  {
        return
    }
    goto HERE    // 会跳转到 HERE 处继续执行 ； 此 goto label 实现了一个 for 循环 （只能在同一个函数中跳转）
}

示例5：写一个程序，在终端打印如下图形
A
AA
AAA
AAAA
AAAAA

// 示例代码如下：
package main
 
import (
    "fmt"
)
 
func print(n int) {
 
    for i := ; i < n; i++ {
        for j := ; j < i; j++ {
            fmt.Printf("A")
        }
        fmt.Println()
    }
}
 
func main() {
    print()
}

示例6：（上述的方式三）

// 示例代码：
package main
 
import "fmt"
 
func main() {
    str := "hello world,中国"
    for i, v := range str { // i表示下标， v 表示值
        fmt.Printf("index[%d] val[%c] len[%d]\n", i, v, len([]byte(string(v)))) // len([]byte(string(v))) --> 表示字符的度
    }
}
 
// 运行结果如下：
[root@NEO example04_for01]# go run main/main.go
index[] val[h] len[]
index[] val[e] len[]
index[] val[l] len[]
index[] val[l] len[]
index[] val[o] len[]
index[] val[ ] len[]
index[] val[w] len[]
index[] val[o] len[]
index[] val[r] len[]
index[] val[l] len[]
index[] val[d] len[]
index[] val[,] len[]
index[] val[中] len[]
index[] val[国] len[]
[root@NEO example04_for01]#

函数

golang函数特点：
// a. 不支持重载，一个包不能有两个名字一样的函数
// b. 函数是一等公民，函数也是一种类型，一个函数可以赋值给变量
// c. 匿名函数
// d. 多返回值

示例7：自定义一种函数类型，作为参数传入另一个函数的参数

package main
 
import "fmt"
 
type calc_func func(int, int) int    // type --> 自定义一种类型 calc_func：calc_func 是函数类型，该类型有两个参数均为 int，返回值也是 int
 
func add(a int, b int) int {
    return a + b
}
 
func operator(op calc_func,a int, b int) int {    // op 参数为自定义的 函数类型；函数当作参数传给另一个函数
    return op(a,b)
}
 
func main(){
    c := add
    fmt.Println(c)    // c 是函数 add 的内存地址
    sum := operator(c,,)
    fmt.Println(sum)
}
 
// 运行结果如下：
[root@NEO example05_func01]# go run main/main.go
0x487170
 
[root@NEO example05_func01]#

函数参数传递方式：

1). 值传递
2). 引用传递
注意1：无论是值传递，还是引用传递，传递给函数的都是变量的副本，不过，值传递是值的拷贝。引用传递是地址的拷贝，一般来说，地址拷贝更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能越低。
注意2：map、slice、chan、指针、interface默认以引用的方式传递

函数命名返回值的名字，如下：

func add(a, b int) (c int) {    // c 就是返回值
    c = a + b
    return
}
 
func calc(a, b int) (sum int, avg int) {
    sum = a + b
    avg = (a +b)/
    return
}

_ 标识符，用来忽略返回值，如下：

func calc(a, b int) (sum int, avg int) {
    sum = a + b
    avg = (a +b)/
    return
}
func main() {
    sum, _ := calc(, )
}

函数的可变参数，如下：

func add(arg…int) int {        // 0个或多个参数
}
 
func add(a int, arg…int) int {        // 1个或多个参数
}
 
func add(a int, b int, arg…int) int {        // 2个或多个参数
}
 
// 注意：其中arg是一个slice（切片，可理解成数组/列表），我们可以通过arg[index]依次访问所有参数，通过len(arg)来判断传递参数的个数

示例8：
写一个函数add，支持1个或多个int相加，并返回相加结果
写一个函数concat，支持1个或多个string相拼接，并返回结果

// 示例代码如下：
package main
 
import "fmt"
 
func add(a int,arg...int) (sum int){
    sum += a
    for i := ; i < len(arg); i++{
    sum += arg[i]
    }
    return
}
 
func concat(s string,arg...string)(result string){
    result += s
    for i := ; i < len(arg); i++{
        result += arg[i]
    }
    return
}
 
func main(){
    sum := add(,)
    fmt.Println(sum)
    sum = add(,,)
    fmt.Println(sum)
 
    result := concat("hello"," world")
    fmt.Println(result)
    result = concat("hello"," world"," neo")
    fmt.Println(result)
}
 
// 运行结果如下：
[root@NEO example05_func02]# go run main/main.go
 
hello world
hello world neo
[root@NEO example05_func02]# 

函数 defer：

// 1. 当函数返回时，执行defer语句。因此，可以用来做资源清理
// 2. 多个defer语句，按先进后出的方式执行 （栈）
// 3. defer语句中的变量，在defer声明时就决定了。

示例代码：

package main
 
import "fmt"
 
func a(){
    i :=
    defer fmt.Println("func a defer",i)   // 执行这个声明的时候，i 的值已经确实为0，此时语句还没有执行，该语句是在函数返的时候才执行
    i++
    fmt.Println("func a",i)    // 先执行这行代码的 Println，再执行 defer 中的 Println
}
 
func f(){
    for i := ; i < ; i++ {
    defer fmt.Println("func f defer",i)    // 先执行后面的 defer 语句
    }
}
 
func main(){
    a()
    f()
}
 
// 运行结果如下：
[root@NEO example05_defer]# go run main/main.go
func a
func a defer
func f defer
func f defer
func f defer
[root@NEO example05_defer]#
 
// defer用途（伪代码）：
// 1. 关闭文件句柄
 
func read() {
    //文件操作
    file := open(filename)
    defer file.Close()
}
 
// 2. 锁资源释放
func read() {
    mc.Lock()
    defer mc.Unlock()
}
 
// 3. 数据库连接释放
func read() {
    conn := openDatabase()
    defer conn.Close()
}

示例题：

1. 编写程序，在终端输出九九乘法表。

// 示例代码：
package main
 
import "fmt"
 
func multi() {
    for i := ; i <= ; i++{
    for j :=; j<=i; j++ {
        fmt.Printf("%d*%d=%d ",j,i,i*j)
    }
    fmt.Println()
    }
}
 
func main(){
    multi()
}

2. 一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3。编程找出1000以内的所有完数。

package main
 
import "fmt"
 
func perfect(n int) bool {
    var sum int
    for i :=; i < n; i++{
    if n%i ==  {
        sum += i    // 把该数的所有因子加起来
    }
    }
   return n == sum
}
 
func process(n int){
    for i := ; i <= n; i++{
        if perfect(i){
            fmt.Println(i)
        }
    }
}
 
func main(){
    var n int
    fmt.Scanf("%d",&n)
 
    process(n)
}

3. 输入一个字符串，判断其是否为回文。回文字符串是指从左到右读和从右到左读完全相同的字符串。

// 示例代码：
package main
 
import "fmt"
 
func process(s string) bool {
    for i := ; i < len(s)/; i++{  // 从字符串的两边向中间靠拢
    if s[i] != s[len(s)--i]{
        return false
    }
    }
    return true
}
 
func main(){
    var s string
    fmt.Scanf("%s\n",&s)
 
    result := process(s)
    if result {
    fmt.Printf("%s is huiwen\n",s)
    } else {
    fmt.Printf("%s not huiwen\n",s)
    }
}

4. 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

package main
 
import (
    "fmt"
    "bufio"
    "os"
)
 
func count(s string) (charCount, spaceCount, numCount, otherCount int){
    t := []rune(s)  // 转换类型
 
    for _,v := range t {
    switch {
        case v >= 'A' && v <= 'z':      // 比较是在 ASCII 中的位置数字； byte 型的只能用单引号
        charCount++
        case v == ' ':
        spaceCount++
        case v >= '' && v <= '':
        numCount++
        default:
        otherCount++
    }
    }
    return
}
 
func main (){
    reader := bufio.NewReader(os.Stdin)      // bufio.NewReader() 实例化一个对象；os.Stdin 标准输入
    result, _, err := reader.ReadLine()    // 从终端读取输入；返回的第一个参数 (result) 是 []byte
    if err != nil {
    fmt.Println("Read from console err:",err)
    return
    }
 
    fmt.Println(result)
 
    cc, sc, nc, oc := count(string(result))    // 先把 result 转换成 string 类型
    fmt.Printf("word count:%d\n space count:%d\n number count:%d\n others count:%d\n",cc,sc,nc,oc)
}
 
// byte 等同于int8，常用来处理ascii字符
// rune 等同于int32,常用来处理unicode或utf-8字符
 
// 运行结果如下：
[root@NEO example06_count]# go run main/main.go
hello -=
[          ]
word count:
 space count:
 number count:
 others count:
[root@NEO example06_count]# 

5. 计算两个大数相加的和，这两个大数会超过int64的表示范围.

package main
 
import (
    "fmt"
)
 
func fillZero(s string, n int)string{
    var res string = s
    for i:=; i<=n; i++{
    res = fmt.Sprintf("%c%s",'',res)
    }
    return res
}
 
func plus(a string, b string) string {
    var index,carry,length int       // index 表示从右开始的个数； carry 表示进位（相加满十进一）；length 表示两个数字字符长度
    var str_plus string
 
    // 长度小的在前面填充 0
    len1 := len(a)
    len2 := len(b)
 
    if (len1== && len2==){
    return ""
    }
 
    switch {
    case len1 > len2:
        n := len1 - len2
        res := fillZero(b,n)
        b = res
        length = len1
    case len1 < len2:
        n := len2 - len1
            res := fillZero(a,n)
            a = res
        length = len2
    default:
        length = len1
    }
 
    // 各位相加
    for (index <= length-) {
    byte_a := a[length--index] - ''    // 数字对应的字符 减去 '0' 字符，就是该数字的值；uint8 类型
    byte_b := b[length--index] - ''
 
    sum := int(byte_a) + int(byte_b) + carry
 
    if sum >=  {
        carry =
    } else {
        carry =
    }
 
     byte_new := (sum % ) + ''
    str_plus = fmt.Sprintf("%c%s",byte_new,str_plus)
    index++
    }
    if carry == {
    str_plus = fmt.Sprintf("1%s",str_plus)
    }
    return str_plus
}
 
func main(){
    var a, b string
    fmt.Scanf("%s %s\n",&a, &b)
 
    res_plus := plus(a,b)
    fmt.Println(res_plus)
}