Go语言开发小技巧&易错点100例（八）

**Go语言开发小技巧&易错点100例（八）**

在前面的几篇文章中，我们已经介绍了很多关于Go语言开发的小技巧和易错点。今天我们继续来讲第八部分。

###1. 使用`sync.WaitGroup`进行并发操作当我们需要等待多个goroutine执行完毕时，可以使用`sync.WaitGroup`来实现。这是一个非常有用的工具，能够帮助我们管理并发操作的顺序。

gopackage mainimport (
"fmt"
"sync"
)

func worker(id int, wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Printf("Worker %d is running...
", id)
}

func main() {
	var wg sync.WaitGroup	for i :=1; i <=5; i++ {
	wg.Add(1)
	go worker(i, &wg)
}
	wg.Wait()
	fmt.Println("All workers have finished.")
}

###2. 使用`sync.Once`进行单例模式当我们需要实现一个单例模式时，可以使用`sync.Once`来保证只执行一次。

gopackage mainimport (
"fmt"
"sync"
)

type singleton struct{}

var once sync.Oncefunc GetInstance() *singleton {
once.Do(func() {
	fmt.Println("Creating a new instance...")
})
	return &singleton{}
}

func main() {
	instance1 := GetInstance()
	instance2 := GetInstance()

	if instance1 == instance2 {
	fmt.Println("Both instances are the same.")
}
}

###3. 使用`time.Sleep`进行延时操作当我们需要在程序中添加一些延时操作时，可以使用`time.Sleep`来实现。

gopackage mainimport (
"fmt"
"time"
)

func main() {
	fmt.Println("Starting...")
	time.Sleep(2 * time.Second)
	fmt.Println("Finished.")
}

###4. 使用`context.WithTimeout`进行超时处理当我们需要在程序中添加一些超时操作时，可以使用`context.WithTimeout`来实现。

gopackage mainimport (
"context"
"fmt"
"time"
)

func worker(ctx context.Context) {
	select {
	case <-ctx.Done():
	fmt.Println("Worker has timed out.")
	default:
	fmt.Println("Worker is running...")
}
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(),2*time.Second)
	defer cancel()
	go worker(ctx)
	time.Sleep(3 * time.Second)
}

###5. 使用`net/ />

gopackage mainimport (
"fmt"
"net/ />)

func handler(w  r * {
	fmt.Fprint(w, "Hello, World!")
}

func main() {
	 func(w  r * {
	 r)
})
	 nil)
}

###6. 使用`database/sql`进行数据库操作当我们需要在Go程序中使用数据库时，可以使用`database/sql`来实现。

gopackage mainimport (
"database/sql"
"fmt"
_ "github.com/lib/pq"
)

func main() {
	db, err := sql.Open("postgres", "user=your_username password=your_password host=localhost dbname=your_database")
	if err != nil {
	fmt.Println(err)
	return}
	defer db.Close()

	var name string	err = db.QueryRow("SELECT name FROM users WHERE id = $1",1).Scan(&name)
	if err != nil {
	fmt.Println(err)
	return}

	fmt.Println(name)
}

###7. 使用`encoding/json`进行JSON序列化当我们需要在Go程序中使用JSON序列化时，可以使用`encoding/json`来实现。

gopackage mainimport (
"encoding/json"
"fmt"
)

type Person struct {
	Name string `json:"name"`
Age int `json:"age"`
}

func main() {
	p := &Person{
	Name: "John",
Age:30,
}
	jsonStr, err := json.Marshal(p)
	if err != nil {
	fmt.Println(err)
	return}

	fmt.Println(string(jsonStr))
}

###8. 使用`encoding/xml`进行XML序列化当我们需要在Go程序中使用XML序列化时，可以使用`encoding/xml`来实现。

gopackage mainimport (
"encoding/xml"
"fmt"
)

type Person struct {
	Name string `xml:"name"`
Age int `xml:"age"`
}

func main() {
	p := &Person{
	Name: "John",
Age:30,
}
	xmlStr, err := xml.Marshal(p)
	if err != nil {
	fmt.Println(err)
	return}

	fmt.Println(string(xmlStr))
}

###9. 使用`crypto/aes`进行AES加密当我们需要在Go程序中使用AES加密时，可以使用`crypto/aes`来实现。

gopackage mainimport (
"crypto/aes"
"crypto/cipher"
"fmt"
)

func main() {
	key := []byte("your_key")
	data := []byte("Hello, World!")

	block, err := aes.NewCipher(key)
	if err != nil {
	fmt.Println(err)
	return}

	cfb := cipher.NewCFBEncrypter(block, key[:16])
encrypted := make([]byte, len(data))
	cfb.XORKeyStream(encrypted, data)

	fmt.Println(string(encrypted))
}

###10. 使用`crypto/sha256`进行SHA-256加密当我们需要在Go程序中使用SHA-256加密时，可以使用`crypto/sha256`来实现。

gopackage mainimport (
"crypto/sha256"
"fmt"
)

func main() {
	data := []byte("Hello, World!")
	hash := sha256.Sum256(data)
	fmt.Println(hash)
}

以上就是本篇文章的内容。通过这些例子，我们可以看到Go语言在并发操作、单例模式、延时操作、超时处理、数据库操作、JSON序列化、XML序列化、AES加密和SHA-256加密等方面都有非常强大的支持能力。