Write an authentic Go code

This is a creation in Article, where the information may have evolved or changed.

The most authentic go code is the code of the Go standard library, and when available, you can see how Google's engineers are doing it.

1. Notes

You can use *////or add comments,//There should be a space after
If you want to add comments to the header of each file, you need to add a blank line to the copyright note and the package, or the copyright note will be used as a comment

// Copyright 2009 The Go Authors. All rights reserved.// Use of this source code is governed by a BSD-style// license that can be found in the LICENSE file./*Package net provides a portable interface for network I/O, includingTCP/IP, UDP, domain name resolution, and Unix domain sockets.......*/package net......

Note: The note should use a complete sentence, the first word of the note should be the indicator to be annotated, so that it is easy to find in Godoc;
Comments should . end with;

2. Declaration Slice

Use this method to declare slice:

var s []string

Instead of the following format

t := []string{}

Note: The former declares a nil slice, while the latter declares a non-slice with a length of 0 nil

3. Case of String

The error string should not be capitalized and should be written as:

fmt.Errorf("failed to write data.")

Rather than written:

fmt.Errorf("Failed to write data")

Because these strings may be concatenated with other strings, the combined string is abrupt if the words that begin with a capital letter are in the middle, unless these initials are fixed-use words.

Note: Abbreviations must be consistent, such as uppercase URLs or lowercase URLs;
Solid is generally declared as maxlength, instead of dividing max_length or maxlength with the following dashes;

4. Handling error rather than panic or ignoring

For the robustness of the code, do not use _ Ignore the error, but to deal with each error, although the code is cumbersome to write and do not ignore the error;

Try not to use panic;

5. Some names

The package name should be in the singular form, such as Util,model, not utils,models;

Receiver's name should be abbreviated, typically using one or two characters as receiver's name, such as:

func (f foo) method {    ...}

Some words may be written in a variety of ways, and should be consistent in the project, such as the Golang used:

// marshaling// unmarshaling// canceling// cancelation

Instead of:

// marshalling// unmarshalling// cancelling// cancellation

6. Empty string Check

The right way:

if s == "" {    ...}

Instead of:

if len(s) == 0 {    ...}

Not even:

if s == nil || s == ""{    ...}

7. Non-empty slice check

The right way:

if len(s) > 0 {    ...}

Instead of:

if s != nil && len(s) > 0 {    ...}

8. Direct use of BOOL values

For variable var b bool of type bool, use it directly as a judgment instead of comparing it with True/false
The right way:

if b {    ...}if !b {    ...}

Instead of:

if b == true {    ...}if b == false {    ...}

9. Comparison of Byte/slice/string equality

var s1 []bytevar s2 []byte    ...bytes.Equal(s1, s2) == 0bytes.Equal(s1, s2) != 0

Instead of:

var s1 []bytevar s2 []byte    ...bytes.Compare(s1, s2) == 0    bytes.Compare(s1, s2) != 0

10. Check if a substring is included

strings should be used. Containesrune, Strings. Containesany, Strings. Contains

11. Copy Slice

Use the built-in function copy instead of traversing slice one-by-one
The right way

var b1, b2 []bytecopy(b2, b1)

12. Try to shorten the IF

The right way:

  var a, b int  ...  return a > b

Instead of:

    var a, b int    ...    if a > b {        return true    } else {        return false    }

13. Simplify Range

The right way:

    for range m {        ...    }

Instead of:

       var m map[string]int       for _ = range m {     }    for _, _ = range m {    }

14. Use strings. Trimprefix/strings. Trimsuffix

The right way:

    var s1 = "a string value"    var s2 = "a "    var s3 = strings.TrimPrefix(s1, s2)

Instead of:

       var s1 = "a string value"       var s2 = "a "       var s3 string    if strings.HasPrefix(s1, s2) {         s3 = s1[len(s2):]    }

15.append Slice

The right way:

    var a, b []byte    a = append(b, a...)

Instead of:

    var a, b []byte    for _,v range a {        append(b, v)    }

Reference documents

http://colobu.com/2017/02/07/write-idiomatic-golang-codes/

Effective Go