Go语言编码规范

规范旨在为日常Go项目开发提供一个代码的规范指导，方便团队形成一个统一的代码风格，提高代码的可读性，规范性和统一性。本规范将从命名规范，注释规范，代码风格和 Go 语言提供的常用的工具这几个方面做一个说明。该规范参考了 go 语言官方代码的风格制定。

命名规范

命名是代码规范中很重要的一部分，统一的命名规则有利于提高的代码的可读性，好的命名仅仅通过命名就可以获取到足够多的信息。

Go在命名时以字母a到Z或a到Z或下划线开头，后面跟着零或更多的字母、下划线和数字(0到9)。Go不允许在命名时中使用@、$和%等标点符号。Go是一种区分大小写的编程语言。因此，Manpower和manpower是两个不同的命名。

当命名（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）。命名如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 private ）。

包命名

保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，尽量和标准库不要冲突。包名应该为小写单词，不要使用下划线或者混合大小写。

package demo

package main

文件命名

尽量采取有意义的文件名，简短，有意义，应该为小写单词，使用下划线分隔各个单词。

my_test.go

结构体命名

采用驼峰命名法，首字母根据访问控制大写或者小写。

struct 申明和初始化格式采用多行，例如下面：

// 多行申明
type User struct{
 Username string
 Email string
}
?
// 多行初始化
u :=User{
 Username: "avatar",
 Email: "avatar@gmail.com",
}

接口命名

命名规则基本和上面的结构体类型。

单个函数的结构名以 “er” 作为后缀，例如 Reader , Writer 。

type Reader interface {
 Read(p []byte) (n int, err error)
}

变量命名

和结构体类似，变量名称一般遵循驼峰法，首字母根据访问控制原则大写或者小写，但遇到特有名词时，需要遵循以下规则：
如果变量为私有，且特有名词为首个单词，则使用小写，如 apiClient
其它情况都应当使用该名词原有的写法，如 APIClient、repoID、UserID
错误示例：UrlArray，应该写成 urlArray 或者 URLArray
若变量类型为 bool 类型，则名称应以 Has, Is, Can 或 Allow 开头

var isExist bool
var hasConflict bool
var canManage bool
var allowGitHook bool

常量命名

常量均需使用全部大写字母组成，并使用下划线分词。

const APP_VER="1.0"

如果是枚举类型的常量，需要先创建相应类型：

type Scheme string
?
const (
 HTTP Scheme="http"
 HTTPS Scheme="https"
)

关键字

下面的列表显示了Go中的保留字。这些保留字不能用作常量或变量或任何其他标识符名称。

注释

Go提供C风格的/ /块注释和C ++风格的//行注释。行注释是常态；块注释主要显示为包注释，但在表达式中很有用或禁用大量代码。

单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释
多行注释也叫块注释，均已以 / 开头，并以 / 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段

go 语言自带的 godoc 工具可以根据注释生成文档，生成可以自动生成对应的网站（ http://golang.org 就是使用 godoc 工具直接生成的），注释的质量决定了生成的文档的质量。每个包都应该有一个包注释，在package子句之前有一个块注释。对于多文件包，包注释只需要存在于一个文件中，任何一个都可以。包评论应该介绍包，并提供与整个包相关的信息。它将首先出现在godoc页面上，并应设置下面的详细文档。

详细的如何写注释可以参考：http://golang.org/doc/effective_go.html#commentary

包注释

每个包都应该有一个包注释，一个位于package子句之前的块注释或行注释。包如果有多个go文件，只需要出现在一个go文件中（一般是和包同名的文件）即可。包注释应该包含下面基本信息(请严格按照这个顺序，简介，创建人，创建时间）：

包的基本简介（包名，简介）
创建者，格式：创建人： rtx 名
创建时间，格式：创建时间： yyyyMMdd

例如 util 包的注释示例如下:

// util 包， 该包包含了项目共用的一些常量，封装了项目中一些共用函数。
// 创建人： xlli5
// 创建时间： 20190522

结构（接口）注释

每个自定义的结构体或者接口都应该有注释说明，该注释对结构进行简要介绍，放在结构体定义的前一行，格式为：结构体名，结构体说明。同时结构体内的每个成员变量都要有说明，该说明放在成员变量的后面（注意对齐），实例如下：

// User ， 用户对象，定义了用户的基础信息
type User struct{
 Username string // 用户名
 Email string // 邮箱
}

函数（方法）注释

每个函数，或者方法（结构体或者接口下的函数称为方法）都应该有注释说明，函数的注释应该包括三个方面（严格按照此顺序撰写）：

简要说明，格式说明：以函数名开头，“，”分隔说明部分
参数列表：每行一个参数，参数名开头，“，”分隔说明部分
返回值：每行一个返回值

示例如下：

// NewtAttrModel ， 属性数据层操作类的工厂方法
// 参数：
// ctx ： 上下文信息
// 返回值：
// 属性操作类指针
func NewAttrModel(ctx *common.Context) *AttrModel {
}

代码逻辑注释

对于一些关键位置的代码逻辑，或者局部较为复杂的逻辑，需要有相应的逻辑说明，方便其他开发者阅读该段代码，实例如下：

// 从 Redis 中批量读取属性，对于没有读取到的 id ， 记录到一个数组里面，准备从 DB 中读取
xxxxx
xxxxxxx
xxxxxxx

注释风格

统一使用中文注释，对于中英文字符之间严格使用空格分隔，这个不仅仅是中文和英文之间，英文和中文标点之间也都要使用空格分隔，例如：

// 从 Redis 中批量读取属性，对于没有读取到的 id ， 记录到一个数组里面，准备从 DB 中读取

上面 Redis 、 id 、 DB 和其他中文字符之间都是用了空格分隔。

建议全部使用单行注释
和代码的规范一样，单行注释不要过长，禁止超过 120 字符

代码风格

缩进和折行

缩进直接使用 gofmt 工具格式化即可（gofmt 是使用 tab 缩进的）
折行方面，一行最长不超过120个字符，超过的请使用换行展示，尽量保持格式优雅

我们使用Goland开发工具，可以直接使用快捷键：ctrl+alt+L，即可。

语句的结尾

Go语言中是不需要类似于Java需要冒号结尾，默认一行就是一条数据

如果你打算将多个语句写在同一行，它们则必须使用。

括号和空格

括号和空格方面，也可以直接使用 gofmt 工具格式化（go 会强制左大括号不换行，换行会报语法错误），所有的运算符和操作数之间要留空格。

// 正确的方式
if a > 0 {
?
}
?
// 错误的方式
if a>0 // a ，0 和 > 之间应该空格
{ // 左大括号不可以换行，会报语法错误
?
}

import 规范

import在多行的情况下，goimports会自动帮你格式化，但是我们这里还是规范一下import的一些规范，如果你在一个文件里面引入了一个package，还是建议采用如下格式：

import (
 "fmt"
)

如果你的包引入了三种类型的包，标准库包，程序内部包，第三方包，建议采用如下方式进行组织你的包：

import (
 "encoding/json"
 "strings"
?
 "myproject/models"
 "myproject/controller"
 "myproject/utils"
?
 "github.com/astaxie/beego"
 "github.com/go-sql-driver/mysql"
)

有顺序的引入包，不同的类型采用空格分离，第一种实标准库，第二是项目包，第三是第三方包。

在项目中不要使用相对路径引入包：

// 这是不好的导入
import "../net"
?
// 这是正确的做法
import "github.com/repo/proj/src/net"

但是如果是引入本项目中的其他包，最好使用相对路径。

错误处理

错误处理的原则就是不能丢弃任何有返回err的调用，不要使用 _ 丢弃，必须全部处理。接收到错误，要么返回err，或者使用log记录下来
尽早return：一旦有错误发生，马上返回
尽量不要使用panic，除非你知道你在做什么
错误描述如果是英文必须为小写，不需要标点结尾
采用独立的错误流进行处理

// 错误写法
if err !=nil {
 // error handling
} else {
 // normal code
}
?
// 正确写法
if err !=nil {
 // error handling
 return // or continue, etc.
}
// normal code

测试

单元测试文件名命名规范为 example_test.go 测试用例的函数名称必须以 Test 开头，尽量避免使用 main 方法测试。例如：TestExample 每个重要的函数都要首先编写测试用例，测试用例和正规代码一起提交方便进行回归测试。

配置文件

编写代码时提供三套配置文件，分别是开发环境 [dev] , 测试环境 [test] , 现网环境 [prod] 。目录如下：

./
├── dev
│ ├── seelog.xml
│ └── service.yml
├── prod
│ ├── seelog.xml
│ └── service.yml
└── test
 ├── seelog.xml
 └── service.yml

常用工具

代码格式化

go 语言本身在代码规范性这方面也做了很多努力，很多限制都是强制语法要求，例如左大括号不换行，引用的包或者定义的变量不使用会报错，此外 go 还是提供了很多好用的工具帮助我们进行代码的规范，

gofmt 大部分的格式问题可以通过gofmt解决， gofmt 自动格式化代码，保证所有的 go 代码与官方推荐的格式保持一致，于是所有格式有关问题，都以 gofmt 的结果为准。

goimport 我们强烈建议使用 goimport ，该工具在 gofmt 的基础上增加了自动删除和引入包。

go get golang.org/x/tools/cmd/goimports

go vet vet工具可以帮我们静态分析我们的源码存在的各种问题，例如多余的代码，提前return的逻辑，struct的tag是否符合标准等。

go get golang.org/x/tools/cmd/vet

使用如下：

go vet .

依赖包管理

GoModule

Golang官方在1.11版本初步引入的GoModule模块。1.12版本正式开始支持。GoModule是官方提供的包管理解决方案。通过GoModule，开发者可以把工程放在GOPATH之外的位置。相比于之前的包管理方案: dep，vendor。GoModule的管理方案更加灵活。可以运行go mod help来看看GoModule中有哪些命令。

go mod init [module]：初始化.mod 包管理文件到当前工程。
go mod vendor：vendor版本的解决方案，将依赖复制到vendor下面。
go mod tidy：移除未用的模块，以及添加缺失的模块。
go mod verify：验证所有模块是否正确。

亮点：

使用replace替换无法直接获取的package 依赖包冲突问题自动查找包依赖

总结

两个等级: [S] 建议, [M] 必须。以下是细节。

代码组织结构

[M] 一个目录只包含一个包，模块复杂拆分子模块/子目录
[S] 内部项目GOPATH如果指向多个工作目录。公开项目为第一个工作区间（即 go get 默认下载到第一个目录）
[M] 非测试文件 (*_test.go) 禁止使用，简化包
[M] 禁止相对路径导入包
[S] 建议goimports或者IDE管理import
[S] 建议使用GoModule管理第三方包

代码风格

[M] 提交代码时 gofmt 格式化代码， golint 检查代码(使用IDE时默认这两个工具会自动用到)
[S] json 字符串建议使用反单引号(`)
[M] 文件名必须小写，允许下划线'_’，但头尾不能。避免与 _test.go 或者系统相关 _386.go 等冲突
[S] 文件名以功能为指引，不需要再出现模块名
[M] 目录名必须小写，允许中划线'-'，但头尾不能
[S] 不建议目录名出现下划线'_'
[M] 包名必须全部小写，无下划线，越短越好，尽量不要与标准库重名，禁止通过中划线连接多个单词
[S] 包名尽量与目录名一致
[M] 函数名和结构体名必须为大小写驼峰模式，最好不带特殊字符如划线等
[S] 函数名建议动词或者动宾结构单词，结构体建议名词或者动名词
[S] 常量和枚举名，大小写驼峰法，不允许下划线，第三方包例外。
[M] 函数参数首字母小写，不能有下划线，按大小驼峰法
[S] 函数参数按紧密程度安排位置，同类型参数应该相邻
[S] 参数不大于5个
[M] 变量名不允许下划线，大小写驼峰法，局部变量首字母小写，全局变量首字母大写
[S] 避免全局变量多使用， for 循环可用单字母
[M] 接口名大小写驼峰法，首字母大写，不能下划线，名词
[S] 接口名 'er' 结尾
[M] 复杂功能请多写注释备注，注释表达需清晰，不要啰嗦。注释标准暂时不强制，最好参考 godoc ，如包注释使用 /**/ ,首字母大写，注释后空一行，函数注释写在函数上方等。

总而言之，文件名和目录名，包名都必须小写。数据类型变量和参数等定义最好使用驼峰大小写法，不要使用下划线或者中划线

单元测试/程序效率

[S] 建议少使用 main 方法测试，而是使用 _test.go 做测试
[M] 与其他语言类似，避免多级 if 或者 for 嵌用，代码层次需简单，绕脑层次少
[M] 避免有歧义的命名，如 IsTrue 变量，if(!IsTrue).
[M] 请熟悉 Go 语言各特征，避免低效用法。

用了近十年的 C# 转到 Go 是一个有趣的旅程。有时，我陶醉于 Go 的简洁[1]；也有些时候，当熟悉的 OOP （面向对象编程）模式[2]无法在 Go 代码中使用的时候会感到沮丧。幸运的是，我已经摸索出了一些写 HTTP 服务的模式，在我的团队中应用地很好。

当在公司项目上工作时，我倾向把可发现性放在最高的优先级上。这些应用会在接下来的 20 年运行在生产环境中，必须有众多的开发人员和网站可靠性工程师（可能是指运维）来进行热补丁，维护和调整工作。因此，我不指望这些模式能适合所有人。

Mat Ryer 的文章[3]是我使用 Go 试验 HTTP 服务的起点之一，也是这篇文章的灵感来源。

代码组成

Broker

一个 Broker 结构是将不同的 service 包绑定到 HTTP 逻辑的胶合结构。没有包作用域结级别的变量被使用。依赖的接口得益于了 Go 的组合[4]的特点被嵌入了进来。

type Broker struct {
    auth.Client             // 从外部仓库导入的身份验证依赖（接口）
    service.Service         // 仓库的业务逻辑包（接口）

    cfg    Config           // 该 API 服务的配置
    router *mux.Router      // 该 API 服务的路由集
}

broker 可以使用阻塞[5]函数 New() 来初始化，该函数校验配置，并且运行所有需要的前置检查。

func New(cfg Config, port int) (*Broker, error) {
    r := &Broker{
        cfg: cfg,
    }

    ...

    r.auth.Client, err = auth.New(cfg.AuthConfig)
    if err != nil {
        return nil, fmt.Errorf("Unable to create new API broker: %w", err)
    }

    ...

    return r, nil
}

初始化后的 Broker 满足了暴露在外的 Server 接口，这些接口定义了所有的，被 route 和中间件（middleware）使用的功能。service 包接口被嵌入，这些接口与 Broker 上嵌入的接口相匹配。

type Server interface {
    PingDependencies(bool) error
    ValidateJWT(string) error

    service.Service
}

web 服务通过调用 Start() 函数来启动。路由绑定通过一个闭包函数[6]进行绑定，这种方式保证循环依赖不会破坏导入周期规则。

func (bkr *Broker) Start(binder func(s Server, r *mux.Router)) {
    ...

    bkr.router = mux.NewRouter().StrictSlash(true)
    binder(bkr, bkr.router)

    ...

    if err := http.Serve(l, bkr.router); errors.Is(err, http.ErrServerClosed) {
        log.Warn().Err(err).Msg("Web server has shut down")
    } else {
        log.Fatal().Err(err).Msg("Web server has shut down unexpectedly")
    }
}

那些对故障排除（比如，Kubernetes 探针[7]）或者灾难恢复方案方面有用的函数，挂在 Broker 上。如果被 routes/middleware 使用的话，这些仅仅被添加到 webserver.Server 接口上。

func (bkr *Broker) SetupDatabase() { ... }
func (bkr *Broker) PingDependencies(failFast bool)) { ... }

启动引导

整个应用的入口是一个 main 包。默认会启动 Web 服务。我们可以通过传入一些命令行参数来调用之前提到的故障排查功能，方便使用传入 New() 函数的，经过验证的配置来测试代理权限以及其他网络问题。我们所要做的只是登入运行着的 pod 然后像使用其他命令行工具一样使用它们。

func main() {
    subCommand := flag.String("start", "", "start the webserver")

    ...

    srv := webserver.New(cfg, 80)

    switch strings.ToLower(subCommand) {
    case "ping":
        srv.PingDependencies(false)
    case "start":
        srv.Start(BindRoutes)
    default:
        fmt.Printf("Unrecognized command %q, exiting.", subCommand)
        os.Exit(1)
    }
}

HTTP 管道设置在 BindRoutes() 函数中完成，该函数通过 ser.Start() 注入到服务（server）中。

func BindRoutes(srv webserver.Server, r *mux.Router) {
    r.Use(middleware.Metrics(), middleware.Authentication(srv))
    r.HandleFunc("/ping", routes.Ping()).Methods(http.MethodGet)

    ...

    r.HandleFunc("/makes/{makeID}/models/{modelID}", model.get(srv)).Methods(http.MethodGet)
}

中间件

中间件（Middleware）返回一个带有 handler 的函数，handler 用来构建需要的 http.HandlerFunc。这使得 webserver.Server 接口被注入，同时所有的安静检查只在启动时执行，而不是在所有路由调用的时候。

func Authentication(srv webserver.Server) func(h http.Handler) http.Handler {
    if srv == nil || !srv.Client.IsValid() {
        log.Fatal().Msg("a nil dependency was passed to authentication middleware")
    }

    // additional setup logic
    ...

    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            token := strings.TrimSpace(r.Header.Get("Authorization"))
            if err := srv.ValidateJWT(token); err != nil {
                ...
                w.WriteHeader(401)
                w.Write([]byte("Access Denied"))

                return
            }

            next.ServeHTTP(w, r)
        }
    }
}

路由

路由有着与中间件有着类似的套路——简单的设置，但是有着同样的收益。

func GetLatest(srv webserver.Server) http.HandlerFunc {
    if srv == nil {
        log.Fatal().Msg("a nil dependency was passed to the `/makes/{makeID}/models/{modelID}` route")
    }

    // additional setup logic
    ...

    return func(w http.ResponseWriter, r *http.Request) {
        ...

        makeDTO, err := srv.Get
    }
}

目录结构

代码的目录结构对可发现性进行了高度优化。

├── app/
|   └── service-api/**
├── cmd/
|   └── service-tool-x/
├── internal/
|   └── service/
|       └── mock/
├── pkg/
|   ├── client/
|   └── dtos/
├── (.editorconfig, .gitattributes, .gitignore)
└── go.mod

app/ 用于项目应用——这是新来的人了解代码倾向的切入点。dd

./service-api/ 是该仓库的微服务 API；所有的 HTTP 实现细节都在这里。

cmd/ 是存放命令行应用的地方。
internal/ 是不可以被该仓库以外的项目引入的一个特殊目录[8]。

./service/ 是所有领域逻辑（domain logic）所在的地方；可以被 service-api，service-tool-x，以及任何未来直接访问这个目录可以带来收益的应用或者包所引入。

pkg/ 用于存放鼓励被仓库以外的项目所引入的包。

./client/ 是用于访问 service-api 的 client 库。其他团队可以使用而不是自己写一个 client，并且我们可以借助我们在 cmd/ 里面的 CI/CD 工具来 “dogfood it[9]” （使用自己产品的意思）。
./dtos/ 是存放项目的数据传输对象，不同包之间共享的数据且以 json 形式在线路上编码或传输的结构体定义。没有从其他仓库包导出的模块化的结构体。/internal/service 负责这些 DTO （数据传输对象）和自己内部模型的相互映射，避免实现细节的遗漏（如，数据库注释）并且该模型的改变不破坏下游客户端消费这些 DTO。

.editorconfig，.gitattributes，.gitignore 因为所有的仓库必须使用 .editorconfig，.gitattributes，.gitignore[10]！
go.mod 甚至可以在有限制的且官僚的公司环境[11]工作。

最重要的：每个包只负责意见事情，一件事情！

HTTP 服务结构

└── service-api/
    ├── cfg/
    ├── middleware/
    ├── routes/
    |   ├── makes/
    |   |   └── models/**
    |   ├── create.go
    |   ├── create_test.go
    |   ├── get.go
    |   └── get_test.go
    ├── webserver/
    ├── main.go
    └── routebinds.go

./cfg/ 用于存放配置文件，通常是以 JSON 或者 YAML 形式保存的纯文本文件，它们也应该被检入到 Git 里面（除了密码，秘钥等）。
./middleware 用于所有的中间件。
./routes 采用类似应用的类 RESTFul 形式的目录对路由代码进行分组和嵌套。
./webserver 保存所有共享的 HTTP 结构和接口（Broker，配置，Server等等）。
main.go 启动应用程序的地方（New()，Start()）。
routebinds.go BindRoutes() 函数存放的地方。

你觉得呢？

如果你最终采用了这种模式，或者有其他的想法我们可以讨论，我乐意听到这些想法！

via: https://www.dudley.codes/posts/2020.05.19-golang-structure-web-servers/

作者：James Dudley[12]译者：dust347[13]校对：unknwon[14]

本文由 GCTT[15] 原创编译，Go 中文网[16] 荣誉推出

参考资料

[1]

简洁: https://www.youtube.com/watch?v=rFejpH_tAHM

[2]

模式: https://en.wikipedia.org/wiki/Software_design_pattern

[3]

Mat Ryer 的文章: https://pace.dev/blog/2018/05/09/how-I-write-http-services-after-eight-years.html

[4]

Go 的组合: https://www.ardanlabs.com/blog/2015/09/composition-with-go.html

[5]

阻塞: https://stackoverflow.com/questions/2407589/what-does-the-term-blocking-mean-in-programming

[6]

闭包函数: https://gobyexample.com/closures

[7]

Kubernetes 探针: https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/）0

[8]

特殊目录: https://dave.cheney.net/2019/10/06/use-internal-packages-to-reduce-your-public-api-surface

[9]

dogfood it: https://en.wikipedia.org/wiki/Eating_your_own_dog_food

[10]

所有的仓库必须使用 .editorconfig，.gitattributes，.gitignore: https://www.dudley.codes/posts/2020.02.16-git-lost-in-translation/

[11]

有限制的且官僚的公司环境: https://www.dudley.codes/posts/2020.04.02-golang-behind-corporate-firewall/

[12]

James Dudley: https://www.dudley.codes/

[13]

dust347: https://github.com/dust347

[14]

unknwon: https://github.com/unknwon

[15]

GCTT: https://github.com/studygolang/GCTT

[16]

Go 中文网: https://studygolang.com/

想构建一个本地 Go 桌面应用程序，有几种方法可以做到：

Electron[1]：将 Node.js[2] 和 Chromium[3] 浏览器绑定在一起，以创建一个打包的本地 Web 应用程序。可与 Go 框架（例如 go-app[4] 或 go-astilectron[5]）一起使用。
Lorca[6]：使用本地安装的 Chrome 浏览器，通过 dev-tools communication protocol[7] 实现。
Webview[8]：使用 webview[9] 创建一个本地窗口，并使用 CGo 绑定在其中渲染应用程序。

我已经写过有关构建一个简单的 electron 应用程序的文章[10]，因此本文将探讨如何使用 Lorca 和 Webview 构建应用程序，然后比较这三种的不同。

Lorca

Go 中一个简单的 Lorca[11] 应用：

func main() {
 // Create UI with data URI
 ui, _ := lorca.New("data:text/html,"+url.PathEscape(`
 <html>
  <head><title>Hello</title></head>
  <body><h1>Hello, world!</h1></body>
 </html>
 `), "", 600, 200)
 defer ui.Close()
 // Create a GoLang function callable from JS
 ui.Bind("hello", func() string { return "World!" })
 // Call above `hello` function then log to the JS console
 ui.Eval("hello().then( (x) => { console.log(x) })")
 // Wait until UI window is closed
 <-ui.Done()
}

因为复杂性被隐藏了，所以看起来非常简单！上面的代码打开一个 Chome 窗口，通过 websocket 连接到其 dev-tools[12] 端点，发送要加载的 HTML，并提供 Go 和 JS 之间的通信：

更酷的是，您可以在 Chrome 中调用 JS 函数并在 Go 中获取输出：

n := ui.Eval(`Math.random()`).Float()
fmt.Println(n)

使用这个库是如此容易，如此直观，如此实用，以至于我刚使用它时感到困惑。我以为一定有陷阱，不会这么简单。但是没有，它就是这么简单。

另外一个好处是您可以使用 Chrome 开发工具来帮助调试任何问题或调整布局。另外，鉴于我自 2014 年以来[13]一直在写 Promise，我喜欢使用 JS Promise 在 Go 和 JS 之间实现异步调用。

Lorca 的最大缺点是，由于它使用 Chrome，因此某些应用程序详细信息（如系统菜单，图标，标题）无法自定义。然后，需要在应用程序优化和简单应用程序之间进行权衡。根据您构建内容的不同，有好有弊，例如，如果您正在构建内部工具，那会很好，但是对于企业应用程序，这可能看起来并不好。

Webview

Webview[14] 是一个库，可帮助直接在本地组件之上构建 Web 应用程序。执行此操作的代码如下：

func main() {
 w := webview.New(true)
 defer w.Destroy()
 w.SetSize(600, 200, webview.HintNone)
 // Create a GoLang function callable from JS
 w.Bind("hello", func() string { return "World!" })

 // Create UI with data URI
 w.Navigate(`data:text/html,
  <!doctype html>
  <html>
   <head><title>Hello</title></head>
   <body><h1>Hello, world!</h1></body>
   <script> hello().then((x) => { console.log(x) }) </script>
  </html>`)

 w.Run()
}

这与 Lorca 非常相似，我认为 Lorca 也是基于 Webview 的。尽管与 Lorca 相似，但输出还是有些不同：

从上图可以看到 Webview 应用程序窗口没有阴影，没有边框，并且在屏幕的左下角进行了初始化。可以通过将Window返回一个 unsafe.Pointer到 OS 依赖的窗口对象的方法（在 macOS 中是 NSWindow）进行定制。这是开始难的地方。

要使用该 Window 对象，我们必须将 Go 的绑定写入本地组件。举例来说，如果我们希望我们的窗口居中启动，我们会调用 NSWindow 的 Center 方法。因此，我们需要在三个文件中写绑定（改编自 gogoa[15]）：

ns_window.go

package main
// #cgo CFLAGS: -x objective-c
// #cgo LDFLAGS: -framework Cocoa
//#include "ns_window.h"
import "C"
import "unsafe"
type NSWindow struct {
 ptr unsafe.Pointer
}
func (self *NSWindow) Center() {
 C.Center(self.ptr)
}

ns_window.h

#include <Cocoa/Cocoa.h>
void Center(void *);

ns_window.m

#include "ns_window.h"
void Center(void *self) {
  NSWindow *window = self;
  [window center];
}

然后在main()函数中，我们可以将窗口居中：

window := NSWindow {w.Window()}
window.Center()

与 Lorca 不同，Webview 可以针对我们的应用程序进行完全自定义。问题在于它需要一些工作。

Webview 的一些其他部分使得用它变得有些困难：

如果使用 Bazel 和 gazelle，则webview生成的Build.bazel文件不正确，clinkopts=["-framework WebKit"] 必须对其进行修补。
调用 w.Init 仅在w.Navigate被调用时有效，但随后w.Eval调用将停止工作。
要设置标题，您可以如上所述编写绑定，或者您必须使用Dispatch方法w.Dispatch(func() { w.SetTitle("Title") })。

我不确定有多少是Webview，有多少是 NSWindow。我需要进行更多的调查和学习，才能更清楚地说明这些发生的原因。

Electron

我之前的文章[16]是关于构建一个简单的 Electron 应用程序的，该应用程序如下所示：

Electron 用于许多大型产品，例如 VSCode。这可能是因为将所有内容捆绑到一个应用程序中使可移植性变得更加简单，并且可以广泛地定制应用程序。将应用程序与浏览器和 Node.js 捆绑在一起的不利之处在于，它导致程序 非常庞大。

让 Go 与 Electron 一起工作也有些困难。但有一些框架可以简化[17]此过程，例如 go-astilectron[18]，不过这些框架很复杂，并且大多数功能不完整。另一种方法可能是使用我之前写过的[19] Go 编译为 WASM ，但这也不是简单的解决方案。

Electron 的优势在于它是便携式的，可定制的，并且经过了应用程序分发的严格测试。只是和 Go 结合有点复杂。

三者比较

我认为要进行的主要比较是可定制性与简单性。到目前为止，Lorca 是最简单的，其可定制性非常有限，Webview 可以完全自定义，但有些困难，而 Electron 则可以完全自定义，但很难与 Go 一起使用。

同样，框架之间的捆绑包大小也有很大差异。Lorca 的二进制文件大小为 8.7 MB，Webview 的大小为 3.7Mb，Electron 的大小为 157Mb。

调试工具也有所不同：Lorca 和 Electron 使用 Chrome 开发工具，而 Webview 使用 Safari 开发工具。

结论

Lorca 和 Webview 都可以与 Go 一起很好地使用，最终二进制较小，并且具有类似的 API。主要区别在于基础渲染器（本机）和调试工具。

我认为 Electron 与 Go 一起使用可能太复杂了，但没有太多困难。

一个潜在的工作流程是在开发和 Webview 分发期间使用 Lorca。Lorca 提供了用于调试和开发的熟悉工具，其中 Webview 提供了可分发的可定制性。Lorca 也是很好的备份，可以交叉编译到 Webview 不支持的其他操作系统。

注意：还有更多类似的选项，wails[20] 或 gotk[21] 可以提供其他方式来构建/分发应用程序。

作者：Graham Jenson
原文链接：https://maori.geek.nz/golang-desktop-app-webview-vs-lorca-vs-electron-a5e6b2869391
译者：polaris

参考资料

[1]

Electron: https://www.electronjs.org/

[2]

Node.js: https://nodejs.org/

[3]

Chromium: https://www.chromium.org/

[4]

go-app: https://github.com/maxence-charriere/go-app

[5]

go-astilectron: https://github.com/asticode/go-astilectron

[6]

Lorca: https://github.com/zserge/lorca

[7]

dev-tools communication protocol: https://chromedevtools.github.io/devtools-protocol/

[8]

Webview: https://github.com/webview/webview

[9]

webview: https://developer.apple.com/documentation/webkit/webview

[10]

构建一个简单的 electron 应用程序的文章: https://maori.geek.nz/building-an-electron-app-with-bazel-d124ed550957

[11]

Lorca: https://github.com/zserge/lorca

[12]

dev-tools: https://chromedevtools.github.io/devtools-protocol/

[13]

自 2014 年以来: https://maori.geek.nz/jquery-promises-and-deferreds-i-promise-this-will-be-short-d10275f82717

[14]

Webview: https://github.com/webview/webview

[15]

gogoa: https://github.com/alediaferia/gogoa

[16]

之前的文章: https://maori.geek.nz/building-an-electron-app-with-bazel-d124ed550957

[17]

简化: https://github.com/asticode/go-astilectron

[18]

go-astilectron: https://github.com/asticode/go-astilectron

[19]

之前写过的: https://maori.geek.nz/a-web-app-using-bazel-golang-wasm-and-proto-c020914f4341

[20]

wails: https://github.com/wailsapp/wails

[21]

gotk: https://github.com/gotk3/gotk3

在线咨询

上一篇：Fastadmin框架聚合数字生活抵扣卡系统v2.
下一篇：HTML5学习笔记二-HTML5的新特性和优缺点

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商

Go语言编码规范

命名规范

包命名

文件命名

结构体命名

接口命名

变量命名

常量命名

关键字

注释

包注释

结构（接口）注释

函数（方法）注释

代码逻辑注释

注释风格

代码风格

缩进和折行

语句的结尾

括号和空格

import 规范

错误处理

测试

配置文件

常用工具

代码格式化

依赖包管理

总结

代码组织结构

代码风格

单元测试/程序效率

代码组成

Broker

启动引导

中间件

路由

目录结构

HTTP 服务结构

你觉得呢？

参考资料

Lorca

Webview

Electron

三者比较

结论

参考资料

您的项目需求