# Things Golang do differently ### Formatting * use `gofmt` to format packages ### Commentary * Go uses c like comments `//` or `/* */` * Every Function/Struct/Variable that you have to export, name it so that first letter is capital * Package name * short, concise, evocative * the package in src/encoding/base64 is imported as "encoding/base64" but has name base64, not encoding\_base64 and not encodingBase64. ### Getters & Setters * Go doesn't provide automatic support for getters and setters. There's nothing wrong with providing getters and setters yourself, and it's often appropriate to do so. ```go owner := obj.Owner() if owner != user { obj.SetOwner(user) } ``` ### Naming **Interface Naming** By convention, one-method interfaces are named by the method name plus an -er suffix or similar modification to construct an agent noun: Reader, Writer, Formatter, CloseNotifier etc. ### Variable Naming * Finally, the convention in Go is to use MixedCaps or mixedCaps rather than underscores to write multi word names * In `a :=` declaration a variable v may appear even if it has already been declared, provided: this declaration is in the same scope as the existing declaration of v (if v is already declared in an outer scope, the declaration will create a new variable §), * The corresponding value in the initialisation is assignable to v, and there is at least one other variable that is created by the declaration ### Indentation ```go if i < f() { g() } if i < f() // wrong! { // wrong! g() } ``` ### Control Structure * There is no do or while loop, only a slightly generalised for; switch is much better If. In Go a simple if looks like this: ```go if x > 0 { return y } ``` * Mandatory braces encourage writing simple if statements on multiple lines. It's good style to do so anyway, especially when the body contains a control statement such as a return or break. Since if and switch accept an initialisation statement, it's common to see one used to set up a local variable. ```go if err := file.Chmod(0664); err != nil { log.Print(err) return err } ``` ### Re-declaration and Re-assignment The last example in the previous section demonstrates a detail of how the := short declaration form works. The declaration that calls os.Open reads, ```go f, err := os.Open(name) ``` * This statement declares two variables, f and err. A few lines later, the call to f.Stat reads, ```go d, err := f.Stat() ``` -​ which looks as if it declares d and err. Notice, though, that err appears in both statements. This duplication is legal: err is declared by the first statement, but only re-assigned in the second. This means that the call to f.Stat uses the existing err variable declared above, and just gives it a new value. ### Range * If you're looping over an array, slice, string, or map, or reading from a channel, a range clause can manage the loop. ```go for key, value := range oldMap { newMap[key] = value } ``` * If you only need the first item in the range (the key or index), drop the second: ```go for key := range m { if key.expired() { delete(m, key) } } ``` * If you only need the second item in the range (the value), use the blank identifier, an underscore, to discard the first: ```go sum := 0 for _, value := range array { sum += value } ``` ### Switch in Golang * Go's switch is more general than C's. * It's therefore possible—and idiomatic—to write an if-else-if-else chain as a switch. ```go func unhex(c byte) byte { switch { case '0' <= c && c <= '9': return c - '0' case 'a' <= c && c <= 'f': return c - 'a' + 10 case 'A' <= c && c <= 'F': return c - 'A' + 10 } return 0 } ``` * There is no automatic fall through, but cases can be presented in comma-separated lists. ```go func shouldEscape(c byte) bool { switch c { case ' ', '?', '&', '=', '#', '+', '%': return true } return false } ``` ### Type Switch * A switch can also be used to discover the dynamic type of an interface variable ```go var t interface{} t = functionOfSomeType() switch t := t.(type) { default: fmt.Printf("unexpected type %T\n", t) // %T prints whatever type t has case bool: fmt.Printf("boolean %t\n", t) // t has type bool case int: fmt.Printf("integer %d\n", t) // t has type int case *bool: fmt.Printf("pointer to boolean %t\n", *t) // t has type *bool case *int: fmt.Printf("pointer to integer %d\n", *t) // t has type *int } ``` ### Functions * Multiple return values ```go func squareRoot (num int) (n float, err error) // or func squareRoot (num int) (float, error) // to return error if num < 0 // named return ``` ### Defer * Go's defer statement schedules a function call (the deferred function) to be run immediately before the function exits. ```go func fileContent (filename string) (string, error) { f, err := os.Open(filename) if err != nil { return "", err } // defer will run the function just before exiting the function fileContents defer f.Close() // something with return } ``` * Deferring a call to a function such as Close has two advantages. * First, it guarantees that you will never forget to close the file, a mistake that's easy to make if you later edit the function to add a new return path. * Second, it means that the close sits near the open, which is much clearer than placing it at the end of the function. **For Example :** ```go for i := 0; i < 5; i++ { defer fmt.Printf("%d ", i) } ``` Deferred functions are executed in LIFO order, so this code will cause `4 3 2 1 0` to be printed when the function returns A more plausible example is a simple way to trace function execution through the program. We could write a couple of simple tracing routines like this: ```go func trace(s string) { fmt.Println("entering:", s) } func untrace(s string) { fmt.Println("leaving:", s) } // Use them like this: func a() { trace("a") defer untrace("a") // do something.... } ``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://dev117uday.gitbook.io/notes-md/golang/things-golang-do-differently.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.