Go language notes

Differences between Go and the “C” type languages

Variable declaration

int i;        // C#
var i int = 5 // Go
i := 5 // Go

Function declaration

private int AddNumbers (int a, int b) {...}  // C#
func addNumbers(a int, b int) int {...} // Go



for (int i = 0; i < 5; i++) {...}  // C#
for i := 0; i < 5; i++ {...} // Go


// "while" loop in C#
int i = 0;
while (i < 5) {

// "while" loop in Go (the init and post statements are optional, so "for" can be used as "while")
i := 0
for i < 5 {

infinite loop

while (true) {...}  // C#
for {...} // Go


if (a == b ) {... } // C#
if a == b {...}     // Go


No “break” is needed after every “case”


Wait with the function call until the surrounding function completes
deferred function calls are pushed into a last-in first-out stack


var a [5]int   // Go (array with 5 integer elements)


Use “slices” with the “append” function to dynamically add elements to a slice and the underlying array.


There are no classes in Go, use “methods” that are functions with receivers (attributes). The receiver has to be specified in the same package as the function.

func (v MyStruct) MyFunction() int {...}

Use pointer receivers to modify the original reference of the receiver in the function.

func (v *MyStruct) MyFunction() int {
  v.X = 5

Functions with a receiver can take a value or pointer. It is recommended to use pointer receivers to be able to modify the passed-in argument and avoid copying it.

Private and public (exported) names

  • Exported (public) names start with an upper case letter
  • Not exported (private) names start with lower case letter


  • When declaring variables, the name comes first, the type comes last
    var i int
  • We can declare multiple variables with the same type, and specify the type only once for the last one in one statement
    var a, b, c bool
  •  Inside functions the short variable variable declaration uses the implicit type
    d := 5
  •  We can declare and assign values to multiple variables with one statement
    e, f, g := true, false, "yes!"
  •  The basic types are


    int (32 bit on 32 bit systems, 64 bit on 64 bit systems)
    int8 int16 int32 int64
    uint (32 bit on 32 bit systems, 64 bit on 64 bit systems)
    uint8 uint16 uint32 uint64
    uintptr (32 bit on 32 bit systems, 64 bit on 64 bit systems)

    byte // alias for uint8

    rune // alias for int32
    // represents a Unicode code point

    float32 float64

    complex64 complex128
  •  To print the type and value of a variable use %T and %v
    a := 8
    fmt.Printf("Type: %T Value: %v", a, a)
    Type: int Value 8
  •  Explicit type conversions with a NewType(value) syntax are required for assignments between different types
    var i int = 5
    var f float32 = float32(i)


  • If a function returns multiple values, enclose the return declaration in parentheses
    func myfunc(x, y string) (string, string) {
    return y, x


 Dynamic view into an array. array[first:last+1] (the element specified by the second argument is not part of the slice)

var s []int = array[0:6]

Create a slice and the underlying array with “make([]type, length of the slice, capacity of the array)”

b := make([]int, 0, 5) // len(b)=0, cap(b)=5

To dynamically add elements to the slice and the underlying array use the “append” function

var s []int
s = append(s, 1)
// Appends an element with the value of 1 to the slice and the array

To iterate through an array or slice use the “for range” expression. It returns the index and the value of the current element

for i, v := range my_array{}


// key is string, value is integer (here we use "make" to create it)
m := make(map[string]int)

// key is string, value is a struct
type MyStruct struct {
x, y int
var m map[string]MyStruct

Leave a comment

Your email address will not be published. Required fields are marked *