Go基础（2）

demo1:

package main

import (
    "fmt"
    "strings"
)

func main() {
    url := pathtourl("www.baidu.com", "https")
    isurl(url)

}

func isurl(url string) {
    http := strings.hasprefix(url, "http://")
    https := strings.hasprefix(url, "https://")
    if http || https {
        fmt.printf("%s 是一个url", url)
    } else {
        fmt.printf("%s 不是一个url", url)
    }
}

func pathtourl(path string, protocol string) string {
    var result string
    if protocol == "http" || protocol == "https" {
        result += protocol
        result += "://"
        result += path
        return result
    } else {
        return ""
    }
}

分析：

1.字符串的基本使用

2.strings包还有其他的一些函数，会在下面介绍

 

demo2:

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func main() {
    str := " hello world hahaha "

    result1 := strings.replace(str, "world", "earth", 1)
    fmt.println(result1) // hello earth hahaha

    result2 := strings.count(str, "ha")
    fmt.println(result2) //3

    result3 := strings.toupper(str)
    fmt.println(result3) // hello world hahaha

    result4 := strings.trimspace(str)
    fmt.println(result4) //hello world hahaha

    result5 := strings.fields(str)
    fmt.println(result5) //[hello world hahaha]

    result6 := strings.join(result5, "0")
    fmt.println(result6) //hello0world0hahaha

    result7 := strconv.itoa(666)
    fmt.println(result7) //666

    result8, err := strconv.atoi("666")
    if err != nil {
        fmt.println("can not convert to int：", err)
    }
    fmt.println(result8) //666
}

分析：

1.一些字符串的基本操作

2.其他的功能直接查文档即可，很简单

 

demo3:

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.now().unixnano()
    now := time.now()
    thetime := now.format("2006/01/02 15:05:05")
    fmt.println(thetime) //2019/03/25 14:07:07
    end := time.now().unixnano()
    fmt.printf("程序共耗时：%d微秒", (end-start)/1000)
}

分析：

1.格式化函数format，必须使用2006/01/02 15:05:05这个日期，go规定的

2.这里统计程序运行时间的方法，在日后开发中会经常用到

 

demo4

package main

import "fmt"

func main() {
    var a int = 10
    fmt.printf("%d\n", a) //10

    var p *int = &a
    fmt.printf("%d->%d\n", p, *p) //824633794696->10

    var b int = 5
    //*p = b
    //fmt.println(a) //5

    p = &b
    fmt.println(a) //10

    modify(p)
    fmt.printf("a:%d b:%d\n", a, b) //a:10 b:666

    modify(&a)
    fmt.printf("a:%d b:%d\n", a, b) //a:666 b:666
}

func modify(p *int) {
    *p = 666
    return
}

分析：

1.指针的巩固练习

2.*p=b：p指向b，因为p是a的地址，所以a的值变成了b的值

3.p=&b：p是a的地址，指向a，这时候把b的地址赋值给p，但指向没有变。a，b的值都没有变，a和b的地址也没有变，*p的值变成5

4.第一次modify：这时的p已经是b的地址了，所以如果修改了p的指向，那么其实就直接修改了b的值

5.第二次modity：这里就是很正常地修改了a的值

 

demo5:

package main

import "fmt"

func main() {
    str := "hello world!"
    for index, value := range str {
        fmt.printf("index[%d] value:%c\n", index, value)
    }
    /*输出前三行如下
    index[0] value:h
    index[1] value:e
    index[2] value:l
    */
}

分析：

1.除了基本地for循环，go有另一种for循环，很方便，值得学习

 

demo6:

package main

import "fmt"

type op_func func(int, int) int

func add(a, b int) int {
    return a + b
}

func operator(op op_func, a, b int) int {
    return op(a, b)
}

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

func main() {
    c := add
    sum := c(1, 2)
    fmt.println(sum)

    var d op_func = add
    result := operator(d, 100, 200)
    fmt.println(result)

    sum, avg := calc(2, 6)
    fmt.println(sum, avg)
}

分析：

1.go的函数可以赋值给一个变量，并且作为参数传递

2.go的函数可以多返回值，并且可以在函数开头给返回值赋值，在return处省略

 

demo7:

package main

import "fmt"

func add(a int, arg ...int) int {
    var sum int = a
    for i := 0; i < len(arg); i++ {
        sum += arg[i]
    }
    return sum
}

func concat(a string, arg ...string) (result string) {
    result = a
    for i := 0; i < len(arg); i++ {
        result += arg[i]
    }
    return
}

func main() {
    sum := add(1, 2, 3, 4, 5)
    fmt.println(sum)

    result := concat("a", "b", "c", "d", "e")
    fmt.println(result)
}

分析：

1.函数支持不确定参数

 

demo8:

package main

import "fmt"

func main() {
    var i int = 0
    defer fmt.println(i)
    defer fmt.println(1)
    i = 10
    fmt.println(i)
}

/*输出：
10
1
0
*/

分析：

1.defer语句的理解

2.defer...i...这一句先被放在栈底，然后在它上面放入defer...1...，最后再把函数本身放上。所以执行的时候，先输出10，然后是1，最后是0

3.defer的实际用途：释放资源，比如defer file.close()：无论对文件做什么操作或者多么复杂的逻辑判断，最终都会释放资源

 

demo9:

package main

import "fmt"

func main() {
    result := func(a int, b int) int {
        return a + b
    }
    fmt.println(result(1, 2))
}

分析：

1.匿名函数的简单使用