【Golang学习笔记】06

最新推荐文章于 2024-07-03 20:09:57 发布

乱乱乱世

最新推荐文章于 2024-07-03 20:09:57 发布

阅读量312

点赞数 1

分类专栏： Golang学习笔记

本文链接：https://blog.csdn.net/qq_28314759/article/details/79183465

版权

Golang学习笔记专栏收录该内容

6 篇文章 0 订阅

订阅专栏

定时器

    timer := time.NewTimer(1 * time.Second)  // 定时器
    <-timer.C

工作池

func worker(id int, jobs <-chan int, result chan<- int)  {//工作池
    for j := range jobs{
        fmt.Printf("id:%d, jobs:%d \n", id, j)
        time.Sleep(1 * time.Second)
        result <- j
    }
    }

func main() {
    jobs := make(chan int, 100)
    result := make(chan int, 100)

    for i := 1; i <= 3; i++  {
        go worker(i, jobs, result)          // 开3个工作池
    }

    for i := 1; i <= 9; i++ {               // 放入9个任务
        jobs <- i
    }
    close(jobs)
    for i := 0; i < 9; i++ {
        <-result                            // 等待结果，阻塞线程
    }
}
/*
    id:2, jobs:2 
    id:3, jobs:3 
    id:1, jobs:1 
    id:3, jobs:4 
    id:1, jobs:5 
    id:2, jobs:6 
    id:1, jobs:7 
    id:3, jobs:8 
    id:2, jobs:9 
*/

获得输入

func main() {
    // 输入
    var input string
    fmt.Scanln(&input)
    fmt.Println("done ", input)
}
/*
qqq
input  qqq
*/

超时处理阻塞方法

func main() {

    // 超过1秒则超时 阻塞的方法
    c1 := make(chan int)

    go func() {
        time.Sleep(2 * time.Second)    // 两秒后往c1里放东西
        c1 <- 1
    }()

    select {
    case msg := <-c1:                  // 等待并阻塞
        fmt.Println("get", msg)
    case <-time.After(1 * time.Second):  // 仅阻塞一秒
        fmt.Println("time out")
    }
    // time out

select default

func main() {
    messages := make(chan string, 1)

    select {
    case msg := <-messages:
        fmt.Println("received messages", msg)
    default:
        fmt.Println("no received messages")
    }

    msg := "hi"
    select {
    case messages <- msg:
        fmt.Println("sent messages", msg)
    default:
        fmt.Println("no messages sent")
    }

    select {
    case msg := <-messages:
        fmt.Println("received messages", msg)
    default:
        fmt.Println("no received messages")
    }
}
/*
no received messages
sent messages hi
received messages hi
*/

速率限制恒速

    requests := make(chan int, 5)
    for i := 0; i < 5; i++ {
        requests <- i
    }
    close(requests)

    limiter := time.Tick(1 * time.Second)

    for r := range requests {
        <- limiter       // 阻塞一秒
        fmt.Println(time.Now(), " ", r)
    }
/*
2018-01-27 20:04:19.0368234 +0800 CST m=+1.005057501   0
2018-01-27 20:04:20.0368806 +0800 CST m=+2.005114701   1
2018-01-27 20:04:21.0369378 +0800 CST m=+3.005171901   2
2018-01-27 20:04:22.036995 +0800 CST m=+4.005229101   3
2018-01-27 20:04:23.0370522 +0800 CST m=+5.005286301   4
*/

速率限制变速

    requests2 := make(chan int, 10)
    for i := 0; i < 10; i++ {
        requests2 <- i
    }
    close(requests2)

    timeLimiter := make(chan time.Time, 3)
    for i := 0; i < 3; i++ {
        timeLimiter <- time.Now()          // 先往channle中随便放三个
    }

    go func() {
        for t := range time.Tick(1 * time.Second) {
            timeLimiter <- t               // 接下来每一秒放一个
        }
    }()

    for r := range requests2 {
        <- timeLimiter             //前三次循环不会阻塞线程，接下来每一秒才会有一个输入。
        fmt.Println(time.Now(), " ", r)
    }
/*
2018-01-27 20:04:23.0370522 +0800 CST m=+5.005286301   0
2018-01-27 20:04:23.0370522 +0800 CST m=+5.005286301   1
2018-01-27 20:04:23.0370522 +0800 CST m=+5.005286301   2
2018-01-27 20:04:24.0371094 +0800 CST m=+6.005343501   3
2018-01-27 20:04:25.0371666 +0800 CST m=+7.005400701   4
2018-01-27 20:04:26.0372238 +0800 CST m=+8.005457901   5
2018-01-27 20:04:27.037281 +0800 CST m=+9.005515101   6
2018-01-27 20:04:28.0373382 +0800 CST m=+10.005572301   7
2018-01-27 20:04:29.0373954 +0800 CST m=+11.005629501   8
2018-01-27 20:04:30.0374526 +0800 CST m=+12.005686701   9
*/

自定义error

// 自定义 error 类型
type argError struct {
    arg int
    prop string
    }

func (e *argError)Error()string  {   // 实现了error的接口
    return fmt.Sprintf("hey I'm bad", e.arg, e.prop)
}

func f2(arg int)(int, error)  {
        if  arg == 41{
            return -1, &argError{arg, "f2 cant't work"}
        }
        return arg, nil
}

func main() {
    fmt.Println(f2(1))
    fmt.Println(f2(41))
}
/*
1 <nil>
-1 hey I'm bad%!(EXTRA int=41, string=f2 cant't work)
*/

exit

func main() {
    defer fmt.Println("end")

    os.Exit(3)      // 不会执行defer
}

url解析

    s := "http://aaa:123@host.com:21/file?a=b#q"

    // 解析这个 URL 并确保解析没有出错。
    u, err := url.Parse(s)
    if err != nil {
    panic(err)
    }

    fmt.Println(u.Scheme)   // http

    // User包含了所有的信息
    fmt.Println(u.User)     // aaa:123
    fmt.Println(u.User.Username())  // aaa
    p, _ := u.User.Password()
    fmt.Println(p)          // 123

    fmt.Println(u.Host)     // host.com:21
    h := strings.Split(u.Host, ":")  // 提取端口
    fmt.Println(h[0])        // host.com
    fmt.Println(h[1])        // 21

    fmt.Println(u.Path)     // /file
    fmt.Println(u.Fragment) // q

    fmt.Println(u.RawQuery) // a=b
    m, _ := url.ParseQuery(u.RawQuery)
    fmt.Println(m)          // map[a:[b]]
    fmt.Println(m["a"][0])  // b

写文件

    func check(e error)  {// 检查err是否为空 
        if e != nil {
            panic(e)
        }
    }

    d1 := []byte("hello go\n")
    err := ioutil.WriteFile("/test.txt", d1, 0644)  // 向一个文件中写入东西，如果文件不存在就创建一个
    check(err)

    f, err := os.Create("/test2.txt")  // 创建一个文件
    defer f.Close()
    check(err)

    d2 := []byte{115, 111, 109, 101, 10}  
    n2, err := f.Write(d2)      // 自动翻译ascll码 
    check(err)
    fmt.Println("wrote %d bytes \n", n2)

    n3, err := f.WriteString("wrote string \nhey\n") // 直接写字符串
    check(err)
    fmt.Println("wrote %d bytes \n", n3)

    f.Sync()      // 同步所有内容到硬盘上 确保内容写入

    w := bufio.NewWriter(f)     // 使用了 bufio的接口
    n4, err := w.WriteString("buffered \n")
    fmt.Println("wrote %d bytes \n", n4)

    w.Flush()     // 通过io.writer将数据写入底层

/*
    test.txt中的内容
    hello go

    test2.txt中的内容
    some
    wrote string 
    hey
    buffered 
*/

读文件

func main() {
// 内容 hello go.Go is a new language, a concurrent, garbage-collected, fast-compiled language.
    dat, err := ioutil.ReadFile("/test.txt")
    Check(err)
    fmt.Println(string(dat))               // 将内容全部读到dat中

    f, err := os.Open("/test.txt")         // 将文件中的内容全部读到内存中
    defer f.Close()
    Check(err)

    b1 := make([]byte, 12)
    n1,err := f.Read(b1)                   // 将全部内容放入字节数组中,直至放慢数组
    Check(err)
    fmt.Printf("%d bytes: %s  \n",n1, string(b1))

    o2,err := f.Seek(6, 0)                 // 偏移6个字节
    Check(err)
    b2 := make([]byte, 6)
    n2,err := f.Read(b2)
    Check(err)
    fmt.Printf("%d bytes @ %d: %s \n", n2, o2, string(b2))

    o3, err := f.Seek(6, 0)
    Check(err)
    b3 := make([]byte, 3)
    n3,err := io.ReadAtLeast(f, b3, 3)      // 最多读3个字节
    Check(err)
    fmt.Printf("%d bytes @ %d: %s \n", n3, o3, string(b3))

    _, err = f.Seek(0, 0)                    // 偏移为0 相当于恢复
    Check(err)

    r4 := bufio.NewReader(f)                 // 使用bufio的接口
    b4, err := r4.Peek(6)
    Check(err)
    fmt.Printf("6 bytes: %s \n", string(b4))
    }

/*
hello go.Go is a new language, a concurrent, garbage-collected, fast-compiled language.

12 bytes: hello go.Go   
6 bytes @ 6: go.Go  
3 bytes @ 6: go. 
6 bytes: hello  
*/

排序

func main() {
    strs := []string{"b", "c", "a"}
    sort.Strings(strs)        
    fmt.Println("strings sort:  ", strs)  // strings sort:   [a b c]

    ints := []int{3,1,2}
    sort.Ints(ints)
    fmt.Println("ints sort:   ", ints)    // ints sort:    [1 2 3]

    areIntsSort := sort.IntsAreSorted(ints)  // 是否已排序
    fmt.Println("are ints sort:  ", areIntsSort) // are ints sort:   true
}

自定义排序

// 实现了接口 Len Swao Less
type ByLengthSort []string

func (s ByLengthSort)Len() int  {
    return len(s)
}

func (s ByLengthSort)Swap(i int, j int)  {
    s[i], s[j] = s[j], s[i]
}

func (s ByLengthSort)Less(i int, j int)bool  {  // 排序规则
    return len(s[i]) < len(s[j])
}

func main()  {
    strs := []string{"aaa", "bb", "dddd", "c"}
    sort.Sort(ByLengthSort(strs))
    fmt.Println(strs)
}

// [c bb aaa dddd]

string转换成其他的

    // string to float64
    f, _ := strconv.ParseFloat("1.234", 64) //(字符串,位数)

    // string to int
    i, _ := strconv.ParseInt("123", 0, 64)   //(字符串,进制（0为自动推断）, 位数)
    d, _ := strconv.ParseInt("0x1c8", 0, 64) //可以自动识别16进制

    // Atoi基础的十进制整形转换函数
    k, _ := strconv.Atoi("135")

时间

func main() {
    fmt.Println(time.Now())

    it := time.Date(
        2012,12,13,0,0,0,0, time.UTC)
    fmt.Println(it)   // 自定义一个time类型

    fmt.Println(it.Weekday())  // 周几

    fmt.Println(it.Before(time.Now()))  // 这个时间是否是在今天之前

    diff := time.Now().Sub(it)          // 这个时间点和现在这个的时间的差
    fmt.Println(diff)

    fmt.Println(diff.Hours())           // 小时
    fmt.Println(diff.Nanoseconds())     // 纳秒

    fmt.Println(it.Add(diff))           // 时间的 加法
}

行过滤器

func main() {
    scanner := bufio.NewScanner(os.Stdin)

    for scanner.Scan()  { // 等待输入
        ucl := strings.ToUpper(scanner.Text())   // 将scanner中的内容变成大写
        if ucl == "#"{
            return
        }
        fmt.Println(ucl)

    }

    if err := scanner.Err(); err != nil {
        fmt.Fprintln(os.Stderr, "error", err)
        os.Exit(1)
    }
}

随机数

s3 := rand.NewSource(int64(time.Now().Second()))    // 将当前时间的秒作为随机种子 随机种子一样 随机出的数也会一样
    r3 := rand.New(s3)
    for i := 0; i < 10; i++ {
        fmt.Print(r3.Intn(100), ",")
    }
// 84,23,85,86,50,55,7,4,13,53,