這篇文章給大家分享的是有關(guān)golang怎么用的內(nèi)容。小編覺得挺實(shí)用的，因此分享給大家做個(gè)參考，一起跟隨小編過來看看吧。

創(chuàng)新互聯(lián)是少有的網(wǎng)站設(shè)計(jì)制作、成都網(wǎng)站設(shè)計(jì)、營銷型企業(yè)網(wǎng)站、小程序開發(fā)、手機(jī)APP,開發(fā)、制作、設(shè)計(jì)、賣友情鏈接、推廣優(yōu)化一站式服務(wù)網(wǎng)絡(luò)公司,自2013年起,堅(jiān)持透明化,價(jià)格低,無套路經(jīng)營理念。讓網(wǎng)頁驚喜每一位訪客多年來深受用戶好評

1. 利用defer、recover來實(shí)現(xiàn)try...catch

func Try(fun func(), handler func(interface{})) {
        defer func() {
                if err := recover(); err != nil {
                        handler(err)
                }
        }()
        fun()
}

func main() {
        Try(func() {
                panic("foo")
        }, func(e interface{}) {
                print(e)
        })
}

2. 關(guān)于error的一個(gè)程序

error是一個(gè)類型，類似于string，error也可以定義自己的類型

package main

import "errors"
import "fmt"

// By convention, errors are the last return value and
// have type `error`, a built-in interface.
func f1(arg int) (int, error) {
    if arg == 42 {

        // `errors.New` constructs a basic `error` value
        // with the given error message.
        return -1, errors.New("can't work with 42")

    }

    // A nil value in the error position indicates that
    // there was no error.
    return arg + 3, nil
}

// It's possible to use custom types as `error`s by
// implementing the `Error()` method on them. Here's a
// variant on the example above that uses a custom type
// to explicitly represent an argument error.
type argError struct {
    arg  int
    prob string
}

func (e *argError) Error() string {
    return fmt.Sprintf("%d - %s", e.arg, e.prob)
}

func f2(arg int) (int, error) {
    if arg == 42 {

        // In this case we use `&argError` syntax to build
        // a new struct, supplying values for the two
        // fields `arg` and `prob`.
        return -1, &argError{arg, "can't work with it"}
    }
    return arg + 3, nil
}

func main() {

    // The two loops below test out each of our
    // error-returning functions. Note that the use of an
    // inline error check on the `if` line is a common
    // idiom in Go code.
    for _, i := range []int{7, 42} {
        if r, e := f1(i); e != nil {
            fmt.Println("f1 failed:", e)
        } else {
            fmt.Println("f1 worked:", r)
        }
    }
    for _, i := range []int{7, 42} {
        if r, e := f2(i); e != nil {
            fmt.Println("f2 failed:", e)
        } else {
            fmt.Println("f2 worked:", r)
        }
    }

    // If you want to programmatically use the data in
    // a custom error, you'll need to get the error  as an
    // instance of the custom error type via type
    // assertion.
    _, e := f2(42)
    if ae, ok := e.(*argError); ok {
        fmt.Println(ae.arg)
        fmt.Println(ae.prob)
    }
}

3. timer和ticker都是可以停止的

package main

import (
	"fmt"
	"time"
)

func main() {
	ticker := time.NewTicker(time.Millisecond * 500)
	go func() {
		for t := range ticker.C {
			fmt.Println("ticker is at ", t)
		}
	}()

	time.Sleep(time.Millisecond * 1500)
	ticker.Stop()
	fmt.Println("ticker stopped")
}

package main

import (
	"fmt"
	"time"
)

func main() {
	timer1 := time.NewTimer(time.Second * 2)
	<-timer1.C
	fmt.Println("timer1 expired.")

	timer2 := time.NewTimer(time.Second * 1)
	go func() {
		<-timer2.C
		fmt.Println("timer2 expired.")
	}()

	ok := timer2.Stop()
	if ok {
		fmt.Println("timer2 stopped.")
	}
}

4. 一個(gè)比較復(fù)雜的channel的例子

package main

import (
	"fmt"
	"math/rand"
	"sync/atomic"
	"time"
)

type readOp struct {
	key  int
	resp chan int
}
type writeOp struct {
	key  int
	val  int
	resp chan bool
}

func main() {
	var ops int64 = 0
	reads := make(chan *readOp)
	writes := make(chan *writeOp)

	go func() {
		var state = make(map[int]int)
		for {
			select {
			case read := <-reads:
				read.resp <- state[read.key]
			case write := <-writes:
				state[write.key] = write.val
				write.resp <- true
			}
		}
	}()

	for r := 0; r < 100; r++ {
		go func() {
			for {
				read := &readOp{
					key:  rand.Intn(5),
					resp: make(chan int)}
				reads <- read
				<-read.resp
				atomic.AddInt64(&ops, 1)
			}
		}()
	}

	for w := 0; w < 10; w++ {
		go func() {
			for {
				write := &writeOp{
					key:  rand.Intn(5),
					val:  rand.Intn(100),
					resp: make(chan bool)}
				writes <- write
				<-write.resp
				atomic.AddInt64(&ops, 1)
			}
		}()
	}

	time.Sleep(time.Second)
	opsFinal := atomic.LoadInt64(&ops)
	fmt.Println("ops:", opsFinal)
}

5. sort包封裝了一些常用的排序方法，用起來還是很方便的

package main

import "fmt"
import "sort"

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

	ints := []int{7, 2, 4}
	sort.Ints(ints)
	fmt.Println("Ints:   ", ints)

	s := sort.IntsAreSorted(ints)
	fmt.Println("Sorted: ", s)
}

6. slice的引用特性

package main

import (
	"fmt"
)

func main() {
	array := make([]int, 0, 3)
	array = append(array, 1)
	a := array
	b := array
	a = append(a, 2)
	b = append(b, 3)
	fmt.Println(a)
}

結(jié)果是什么呢？答案揭曉，輸出是“[1 3]”。

就我的理解，slice 是一個(gè){指向內(nèi)存的指針，當(dāng)前已有元素的長度，內(nèi)存最大長度}的結(jié)構(gòu)體，其中只有指向內(nèi)存的指針一項(xiàng)是真正具有引用語義的域，另外兩項(xiàng)都是每個(gè) slice 自身的值。因此，對 slice 做賦值時(shí)，會出現(xiàn)兩個(gè) slice 指向同一塊內(nèi)存，但是又分別具有各自的元素長度和最大長度。程序里把 array 賦值給 a 和 b，所以 a 和 b 會同時(shí)指向 array 的內(nèi)存，并各自保存一份當(dāng)前元素長度 1 和最大長度 3。之后對 a 的追加操作，由于沒有超出 a 的最大長度，因此只是把新值 2 追加到 a 指向的內(nèi)存，并把 a 的“當(dāng)前已有元素的長度”增加 1。之后對 b 進(jìn)行追加操作時(shí)，因?yàn)?a 和 b 各自擁有各自的“當(dāng)前已有元素的長度”，因此 b 的這個(gè)值依舊是 1，追加操作依舊寫在 b 所指向內(nèi)存的偏移為 1 的位置，也就復(fù)寫了之前對 a 追加時(shí)寫入的 2。

為了讓 slice 具有引用語義，同時(shí)不增加 array 的實(shí)現(xiàn)負(fù)擔(dān)，又不增加運(yùn)行時(shí)的開銷，似乎也只能忍受這個(gè)奇怪的語法了。

感謝各位的閱讀！關(guān)于“golang怎么用”這篇文章就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，讓大家可以學(xué)到更多知識，如果覺得文章不錯(cuò)，可以把它分享出去讓更多的人看到吧！