服务端

Golang快速入门、从安装到使用详解

Golang快速入门笔记

## 前言

Golang 的开发中，有时候我们需要获取当前正在运行的程序所在的目录路径，这对于读取相对路径下的配置文件或资源文件非常有用。

本文将展示几种在 Golang 中获取当前运行文件目录的方法。

## 方法一：使用 `os` 包

Go 语言的 `os` 包提供了很多与操作系统交互的功能，其中就包括了获取当前执行的程序的绝对路径。

```go
package main

import (
    "fmt"
    "os"
    "path/filepath"
)

func main() {
    // 获取当前执行的程序的路径
    exePath, err := os.Executable()
    if err != nil {
        panic(err)
    }
  
    // 将路径转换为绝对路径
    exeAbsPath, err := filepath.Abs(exePath)
    if err != nil {
        panic(err)
    }

    // 获取执行文件所在的目录
    dir := filepath.Dir(exeAbsPath)
  
    fmt.Println("当前运行文件的目录是：", dir)
}
```

请注意，这里获取的是可执行文件的路径，而不是调用 `os.Executable()` 的源代码文件路径。

## 方法二：使用 `runtime` 包

如果你想获取的是源代码文件所在的目录，可以使用 `runtime` 包中的 `Caller` 函数。

```go
package main

import (
    "fmt"
    "path/filepath"
    "runtime"
)

func main() {
    // 获取当前函数调用的程序计数器、文件信息和行号
    _, filename, _, ok := runtime.Caller(0)
    if !ok {
        panic("No caller information")
    }
  
    // 将文件的路径转换为绝对路径
    absPath, err := filepath.Abs(filename)
    if err != nil {
        panic(err)
    }
  
    // 获取执行文件所在的目录
    dir := filepath.Dir(absPath)
  
    fmt.Println("当前源代码文件的目录是：", dir)
}
```

这段代码会输出当前源代码文件所在的目录路径。`runtime.Caller(0)` 返回的是当前调用栈的信息，其中 `0` 表示当前函数，`filename` 就是当前源文件的路径。

## 方法三：使用 `os` 包结合环境变量

有时候，我们可以结合环境变量来确定当前的工作目录，这通常用于获取程序运行时的工作目录，这样可以找到相对于工作目录的文件和资源。 

```go
package main

import (
    "fmt"
    "os"
)

func main() {
    // 获取程序的工作目录
    dir, err := os.Getwd()
    if err != nil {
        panic(err)
    }
  
    fmt.Println("程序的工作目录是：", dir)
}
```

这里 `os.Getwd()` 返回的是程序的当前工作目录，通常是你在哪个目录下执行 `go run` 或者二进制文件的路径。 

## 总结

在 Golang 中，主要有三种方法来获取当前运行文件或代码的目录。使用 `os.Executable` 获取的是可执行文件的目录，使用 `runtime.Caller` 获取的是源代码文件所在的目录，而使用 `os.Getwd` 则是获得程序执行时的工作目录。根据你的需求选择适合的方法，确保你的程序能够正确地找到它需要的资源。


Golang如何获取当前运行文件的目录？Golang的开发中，有时候我们需要获取当前正在运行的程序所在的目录路径，这对于读取相对路径下的配置文件或资源文件非常有用。本文将展示几种在Golang中获取当前运行文件目录的方法。方法一：使用os包Go语言的os包提供了很多与操作系统交互的功能，其中就包括了获取当前执行的程序的绝对路径。packagemainimport("fmt""os""path/f

Golang 如何获取当前运行文件的目录

## 前言

生成随机字符串在许多编程情景中都非常有用，比如创建密码、唯一标识符或者用于测试的随机数据。Golang 生成一个固定长度的随机字符串是一个相对简单的任务，但需要注意一些关于随机性和安全性的细节。

本文将详细介绍如何在 Golang 中生成一个固定长度的随机字符串。

## 实现步骤

### 一、引入依赖包

首先，我们需要引入 Go 的两个包：`math/rand` 用于生成随机数，`time` 用于提供一个随机种子。

```go
import (
    "math/rand"
    "time"
)
```

### 二、设定字符集

随机字符串可以从一个预定义的字符集中生成。这个字符集可以包括小写字母、大写字母、数字和符号等。下面是一个包含了大小写字母和数字的基本字符集：

```go
const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
```

### 三、初始化随机种子

在生成随机数之前，为了确保每次运行程序时随机数都是不同的，我们需要使用当前时间初始化随机种子：

```go
func init() {
    rand.Seed(time.Now().UnixNano())
}
```

### 四、编写生成随机字符串的函数

利用上面的字符集和随机种子，我们现在可以编写一个函数来生成固定长度的随机字符串了。这个函数接收一个整数参数 `length`，表示所需字符串的长度，并返回一个随机字符串。

```go
func RandomString(length int) string {
    b := make([]byte, length)
    for i := range b {
        b[i] = charset[rand.Intn(len(charset))]
    }
    return string(b)
}
```

这个函数首先创建了一个长度为 `length` 的 `byte` 切片。然后，它遍历切片的每一位，使用 `rand.Intn` 函数从我们定义的字符集 `charset` 中随机选择一个字符，并将其分配到切片中相应的位置。最后，它将 `byte` 切片转换为字符串并返回。

## 完整代码

将上述片段合并后，我们得到一个完整的示例代码，用于生成固定长度的随机字符串：

```go
package main

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

const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"

func init() {
    rand.Seed(time.Now().UnixNano())
}

func RandomString(length int) string {
    b := make([]byte, length)
    for i := range b {
        b[i] = charset[rand.Intn(len(charset))]
    }
    return string(b)
}

func main() {
    // 生成一个长度为 10 的随机字符串
    randomStr := RandomString(10)
    fmt.Println(randomStr)
}
```

运行这个程序，你将得到一个长度为 10 的随机字符串，每次运行结果都将不同。请记住，使用 `math/rand` 包生成的随机序列并不适合加密场景。

如果你需要生成密码或其他安全相关的随机字符串，应该使用 `crypto/rand` 包来确保足够的随机性和不可预测性。 

## 注意事项

如果你的随机字符串用于安全敏感的应用，比如生成令牌或密码，你应该使用 `crypto/rand` 包来生成更加安全的随机字符串。这个包提供了密码学上安全的随机数生成器。

```go
import (
    "crypto/rand"
    "encoding/base64"
)

func SecureRandomString(length int) (string, error) {
    b := make([]byte, length)
    _, err := rand.Read(b)
    if err != nil {
        return "", err
    }
    return base64.URLEnc,```go
// 编码输出保证字符串可读。
    return base64.URLEncoding.EncodeToString(b)[:length], nil
}

// 完整示例代码
package main

import (
    "crypto/rand"
    "encoding/base64"
    "fmt"
)

func SecureRandomString(length int) (string, error) {
    b := make([]byte, length)
    _, err := rand.Read(b)
    if err != nil {
        return "", err
    }
    // 注意：如果你需要确切的字符串长度，请根据base64编码的特性,
    // 调整b的长度，因为base64编码会增加输出长度。
    return base64.URLEncoding.EncodeToString(b)[:length], nil
}

func main() {
    // 生成一个长度为 10 的安全随机字符串
    randomStr, err := SecureRandomString(10)
    if err != nil {
        panic(err) // 处理错误的推荐方式
    }
    fmt.Println(randomStr)
}
```

在这个修改后的安全版本中，我们使用 `crypto/rand` 中的 `Read` 函数来生成一个安全的随机字节切片，并使用 `base64.URLEncoding.EncodeToString` 将这个字节切片转换成一个可读的安全随机字符串。

运行这个程序会生成一个长度为 10 的安全随机字符串。由于 base64 编码会使字符串长度增加，你可能需要根据编码后的长度来调整生成的字节切片的长度，确保最终的字符串满足你的实际需求。


生成随机字符串在许多编程情景中都非常有用，比如创建密码、唯一标识符或者用于测试的随机数据。Golang生成一个固定长度的随机字符串是一个相对简单的任务，但需要注意一些关于随机性和安全性的细节。本文将详细介绍如何在Golang中生成一个固定长度的随机字符串。实现步骤一、引入依赖包首先，我们需要引入Go的两个包：math/rand用于生成随机数，time用于提供一个随机种子。import("mat

Golang 中如何生成固定长度的随机字符串

## 前言

Golang 定时器允许我们在将来的某个时间点执行一次或定期执行代码，这在编写需要调度任务或者实现某些定时操作的程序时非常有用。Golang 的标准库 `time` 提供了强大的定时器和计时器功能。

本文将详细介绍如何在 Golang 中使用定时器。

## 实现方式

### 一、单次定时器

如果只想在将来的某个时间点执行一次任务，可以使用 `time.AfterFunc` 函数或者 `time.NewTimer` 方法。

#### 使用 `time.AfterFunc`

```go
package main

import (
    "fmt"
    "time"
)

func main() {
    // 定义一个延迟时间，比如2秒
    duration := 2 * time.Second

    // 创建一个定时器，在2秒后执行
    timer := time.AfterFunc(duration, func() {
        fmt.Println("Timer expired")
    })

    // 等待定时器触发或者其他逻辑
    // ... 可以在这里执行其他任务

    // 如果需要，可以停止定时器
    // timer.Stop()

    // 防止程序直接退出，等待定时任务执行完毕
    time.Sleep(3 * time.Second)
}
```

在上面的代码中，`time.AfterFunc` 将在指定的延迟后调用传入的函数。

#### 使用 `time.NewTimer`

```go
package main

import (
    "fmt"
    "time"
)

func main() {
    // 定义一个延迟时间
    duration := 2 * time.Second

    // 创建一个新定时器
    timer := time.NewTimer(duration)

    // 当定时器到期时，时间将被发送到 timer.C
    <-timer.C
    fmt.Println("Timer expired")

    // 如果需要，可以重设定时器
    // timer.Reset(duration)

    // 如果需要，可以停止定时器
    // timer.Stop()
}
```

在这个例子中，`time.NewTimer` 创建了一个新的定时器实例。当定时器到期时，当前时间会被发送到通道 `timer.C`。

### 二、周期定时器

如果你想要定期执行任务，可以使用 `time.Ticker`。

#### 使用 `time.NewTicker`

```go
package main

import (
    "fmt"
    "time"
)

func main() {
    // 定义周期时间，比如每隔1秒
    interval := 1 * time.Second

    // 创建一个周期定时器
    ticker := time.NewTicker(interval)
    defer ticker.Stop()

    // 使用for循环来处理定时事件
    for {
        select {
        case <-ticker.C:
            // 定时器到时，执行的操作
            fmt.Println("Ticker ticked")
        // 可以添加其他case处理其他事项
        // case <-someOtherChannel:
        //     // 处理其他事件
        }
    }
}
```

在上面的代码中，使用 `time.NewTicker` 创建了一个周期定时器，每隔指定的时间 `interval` 就会执行一次循环体中的代码。

## 总结

通过标准库中的 `time` 包，可以方便地创建单次定时器和周期定时器来调度任务的执行。只需要选择合适的工具，无论是一次性执行还是周期性执行任务，Go 都能够帮助你优雅地实现。

Golang 的定时器和计时器是并发安全的，可以在多个goroutine之间共享使用，这在编写并发程序时尤其有用。通过上面的例子，应该对如何在 Go 程序中创建和管理定时器有了一个基本的理解。


Golang定时器允许我们在将来的某个时间点执行一次或定期执行代码，这在编写需要调度任务或者实现某些定时操作的程序时非常有用。Golang的标准库time提供了强大的定时器和计时器功能。本文将详细介绍如何在Golang中使用定时器。实现方式一、单次定时器如果只想在将来的某个时间点执行一次任务，可以使用time.AfterFunc函数或者time.NewTimer方法。使用time.AfterFun

Golang 如何执行定时器 Timer

## 背景

邮件是常见的触达用户的途径，本文详细介绍基于 golang 的模版引擎构建漂亮的邮件内容，并且发送给模板用户。

## 思路

go 内置了 html/template 模块，类似 ejs 模块引擎。利用 template 能力可以将变量动态的注入到HTML字符串中，最终获得成功注入变量的字符串内容。

具体实现思路：

1. 首先根据设计图输出静态的HTML文件；
2. 然后将HTML中需要变化的内容提取变量占位符；
3. 利用 template 工具将 HTML 中的变量按照规则注入；
4. 最终通过运行 template 引擎，获得最终的动态HMTL内容；

## 邮件内容模版

### 1. 输出静态HTML文件

根据 figma 设计图编写对应的 HTML 代码；根据产品要求，内容需要动态变化的地方提取变量，方便后续的动态内容注入。

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/kb8Mr0gGIl9-J2PW.png)

```javascript
<!DOCTYPE HTML
  PUBLIC "-//W3C//DTD XHTML 1.0 Transitional //EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:v="urn:schemas-microsoft-com:vml"
  xmlns:o="urn:schemas-microsoft-com:office:office">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="x-apple-disable-message-reformatting">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <title>乐闻世界 - 列表</title>
</head>

<body
  style="margin: 0;padding: 0;line-height: inherit;margin: 0;padding: 0;-webkit-text-size-adjust: 100%;background-color: #f6f6f6;color: #333333">
  <table
    style="vertical-align: top;border-collapse: collapse;line-height: inherit;color: #000000;border-collapse: collapse;table-layout: fixed;border-spacing: 0;mso-table-lspace: 0pt;mso-table-rspace: 0pt;vertical-align: top;min-width: 320px;Margin: 0 auto;background-color: #f6f6f6;width:100%"
    cellpadding="0" cellspacing="0">
    <tbody style="line-height: inherit;">
      <tr style="vertical-align: top;border-collapse: collapse;line-height: inherit;vertical-align: top">
        <td
          style="vertical-align: top;border-collapse: collapse;line-height: inherit;color: #000000;word-break: break-word;border-collapse: collapse !important;vertical-align: top">
          
          <div style="line-height: inherit;padding-top: 24px;background-color: transparent">
            <div
              style="line-height: inherit;Margin: 0 auto;min-width: 320px;max-width: 620px;min-height: 512px; overflow-wrap: break-word;word-wrap: break-word;word-break: break-word;background-color: transparent;">
              <div
                style="line-height: inherit;border-collapse: collapse;display: table;width: 100%;background-color: transparent;">
                

                
                <div
                  style="line-height: inherit;max-width: 620px;min-width: 320px;display: table-cell;vertical-align: top;">
                  <div
                    style="line-height: inherit;background-color: #ffffff;width: 100% !important;border-radius: 8px;">
                    
                    <div
                      style="line-height: inherit;padding: 48px 36px 96px 36px;border-top: 0px solid transparent;border-left: 0px solid transparent;border-right: 0px solid transparent;border-bottom: 0px solid transparent;">
                      

                      
                      {{if .Picture}}
                      <table style="line-height: inherit;color: #000000;font-family:arial,helvetica,sans-serif;"
                        role="presentation" cellpadding="0" cellspacing="0" width="100%" border="0">
                        <tbody style="line-height: inherit;">
                          <tr style="line-height: inherit;">
                            <td
                              style="line-height: inherit;color: #000000;overflow-wrap:break-word;word-break:break-word;padding:0px;font-family:arial,helvetica,sans-serif;"
                              align="left">

                              <img align="center" border="0" src="{{.Picture}}" alt="乐闻世界"
                                title="乐闻世界"
                                style="line-height: inherit;outline: none;text-decoration: none;-ms-interpolation-mode: bicubic;clear: both;display: inline-block !important;border: none;height: auto;float: none;width: 60%;max-width: 300px;margin-bottom: 48px;"
                                width="173.6" />
                            </td>
                          </tr>
                        </tbody>
                      </table>
                      {{end}}

                      
                      <table
                        style="vertical-align: top;border-collapse: collapse;line-height: inherit;color: #000000;font-family:arial,helvetica,sans-serif;"
                        role="presentation" cellpadding="0" cellspacing="0" width="100%" border="0">
                        <tbody>
                          <tr style="vertical-align: top;border-collapse: collapse;">
                            <td
                              style="vertical-align: top;border-collapse: collapse;line-height: inherit;color: #000000;overflow-wrap:break-word;word-break:break-word;padding:10px;font-family:arial,helvetica,sans-serif;"
                              align="left">

                              <div
                                style="line-height: 26px; text-align: left; word-wrap: break-word;font-size: 16px;font-weight: 500;">
                                <p style="margin: 0;font-size: 16px; line-height: 26px;">{{.Title}}</p>
                                <p style="margin: 0;font-size: 16px; line-height: 26px;"> <br />{{.Desc}}</p>

                                {{if .Logs}}
                                
                                <p
                                  style="font-size: 14px;font-weight: 600; line-height: 22px;color: #999999;margin: 24px 0;">
                                  ⚠️
                                  {{.Warning}}
                                </p>
                                {{end}}
                              </div>
                            </td>
                          </tr>
                        </tbody>
                      </table>

                      
                      {{range .Logs}}
                      <div style="line-height: inherit;border-top:1px dashed #BDBDBD;padding-top: 24px;">
                        <div
                          style="line-height: 26px; text-align: left; word-wrap: break-word;font-size: 16px;font-weight: 500;">
                          {{if .IsRespondent}}
                          <p style="margin: 0;font-size: 14px;font-weight: 700; line-height: 22px;color:  #338AFF;">
                            {{.Title}}</p>
                          {{else}}
                          <p style="margin: 0;font-size: 14px;font-weight: 700; line-height: 22px;color:  #6ABF40;">
                            {{.Title}}</p>
                          {{end}}

                          <p style="margin: 0;font-size: 14px;font-weight: 400; line-height: 22px;color: #999999">
                            {{.Time}}
                          </p>
                          <p
                            style="margin: 0;font-size: 14px;font-weight: 400; line-height: 22px;color: #333333;margin-top: 8px;">
                            {{.Content}}
                          </p>
                        </div>
                      </div>
                      {{if .AttachFiles}}
                      <table
                        style="vertical-align: top;border-collapse: collapse;line-height: inherit;color: #000000;margin-bottom:24px;"
                        role="presentation" cellpadding="0" cellspacing="0" width="100%" border="0">
                        <tbody style="line-height: inherit;">
                          {{range .AttachFiles}}
                          <tr
                            style="vertical-align: top;border-collapse: collapse;line-height: inherit;overflow-wrap:break-word;word-break:break-word;padding:10px;font-family:arial,helvetica,sans-serif;"
                            align="left">
                            {{range .}}
                            <td
                              style="vertical-align: top;border-collapse: collapse;line-height: inherit;color: #000000;overflow-wrap:break-word;word-break:break-word;padding:0px;font-family:arial,helvetica,sans-serif;"
                              align="left">

                              <img align="center" border="0" src="{{.}}" alt="乐闻世界"
                                title="乐闻世界"
                                style="line-height: inherit;outline: none;text-decoration: none;-ms-interpolation-mode: bicubic;clear: both;display: inline-block !important;border: none;height: auto;float: none;width: 80%;max-width: 300px;margin-top: 8px;" />
                            </td>
                            {{end}}
                          </tr>
                          {{end}}
                        </tbody>
                      </table>
                      {{end}}
                      {{end}}
                    </div>
                  </div>
                </div>
              </div>
            </div>
          </div>
        </td>
      </tr>
    </tbody>
  </table>
</body>

</html>
```

### 2. Template 注入变量

根据 HTML 模版中提取的变量占位符，定义业务动态变量内容。

```javascript
package main

import (
	"fmt"
	"net/http"
	"text/template"
)

type TicketLog struct {
	Title        string
	Time         string
	Content      string
	IsRespondent bool
	AttachFiles  [][]string // 两个一组
}

type TicketInfo struct {
	Picture string
	Title   string
	Desc    string
	Warning string
	Logs    []TicketLog
}

func renderHtml(responseWriter http.ResponseWriter, request *http.Request) {
	// 解析指定文件生成模板对象
	tmpl, err := template.ParseFiles("./templates/levenx.html")
	if err != nil {
		fmt.Println("create template failed, err:", err)
		return
	}

	responseWriter.Header().Set("Content-Type", "text/html; charset=utf-8")

	ticketLogs := []TicketLog{
		{
			Title:        "[乐闻的回复]",
			Time:         "2022.05.05 05:05:05",
			Content:      "这是被投诉方的回复这是被投诉方的回复 这是被投诉方的回复 这是被投诉方的回复 这是被投诉方的回复 这是被投诉方的回复 这是被投诉方的回复",
			IsRespondent: true,
			AttachFiles: [][]string{
				{"http://localhost:3000/static/attach.png", "http://localhost:3000/static/attach.png"},
				{"http://localhost:3000/static/attach.png", "http://localhost:3000/static/attach.png"},
			},
		},
		{
			Title:        "[客服的回复]",
			Time:         "2022.05.05 05:05:05",
			Content:      "对不起，给您的使用带来了困扰，我们会尽快解决你的问题。",
			IsRespondent: false,
		},
	}

	ticketInfo := TicketInfo{
		Picture: "http://localhost:3000/static/logo.png",
		Title:   "乐闻的工单",
		Desc:    "对于您的工单12121，如果您对回复有任何疑问，可以直接回复此邮件。",
		Warning: "请不要修改邮件标题，否则我们的团队无法收到您的回复",
		Logs:    ticketLogs,
	}

	tmpl.Execute(responseWriter, ticketInfo)
}
```

### 3. 启动 Http 服务器，向网页输出动态HTML内容

启动 http server，支持静态资源，static 文件夹中的所有静态资源都可以通过http服务访问到。

```javascript
func main() {
	fs := http.FileServer(http.Dir("assets/"))
	http.Handle("/static/", http.StripPrefix("/static/", fs))

	http.HandleFunc("/", renderHtml)
	err := http.ListenAndServe("127.0.0.1:3000", nil)
	if err != nil {
		fmt.Println("HTTP server failed,err:", err)
		return
	}
	fmt.Print("访问 http://localhost:3000")
}
```

尝试访问 `http://localhost:3000`

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/BlaVsNLH76vpT0zW.png)

## 发送邮件

邮件传输需要遵循特定的协议，其中使用SMTP协议即可完成邮件的发送和回复。golang 有现成的工具库支持了邮件发送，我们接下来将实现发送上面Template模板输出的内容到特定的邮箱。

1. 安装依赖库

```javascript
go get github.com/jordan-wright/email
```

1. 获取邮件服务商的邮件授权码，比如使用QQ的企业账号

   根据下面截图开启SMTP服务，生成授权码

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/FxoLg6AVLdVAeuTf.png)

   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/nOrFp6Q5eTiiZHbb.png)
2. 使用授权码，开始发送邮件

   ```javascript
    import (
   	"fmt"
   	"net/http"
   	"text/template"
     "net/smtp"
     "github.com/jordan-wright/email"
     "log"
     "bytes"
   )  

   func sendMail() {
     body := new(bytes.Buffer)
   	tmpl.Execute(body, ticketInfo)

     e := email.NewEmail()
     //设置发送方的邮箱
     e.From = "乐闻 <1025534801@qq.com>"
     // 设置接收方的邮箱
     e.To = []string{"接受邮件的邮箱"}
     //设置主题
     e.Subject = "乐闻的工单"
     //设置文件发送的内容
     e.HTML = body.Bytes()
     auth := smtp.PlainAuth("", "发送邮件的邮箱", "授权码", "smtp.qq.com");
     //设置服务器相关的配置
     error := e.Send("smtp.qq.com:25",auth)
     if error != nil {
         log.Fatal(error)
     }
   }

   ```
   ![Untitled.png](https://cdn.portal.levenx.com/levenx-world/psTnt27Kmf1LSwLA.png)

邮件是常见的触达用户的途径，本文详细介绍基于golang的模版引擎构建漂亮的邮件内容，并且发送给模板用户。思路go内置了html/template模块，类似ejs模块引擎。利用template能力可以将变量动态的注入到HTML字符串中，最终获得成功注入变量的字符串内容。具体实现思路：首先根据设计图输出静态的HTML文件；然后将HTML中需要变化的内容提取变量占位符；利用template工具将H

Golang 使用 Template 引擎构建漂亮的邮件内容并且发送邮件

## 背景

Go 自2012年发布至今，由于其出色的性能与并发处理能力，已经被各大互联网公司应用到成熟的产品服务上，目前本人从事项目的后端服务已经从Python全部切换到Go。

于是决定跟后端大佬系统的学习一下Golang语言，然后将自己学习过程中遇到的问题和感悟记录下来，方便自己后续巩固学习和有需要的同学借鉴经验。

## 开发环境

### 1. 安装 Golang 环境

访问 golang 官网下载环境安装包：[https://go.dev/dl/](https://go.dev/dl/)

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/on-M6bV-CICQFLPk.png)

下载后根据指引下一步安装即可，最终安装完成后，打开命令行工具，输入 `go version`，看看能否正常输出go的版本号。

如果正常输入go 版本，说明go的运行环境已经安装成功。

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/aNO_FVZFiZYozDE7.png)

### 2. 安装 VSCode

VsCode 的安装就更加容易，直接在官网下载软件包按照指引安装即可。

[https://code.visualstudio.com/](https://code.visualstudio.com/)

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/w7CDtemP6vK_Q76p.png)

### 3. 安装 Go 插件

VSCode 的插件功能中输入 go 关键字，然后找到下图中的插件，并安装。

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/i2DScjvgGQwaVo3_.png)

### 4. 安装 Go 插件依赖工具

快捷键 Ctrl + Shift + p 打开命令面板，输入go install tools，选择第一项 Go: install/Update Tools

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/pQPT0uXmXpLaSWU9.png)

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/AMyamI2pLXn3Rkoj.png)

### 5. 初始化 Go 项目

1. go mod 初始化

```javascript
go mod init levenx.com/mail
```

1. 新建项目入口文件 `main.go` ,并输入下面代码

```javascript
package main
import "fmt"
func main() {
    fmt.Println("你好，乐闻世界")
}
```

1. 命令行执行运行 go 脚本

```javascript
go run main.go
```

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/8fcrr1mRZyPdvrkf.png)

## Debug 断点调试

在程序运行的过程中，将运行程序停在具体的断点处，查询当前程序运行的状态。

1. VSCode 创建 `launch.json`

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/rYEW09IrU0wdJjbS.png)

`launch.json` 文件内容

```javascript
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Launch Package",
            "type": "go",
            "request": "launch",
            "mode": "auto",
            "program": "${fileDirname}"
        }
    ]
}
```

1. 运行go程序

![Untitled.png](https://cdn.portal.levenx.com/levenx-world/UKI-1KgXubQ1Obhd.png)

## 总结

VSCode 作为前端开发最喜欢的开发编辑器，同样能够支持所有的开发语言。使用熟悉的编程工具，会让我们更加容易上手新学的开发语言。


Go自2012年发布至今，由于其出色的性能与并发处理能力，已经被各大互联网公司应用到成熟的产品服务上，目前本人从事项目的后端服务已经从Python全部切换到Go。于是决定跟后端大佬系统的学习一下Golang语言，然后将自己学习过程中遇到的问题和感悟记录下来，方便自己后续巩固学习和有需要的同学借鉴经验。开发环境1.安装Golang环境访问golang官网下载环境安装包：https://go.de

在 VSCode 上开发 Golang 程序，并支持 debug断点调试

前端

客户端

算法

工程

产品

信息安全

运维

Go，也称为 Golang，是一种开源的编程语言，由 Google 开发。Go 是一种静态类型、编译型、并发型的语言，它被设计为一种简单、快速、可靠和高效的语言。Go 语言的语法类似于 C 语言，但也借鉴了其他语言的一些特性，如 Python 和 Java。

Go 语言的设计目标是提供一种简单、易于学习和使用的语言，同时具有高效的执行速度和并发处理能力。Go 语言的主要特点包括：

1. 并发支持：Go 语言内置了并发支持，可以轻松地编写高并发的程序，而不需要额外的库或框架。

2. 内存管理：Go 语言有自己的垃圾收集器，可以自动管理内存，避免内存泄漏和悬垂指针等问题。

3. 快速编译：Go 语言的编译速度非常快，可以在几秒钟内编译大部分代码。

4. 简单易学：Go 语言的语法简单，易于学习和使用，同时也提供了足够的功能和扩展性。

5. 跨平台支持：Go 语言可以在各种操作系统和硬件平台上运行，包括 Windows、Linux、macOS、Android、iOS 等。

6. 开源：Go 语言是一个开源项目，可以自由下载、使用和修改。

Go 语言被广泛应用于网络编程、云计算、大数据处理、系统编程、区块链等领域。许多知名公司和组织，如 Google、Uber、Docker、Kubernetes、Cloudflare 等都在使用 Go 语言开发自己的项目和服务。