Golang Quick Reference

// Features: mutable, pass by reference, heap allocated
a := []int{1,2,3,4,5} // shorthand and initialization
// Can also specify index for placeholder
a := []int{0:1,4:3}
// Add
a = append(a, 6)
// Delete
// Index of element to delete
index := 2
// Delete element
slice = append(slice[:index], slice[index+1:]...)  // This is also array merging
// Modify and read same as array

// Length (Length) refers to the number of elements currently contained in the slice.
// Capacity (Capacity) refers to the size of the underlying array, i.e., the number of elements the slice can accommodate, the upper limit.
a := make([]byte, 5, 10) // This means slice a can accommodate up to 10 byte elements, but currently only has 5 elements.
// Can omit capacity
a := make([]byte, 5)
 
// Syntax explanation a[b:c] => 
// b represents current index, if empty then index is 0
// c represents current index, if empty then index is len(a)
s := x[:] // slice s points to array x's memory space, changing slice s's values also affects array x's values

for k,v := range a {} 
for _,v := range a {} // don't need index
for k := range a {} // only need index
for range time.Tick(time.Second) {} // need neither

// Features: fixed size, pass by value, stack allocated
a := [5]int{1,2,3,4,5}
// Cannot add or delete
// Modify
a[3] = 6
// Read
a[3]

switch a {
case "a":
	// todo
case "b", "c":  // matches either b or c
	// todo
default:
	// todo
}
 
// Can also prepend a statement
switch a:=1; a { ... }

for {}  // equivalent to while true
for a < 19 {} // equivalent to while a < 19
for a := 10; a<99; a++ {} // normal usage
 
// Also supports break and continue with outer labels
here:
    for i := 0; i < 2; i++ {
        for j := i + 1; j < 3; j++ {
            if i == 0 {
                continue here
            }
            fmt.Println(j)
            if j == 2 {
                break
            }
        }
    }
 
there:
    for i := 0; i < 2; i++ {
        for j := i + 1; j < 3; j++ {
            if j == 1 {
                continue
            }
            fmt.Println(j)
            if j == 2 {
                break there
            }
        }
    }

if a > 0 {}
 
// Can add additional statement and end with semicolon
if a := b+c; a > 0 {}

Add package declaration at the very beginning of each Go source file (excluding comments)
Executable files are in main package
Convention: package name == last name of package import path (import path math/rand => package name rand)
Identifiers starting with uppercase: exported identifiers, visible to other packages
Identifiers starting with lowercase: private identifiers, not visible to other packages

func a() {}
func a(b int){}
func a(b, c int){} // multiple of same type
func a() string {}
// Return value
func a() (int,string){
  return 1, "1"
}
// Return identifier, just return directly
func a() (b int, c string){
	b = 1
	c = "1"
	return
}

// Used as parameter
add := func(a,b)int{
	return a+b
}
 
// Used as return value
func wrapAdd() (add func() int) {
	c := 1
	add = func() int { return c }
	return
}

func a(args ...int) int {
	return 1
}

var a int = 1
a := 1
const a = "1"

go build: Used to compile Go code and generate executable files. For example, go build main.go will compile the main.go file and generate an executable file.
 
go run: Used to compile and run Go code. For example, go run main.go will compile and directly run the main.go file.
 
go test: Used to run Go unit tests. Through the go test command, you can automatically run test files in the project and output test results.
 
go get: Used to fetch and install third-party dependency packages. For example, go get github.com/example/package will fetch and install the github.com/example/package dependency package.
 
go mod init: Used to initialize Go project module management. By executing the go mod init command, you can create a new go.mod file for managing project dependencies.
 
go mod tidy: Used to automatically clean up unused dependencies in the project. Running go mod tidy will check project dependencies and remove dependencies that are no longer needed.
 
go mod vendor: Used to copy project dependencies to the project's vendor directory. By running go mod vendor, you can copy all dependencies to the project for offline building and deployment.
 
go doc: Used to view Go code documentation. For example, go doc fmt.Println will display the documentation for the Println function in the fmt package.