关于golang:行之有效的Golang编码规范

7次阅读

共计 3762 个字符，预计需要花费 10 分钟才能阅读完成。

相熟编码标准能够帮忙咱们写出可读性高，可测试性高的代码
同时编码标准也是小型重构的利器，当初咱们从命名，变量，循环，正文，函数等方面，谈谈如何从编码角度晋升整体我的项目品质。

1. 命名的首要要求是精确直观地表白用意，主要要求是简短。

除了一些大家比拟熟知的缩写外，不举荐应用缩写。
比方：sec 示意 second、str 示意 string、num 示意 number、doc 示意 document。

2. 命名的技巧是：动词➕宾语，也就是 ” 谁干了什么事 ”
比方：AddTopicDynamic => 增加主题动静

动词 -Add 宾语 -TopicDynamic

3. 用意义明确的常量代替魔法数字

有一次遇到一个 if 判断, 心里曾经 MMP 了，鬼晓得这个 count*5 代表什么意思😝

if (groupCount < count*5) {// 业务代码}

4. 分组命名常量
比方：redis 的 key

Dynamics      = "xxx"   // hash
GlobalDynamic = "xxx"   // 全局动静
DynamicPushed = "xxx"   // 用于标记动静是否已推送
-------------------------------------------------
// 应用前缀 Key 将常量分组，可读性更强
KeyDynamics      = "xxx"   // hash
KeyGlobalDynamic = "xxx"   // 全局动静
KeyDynamicPushed = "xxx"   // 用于标记动静是否已推送

1. 要控制变量的作用域，应该 private 的变量绝不 public。

2. 要控制变量的存活工夫，变量的存活工夫越短，代码越易读，重构起来越简略。
比方：在变量行将被应用时再初始化

// 优化前
func Demo() {
    paramA := "A"
    // 业务代码 1
    
    // 业务代码 2
    paramA = "B"
}
---------------------------------------
// 在变量行将被应用时再初始化，缩短变量生命周期
func Demo() {
    // 业务代码 1
    
    // 业务代码 2
    paramA := "A"
    paramA = "B"
}

3. 用布尔变量优化布尔判断

// 优化前
// 判断是否是提问者，主题必须已答复（answererId > 0）且不能是自问自答（actorId != answererId）func IsQuestioner(questionerId int64, actorId int64, answererId int64) bool {return actorId == questionerId && actorId != answererId && answererId > 0}
----------------------------------------------------------------------------------
// 用布尔变量优化布尔判断
// 判断是否是提问者，主题必须已答复（answererId > 0）且不能是自问自答（actorId != answererId）func IsQuestioner(questionerId int64, actorId int64, answererId int64) bool {
    isQuestioner := actorId == questionerId // 是提问者
    isNotAnswer := actorId != answererId    // 不是回答者
    isAlreadyAnswered := answererId > 0     // 问题曾经答复
    
    return isQuestioner && isNotAnswer && isAlreadyAnswered
}

1. 一个循环只做一件事。

2. 循环的内务操作（比方 index++ 这种），要么放在循环结尾，要么放在循环结尾。

3. 长循环应用有意义的循环变量名，并且能够把局部内容抽成一个子函数。

4. 函数内或循环内做数据校验时（比方 if 判断），正当应用 continue，break，return，让失常门路变得清晰。

5. 最多嵌套两层循环。

第四点和第五点看上面这个示例

// 假如上面是一段依据审核后果做相应操作的代码
// 嵌套了 3 层 if 判断，最初执行业务代码
func ReviewTopicHandler(reviewResult interface) (err error) {if reviewResult.IsValid() {if reviewResult.IsTopicType() {if reviewResult.GetStatus() != topic.StatusNormal {
                // 业务操作
                return
            }
        }
    }

    return 
}
------------------------------------------------------------
// 依据第四点和第五点的观点，利用 return 优化调嵌套 if
func ReviewTopicHandler(reviewResult interface) (err error) {if !reviewResult.IsValid() {Logger.Warnf("review result is invalid")
        return
    }
    if !reviewResult.IsTopicType() {Logger.Debugf("It's not a topic review result")
        return
    }
    if reviewResult.GetStatus() == topic.StatusNormal {Logger.Debugf("a normal topic. No any operation")
        return
    }

    // 业务操作
    return 
}

提倡高效正文，不合理的正文只会帮倒忙。
1. 不要用正文将你写的代码用文字翻译一遍。

2. 不要尝试用正文解释艰涩难懂的代码，正确的做法是重构代码。

3. 最好能够用一句话概述代码块做了什么。

心态：面向到职写正文

1. 函数不能过长，过长的函数不易测试，从中抽离出一些性能内聚的代码作为子函数，其可读性，可测试性，可复用性，可扩展性都会显著进步。

2. 利用空行宰割代码块，能够让代码逻辑更清晰

3. 尽量让函数内聚，只做一件事。（繁多职责准则）

// 假如上面这个函数负责构建一段将要推送给用户的文本。// 因为能推送给终端用户的内容无限，每个文本都限度了字符串长度，如下图所示
// 优化计划："限度文本长度" 是一个性能十分内聚的函数（合乎繁多职责），// 将它抽离成独自的函数，能够更好的复用代码，并且针对这个函数的单元测试也是非常高效的。func (s *Service) BuildContent() {
    var text string
    textRune := []rune(s.Text)
    if len(textRune) > ImMessageLength {text =  string(textRune[0:ImMessageLength-3]) + "..."
    }
    var nickName string
    nickNameRune := []rune(s.User.Nickname)
    if len(nickNameRune) > UserNameMaxLength {nickName =  string(nickNameRune[0:UserNameMaxLength-3]) + "..."
    }

    // 业务代码
    
    s.Content = nickName + text
}
---------------------------------------------------------
// 抽离出函数：SpiltOverMaxLenString
func (s *Service) BuildContent() {text := SpiltOverMaxLenString(s.Text, ImMessageLength)
    nickName := SpiltOverMaxLenString(s.User.Nickname, UserNameMaxLength)

    // 业务代码
    
    s.Content = nickName + text
}
func SpiltOverMaxLenString(input string, maxLen int) (output string) {aliasRune := []rune(input)
    if len(aliasRune) > maxLen {return string(aliasRune[0:maxLen-3]) + "..."
    }

    return input
}

4. 管制函数参数的个数，个别大于 6 个时能够思考用对象封装起来。

5. 不要用函数参数来控制代码逻辑。

这是我在萌新阶段最喜爱干的事，我已经写过相似这样 ” 离谱 ” 的代码：
这种代码通常能够分解成多个函数，更便于复用，测试

func Demo(action string) {
    switch action {
    case "createTopic": // 业务代码 A
    case "createComment": // 业务代码 B
    case "createAnswer": // 业务代码 C
    }
}
-------------------------------------------
func Demo(isDeleted bool) {if (isDeleted) {// 业务代码 A} else {// 业务代码 B}
}

写文章不易，求大家点个赞～蟹蟹各位啦～