fundamental1

$ git config --global url."https://${GITHUB_TOKEN}@github.com".insteadOf "https://github.com"

var greeting interface{} = "hello world"
greetingStr := greeting.(string)

greeting := []byte("hello world")
greetingStr := string(greeting)

switch v := param.(type) { 
default:
    fmt.Printf("Unexpected type %T", v)
case uint64:
    fmt.Println("Integer type")
case string:
    fmt.Println("String type")
}

a := struct{}{}

// 印出結果會是 0
println(unsafe.Sizeof(a)) 
// 0

map_obj := make(map[string]struct{})
for _, value := range []string{"interviewbit", "golang", "questions"} {
map_obj[value] = struct{}{}
}
fmt.Println(map_obj)
// Output
map[interviewbit:{} golang:{} questions:{}]

visited := make(map[string]struct{})
for _, isExists := visited[v]; !isExists {
    // First time visiting a vertex.
    visited[v] = struct{}{}
}

func workerRoutine(ch chan struct{}) {
    // Receive message from main program.
    <-ch
    println("Signal Received")

    // Send a message to the main program.
    close(ch)
}

func main() {
    //Create channel
    ch := make(chan struct{})
    //define workerRoutine
    go workerRoutine(ch)
    // Send signal to worker goroutine
    ch <- struct{}{}
    // Receive a message from the workerRoutine.
    <-ch
    println(“Signal Received")
}

slice1 := []int{1, 2}
slice2 := []int{3, 4}
slice3 := slice1
copy(slice1, slice2)
fmt.Println(slice1, slice2, slice3)
// Output
[3 4] [3 4] [3 4]

slice1 := []int{1, 2}
slice2 := []int{3, 4}
slice3 := slice1
slice1 = slice2
fmt.Println(slice1, slice2, slice3)
# Output
[3 4] [3 4] [1 2]

map1 := map[string]bool{"Interview": true, "Bit": true}
map2 := make(map[string]bool)
for key, value := range map1 {
	map2[key] = value
}

map1 := map[string]bool{"Interview": true, "Bit": true}
map2 := map[string]bool{"Interview": true, "Questions": true}
map3 := map1
map1 = map2    //copy description
fmt.Println(map1, map2, map3)

ls $GOPATH
# bin pkg src

type Interface interface {
    // Find number of elements in collection
    Len() int
    
    // Less method is used for identifying which elements among index i and j are lesser and is used for sorting
    Less(i, j int) bool
    
    // Swap method is used for swapping elements with indexes i and j
    Swap(i, j int)
}

type Human struct {
    name string
    age  int
}

// AgeFactor implements sort.Interface that sorts the slice based on age field.
type AgeFactor []Human
func (a AgeFactor) Len() int           { return len(a) }
func (a AgeFactor) Less(i, j int) bool { return a[i].age < a[j].age }
func (a AgeFactor) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

func main() {
    audience := []Human{
        {"Alice", 35},
        {"Bob", 45},
        {"James", 25},
    }
    sort.Sort(AgeFactor(audience))
    fmt.Println(audience)
}

// Output
[{James 25} {Alice 35} {Bob 45}]

package main

import "fmt"

func swapContents(listObj []int) {
        for i, j := 0, len(listObj)-1; i < j; i, j = i+1, j-1 {
                listObj[i], listObj[j] = listObj[j], listObj[i]
        }
}
func main() {
	listObj := []int{1, 2, 3}
	swapContents(listObj)
	fmt.Println(listObj)
}
// Output
[3 2 1]

package main

import (
    "strings"
    "fmt"
)

func main() {
    var str strings.Builder

    for i := 0; i < 5; i++ {
        str.WriteString("a")
    }

    fmt.Println(str.String())
}
// Output
aaaaa

switch a, b := x[i], y[j]; {
    case a < b: t = -1
    case a == b: t = 0
    case a > b: t = 1
}

for i, j := 0, N; i < j; i, j = i+1, j-1 { }

greeting(lastname)

func greeting(name string)  {}

func inc1(x int) int { return x+1 }
f1 := inc1

// func IndexFunc(s string, f func(c int) bool) int
strings.IndexFunc(line, unicode.IsSpace)

func fib() func() int {
    a, b := 1, 1
    return func() int {
        a, b = b, a + b
        return b
    }
}

func MakeAddSuffix(suffix string) func(string) string {
    return func(name string) string {
        if !strings.HasSuffix(name, suffix) {
            return name + suffix
        }
        return name
    }
}

// 使用
addBmp := MakeAddSuffix(".bmp")
addJpeg := MakeAddSuffix(".jpeg")

addBmp("file") // returns: file.bmp
addJpeg("file") // returns: file.jpeg

package main
import "fmt"
func trace(s string) string {
    fmt.Println("entering:", s)
    return s
}
func un(s string) {
    fmt.Println("leaving:", s)
}
func a() {
    defer un(trace("a"))
    fmt.Println("in a")
}
func b() {
    defer un(trace("b"))
    fmt.Println("in b")
    a()
}
func main() {
    b()
}

// Results
//
// entering: b
// in b
// entering: a
// in a
// leaving: a
// leaving: b

func trace(name string) func() {
	fmt.Printf("Entering %s\n", name)
	return func() {
		fmt.Printf("Leaving %s\n", name)
	}
}
func main() {
	defer trace("f")()
	fmt.Println("Doing something")
}
// Results
//
// Entering f
// Doing something
// Leaving f

// 下面的寫法有差異

// new 所回傳的是記憶體位址，所以 arr2 是 *[5]int，是不為 nil 的記憶體位址
var arr2 = new([5]int)

// var 的話是 type [5]int
var arr1 [5]int

var arrKeyValue = [5]string{3: "Chris", 4: "ron"}

// 這樣宣告出來的 slice 指向 nil
// len 0
var identifier []type
// slice 宣告的時候可以指定是哪個 array 的切片 (start 到 end - 1)
var slice1 []type = arr1[start:end]
// slice 宣告的時候指定整個 array
var slice1 []type = arr[:]
// 其他切片語法
s := [3]int{1,2,3}[:]
s := [...]int{1,2,3}[:]
s := []int{1,2,3}
var x = []int{1,2,3,4,5}
// 會參照相同的 underlying array
s2 := s[:]
// 以下為 true
s == s[:i] + s[i:]
// 可以做移位操作
s2 = s2[1:]

slice1 := make([]type, len)
slice1 := make([]type, len, cap)
// 以下是等價的
make([]int, 50, 100)
new([100]int)[0:50]

values := [][]int{} // multidimensional slice
// These are the first two rows.
row1 := []int{1, 2, 3}
row2 := []int{4, 5, 6}

// Append each row to the two-dimensional slice.
values = append(values, row1)
values = append(values, row2)

// New Buffer.
var b bytes.Buffer
// Write strings to the Buffer.

b.WriteString("ABC")
b.WriteString("DEF")
// Use Fprintf with Buffer.
fmt.Fprintf(&b, " A number: %d, a string: %v\n", 10, "bird")
b.WriteString("[DONE]")
// Convert to a string and print it.
fmt.Println(b.String())

// Outputs
ABCDEF A number: 10, a string: bird
[DONE]

// ix 是 index
// value 是每一次 loop 的值，只做用在 body 內，是 copy of the slice item
// 所以不能用來更改 slice 內容
for ix, value := range slice1 {
...
}

// 要改內容的話要透過 index
seasons := []string{"Spring","Summer","Autumn","Winter"}
for ix := range seasons {
  seasons[ix] = strings.ToUpper(seasons[ix])  // modifying the seasons
}

// 多擴充一位給 slice
sl = sl[0:len(sl)+1]

// copy function
// 用 src 覆蓋掉 dst
// 回傳複製了多少 element
// 當 src 是 string 的時候，element type 是 byte
func copy(dst, src []T) int

// append function
// 如果 append 會造成超過 underlying type 的話，會分配到另一個新的且足夠大的 slice
func append(s[]T, x ...T) []T

// 把一個 slice append 到另一個 slice
x = append(x, y...)

// s 是 string
c := []byte(s)

// copy 也可以處理字串來源
copy(dst []byte, src string)

// range unicode string 的話
// 每一個 loop 是一個 rune
s := "\u00ff\u754c"
for i, c := range s {
    fmt.Printf("%d:%c ", i, c)
}
// Outputs
0:ÿ 2:界


// 建立 substring
substr := str[start:end]

s := "hello"
c := []byte(s) // converting string s to array of bytes `c`.
c[0] = 'c'     // modifying the c 
s2 := string(c) // Converting c to string, s2 == "cello"

// 把 b 加到 a
a = append(a, b...)
// 刪除 index i
a = append(a[:i], a[i+1:]...)
// 從 index i 到 j 的部分切掉
a = append(a[:i], a[j:]...)
// 使用新的 slice 做擴展
a = append(a, make([]T, j)...)
// 插入 item 到 index i
a = append(a[:i], append([]T{x}, a[i:]...)...)
// 插入新的 長度 j 的 slice 於 index i
a = append(a[:i], append(make([]T, j), a[i:]...)...)
// 插入已存在的 slice b 於 index i
a = append(a[:i], append(b, a[i:]...)...)
// 從 stack 拿掉最高的元素
x, a = a[len(a)-1], a[:len(a)-1]
// 插入一個元素到 stack
a = append(a, x)

var digitRegexp = regexp.MustCompile("[0-9]+")
func FindDigits(filename string) []byte {
  b, _ := ioutil.ReadFile(filename)
  return digitRegexp.Find(b)
}

func FindDigits(filename string) []byte {
  b, _ := ioutil.ReadFile(filename)
  b = digitRegexp.Find(b)
  c := make([]byte, len(b))
  copy(c, b) // copying b to c
  return c
}

// string 可以直接做成 rune slice
str := "hello"
runes := []rune(str)
// 也可以直接做成 byte slice
bytes := []byte(str)

// 轉回 string
string(runes)
string(bytes)

var map1 map[keytype]valuetype
// example
var map1 map[string]int

// 初始化 map
var map1 map[keytype]valuetype = make(map[keytype]valuetype)
// or
map1 := make(map[keytype]valuetype)

func main() {
  mf := map[int]func() int{ // key type int, and value type func()int
    1: func() int { return 10 },
    2: func() int { return 20 },
    5: func() int { return 50 },
  }
  fmt.Println(mf)
}
// Outputs
// 注意 value 是 function 的 address
map[1:0x4011c0 2:0x4011d0 5:0x4011e0]

make(map[keytype]valuetype, cap)

// 確認 map 是否有值
if _, ok := map1[key1]; ok {
  // ...
}

// 刪除 map 內的 key 值
delete(map1, key1)

items := make([]map[int]int, 5)
for i := range items {
  items[i] = make(map[int]int, 1) 
  items[i][1] = 2 // This 'item' data will not be lost on the next iteration
}

func insertListElements(n int)(*list.List){   // add elements in list from 1 to n
  lst := list.New()
  for i:=1;i<=n;i++{
    lst.PushBack(i)         // insertion here
  } 
  return lst
}

func main() {
  n := 5                    // total number of elements to be inserted
  myList := insertListElements(n) // function call
  for e := myList.Front(); e != nil; e = e.Next() {
		fmt.Println(e.Value)  // printing values of list
	}
}

func main() {
  searchIn := "John: 2578.34 William: 4567.23 Steve: 5632.18" // string to search
  pat := "[0-9]+.[0-9]+" // pattern search in searchIn

  f := func (s string) string {
    v, _ := strconv.ParseFloat(s, 32)
    return strconv.FormatFloat(v * 2, 'f', 2, 32)
  }
  // 檢查是否 pattern 可以找到 match
  if ok, _ := regexp.Match(pat, []byte(searchIn)); ok {
    fmt.Println("Match found!")
  }
  
  // 做出指定 pattern 的 regexp object
  // 如果是用 MustCompile 的話，如果 pattern 轉換成 regexp object 失敗會 panic
  re, _ := regexp.Compile(pat)

  // 透過 regexp object 去處理輸入的 文章字串
  // 並用 ReplaceAllString 去做取代
  str := re.ReplaceAllString(searchIn, "##.#") // replace pat with "##.#"
  fmt.Println(str)
  // using a function
  str2 := re.ReplaceAllStringFunc(searchIn, f)
  fmt.Println(str2)
}

// 假設 Info 是個要被保護的 shared variable
// 可以給他一個 sync.Mutex 變數來處理
type Info struct {
  mu sync.Mutex
  // ... other fields, e.g.:
  Str string
}

func Update(info *Info) {
    info.mu.Lock()
    // critical section:
    info.Str = // new value
    // end critical section
    info.mu.Unlock()
}

func main() {
  // Here are some calculations with bigInts:
  im := big.NewInt(math.MaxInt64)
  in := im
  io := big.NewInt(1956)
  ip := big.NewInt(1)
  ip.Mul(im, in).Add(ip, im).Div(ip, io)
  fmt.Printf("Big Int: %v\n", ip)
  // Here are some calculations with big rationals:
  rm := big.NewRat(math.MaxInt64, 1956)
  rn := big.NewRat(-1956, math.MaxInt64)
  ro := big.NewRat(19, 56)
  rp := big.NewRat(1111, 2222)
  rq := big.NewRat(1, 1)
  rq.Mul(rm, rn).Add(rq, ro).Mul(rq, rp)
  fmt.Printf("Big Rat: %v\n", rq)
}

// 這樣宣告是兩個相同 underlying type 的不同 type，不可直接互用，要轉型
type nr number   // new distinct type
// 這樣宣告是可互通的 不同 type
type nrAlias = number // alias type

type TagType struct { // tags
    field1 bool "An important answer"
    field2 string `The name of the thing`
    field3 int "How much there are"
}

tt := TagType{true, "Barack Obama", 1}

for i:= 0; i < 3; i++ {
    ttType := reflect.TypeOf(tt)
    ixField := ttType.Field(i)       // getting field at a position ix
    fmt.Printf("%v\n", ixField.Tag)   // printing tags
}

type T struct {
  a int "This is a tag"
  b int `A raw string tag`
  c int `key1:"value1" key2:"value2"`
}

if field, ok := reflect.TypeOf(t).FieldByName("c"); ok {
    fmt.Println(field.Tag)
    fmt.Println(field.Tag.Get("key1"))
}

type T struct {
  a int
}

func (t T) print(message string) {
  fmt.Println(message, t.a)
}

func (T) hello(message string) {
  fmt.Println("Hello!", message)
}

func callMethod(t T, method func(T, string)) {
  method(t, "A message")
}

func main() {
  t1 := T{10}
  t2 := T{20}
  var f func(T, string) = T.print
  callMethod(t1, f)
  callMethod(t2, f)
  callMethod(t1, T.hello)
}

type Point struct {
  x, y float64
}

func (p *Point) Abs() float64 {
  return math.Sqrt(p.x*p.x + p.y*p.y)
}

type NamedPoint struct {
  Point   // anonymous field of Point type
  name string
}

func main() {
  n := &NamedPoint{Point{3, 4}, "Pythagoras"} // making pointer type variable
  fmt.Println(n.Abs()) // prints 5
}

func main() {
  ms := runtime.MemStats{}
  runtime.ReadMemStats(&ms)
    
  println("Heap after GC. Used:", ms.HeapInuse, " Free:", ms.HeapIdle, " Meta:", ms.GCSys)

  time.Sleep(5 * time.Second)
}

// 名稱通常是以 -er 為結尾
type Namer interface {
    Method1(param_list) return_type
    Method2(param_list) return_type
    ...
}
// 宣告，此時 ai 尚未初始化，值是 nil
// interface 是 reference type
var ai Namer
// ai 是 receiver value + method table ptr

// io.Reader interface
type `Reader` interface {
    Read(p []byte) (n int, err error)
}

var r io.Reader
// 以下都有滿足介面 Reader
r = os.Stdin
r = bufio.NewReader(r)
r = new(bytes.Buffer)
f,_ := os.Open("test.txt")
r = bufio.NewReader(f)

type ReadWrite interface {
  Read(b Buffer) bool
  Write(b Buffer) bool
}

type Lock interface {
  Lock()
  Unlock()
}

type File interface {
  ReadWrite
  Lock
  Close()
}

// 判斷 interface type 是不是 concrete type T
if v, ok := varI.(T); ok { // checked type assertion
    Process(v)
    return
}
// here varI is not of type T

switch t := areaIntf.(type) {
    case *Square:
      fmt.Printf("Type Square %T with value %v\n", t, t)
    case *Circle:
      fmt.Printf("Type Circle %T with value %v\n", t, t)
    default:
      fmt.Printf("Unexpected type %T", t)
}

type Stringer interface { String() string }

if sv, ok := v.(Stringer); ok {
  fmt.Printf("v implements String(): %s\n", sv.String()); // note: sv, not v
}

type Reader interface {
  Read(p []byte) (n int, err error)
}

type Writer interface {
  Write(p []byte) (n int, err error)
}

type Element interface{}

type Vector struct {
  a []Element
}

var x float64 = 3.4
v := reflect.ValueOf(x)
// v 是 reflect.Float64

func main() {
  var x float64 = 3.4
  v := reflect.ValueOf(x)
  // setting a value:
  // Error: will panic: reflect.Value.SetFloat using unaddressable value
  // v.SetFloat(3.1415)
  fmt.Println("settability of v:", v.CanSet())
  v = reflect.ValueOf(&x) // Note: take the address of x.
  fmt.Println("type of v:", v.Type())
  fmt.Println("settability of v:", v.CanSet())
  v = v.Elem()
  fmt.Println("The Elem of v is: ", v)
  fmt.Println("settability of v:", v.CanSet())
  v.SetFloat(3.1415) // this works!
  fmt.Println(v.Interface())

  fmt.Println(v)
}
// outputs
settability of v: false
type of v: *float64
settability of v: false
The Elem of v is:  3.4
settability of v: true
3.1415
3.1415

func mapToStruct(m map[string]interface{}) interface{} {
	var structFields []reflect.StructField

	for k, v := range m {
		sf := reflect.StructField{
			Name: strings.Title(k),
			Type: reflect.TypeOf(v),
		}
		structFields = append(structFields, sf)
	}

	// Creates the struct type
	structType := reflect.StructOf(structFields)

	// Creates a new struct
	structObject := reflect.New(structType)

	return structObject.Interface()
}


func main() {

	m := make(map[string]interface{})

	m["name"] = "Barack"
	m["surname"] = "Obama"
	m["age"] = 57

	s := mapToStruct(m)
	fmt.Printf("%t %[1]v\n", s)

	sr := reflect.ValueOf(s)
	sr.Elem().FieldByName("Name").SetString("Donald")
	sr.Elem().FieldByName("Surname").SetString("Trump")
	sr.Elem().FieldByName("Age").SetInt(72)
	fmt.Println(s)
}

type Task struct {
  Command string
  *log.Logger
}
// New
func NewTask(command string, logger *log.Logger) *Task {
  return &Task{command, logger}
}
// task 可以呼叫 Log 的方法
task.Log()

type ReaderWriter struct {
  io.Reader
  io.Writer
}
// 初始化

t := &ReaderWriter{
    Reader: nil, // 可以塞滿足 interface 的物件
    Writer: nil,
}

type Cars []*Car
// Cars 可以有方法
func (cs Cars) Process(f func(car *Car)) {
    for _, c := range cs {
        f(c)
    }
}