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
", a) //10

    var p *int = &a
    fmt.Printf("%d->%d
", 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
", a, b) //a:10 b:666

    modify(&a)
    fmt.Printf("a:%d b:%d
", 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
", 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.匿名函数的简单使用