ʕ ◔ϖ◔ʔ Go~

go_memo.rst

ʕ ◔ϖ◔ʔ Go~

Number with explicit type

// ʕ ◔ϖ◔ʔ Go~
// Pros: It can use in global
// Cons: var
var x float64 = 10

// Pros: short, no var
// Cons: can't use in global
y := float64(10)

Slice creation

// ʕ ◔ϖ◔ʔ Go~

// *Type
// It needs length. Can't omit.
// Pros: it can have initial length
// Cons: long
slice := make([]*Type, 0)

// Pros: it can have initial values and length, short
// Cons: {}
slice := []*Type{}
slice := []int{1, 2, 3}
array := [10]int{1, 2, 3}  // it is not slice, array
array := [...]int{1, 2, 3} // omit length

// Pros: It can use in global space
// Cons: var
var slice []*Type
var array [10]*Type // It is not slice, array

# Python
array = []
array = [1, 2, 3]
array = [0] * 10

Two dimensional slice

// ʕ ◔ϖ◔ʔ Go~
slice2d := make([][]int, 10)

# Python
array2d = [[]] * 10

Append

// ʕ ◔ϖ◔ʔ Go~
slice = append(slice, 1)
slice = append(slice, 1, 2, 3)
slice = append(slice, other...)

# Python
array.append(1)
array = array + other

Loop

// ʕ ◔ϖ◔ʔ Go~
// index
for i := range slice {
    fmt.Println(i)
}

// value
for _, v := range slice {
    fmt.Println(v)
}

// both
for i, v := range slice {
    fmt.Println(i, v)
}

# Python
# index
for i in range(len(array)):
    print(i)

# value
for v in array:
    print(v)

# both
for i, v in enumerate(array):
    print(i, v)

Is slice empty?

// ʕ ◔ϖ◔ʔ Go~
if len(array) == 0 {
    fmt.Println(" ʕ ◔ϖ◔ʔ empty~")
}

# Python
if not array:
    print("empty")

Map creation

// ʕ ◔ϖ◔ʔ Go~
// int -> []*Type
// it return instance, not pointer
make(map[int][]*Type)

Object creation

// ʕ ◔ϖ◔ʔ Go~
type Person struct {
    name string
    age  int
}

Without initial value

// ʕ ◔ϖ◔ʔ Go~
// Option 1: instance & :=, it needs {}
anonymous := Person{}

// Option 2: instance & var
var anonymous Person

// Option 3: pointer  & :=, it needs {}
anonymous := &Person{}

// Option 4: pointer & :=
anonymous := new(Person)

// Option 5: pointer & var
var anonymous *Person = &Person{}

// Option 5: pointer & var & new
var anonymous *Person = new(Person)

// Wrong! it is just pointer! instance is not created!
var anonymous *Person

# Python
anonymous = Person()

With initial value

// ʕ ◔ϖ◔ʔ Go~

// Option 1: initialize with composite literal
// Pros: Easy and simple
// Cons: It will be error if type has extra field, initializing map everyplace is boring
tongpoo := Person{"ymotongpoo", 30}
var tongpoo Person = Person{"ymotongpoo", 30}
tongpoo := Person{"ymotongpoo", 30}
var tongpoo *Person = &Person{"ymotongpoo", 30}

// Option 2: field name
// Pros: Easy and simple, It wont't be error evenif the type has extra field
// Cons: Initializing map everyplace is boring
tongpoo := Person{name:"ymotongpoo", age:30}
var tongpoo Person = Person{name:"ymotongpoo", age:30}
tongpoo := Person{name:"ymotongpoo", age:30}
var tongpoo *Person = &Person{name:"ymotongpoo", age:30}

// Option 3: initializer function
// Pros: It can have complex initialization code
// Cons: long
func NewPerson(name string, age int) *Person {
    obj := new (Person)
    obj.name = name
    obj.age = age
    return obj
}
obj := NewPerson("ymotongpoo", 30)