Catatan Go : Basic

package main

import "fmt"

func main(){
   fmt.Println("Hello World")
}

$ go build <namafile>

$ go build helloworld.go
$ ./helloworld

Hello World

--- Atau bisa langsung running ---

$ go run helloworld.go

Hello World

var name string = "John Doe"
age := 30

var name string = "John Doe"
var age int = 30
var isEmployed bool = true

var (
    name string = "John Doe"
    age int = 30
    isEmployed bool = true
)

name := "John Doe"
age := 30
isEmployed := true

var name string
var age int
var isEmployed bool

fmt.Println(name, age, isEmployed)
// Output: "" 0 false

package main

import "fmt"

func main() {

	var (
		name       string = "John Doe"
		age        int    = 30
		isEmployed bool   = true
	)

	fmt.Println(name)
	fmt.Println(age)
	fmt.Println(isEmployed)

}

package main

import (
   "fmt"
   "reflect"   "unsafe")

func main() {
   //Declare a int
   var a = 2

   //Size of int8 in bytes
   fmt.Printf("%d bytes\n", unsafe.Sizeof(a))
   fmt.Printf("a's type is %s\n", reflect.TypeOf(a))

   //Declare b int 8
   var b int8 = 127

   //Size of int8 in bytes
   fmt.Printf("%d bytes\n", unsafe.Sizeof(b))
   fmt.Printf("a's type is %s\n", reflect.TypeOf(b))

   //Declare c int 16
   var c int16 = 32767

   //Size of int16 in bytes
   fmt.Printf("%d bytes\n", unsafe.Sizeof(c))
   fmt.Printf("a's type is %s\n", reflect.TypeOf(c))

   //Declare d int 32
   var d int32 = 2147483647

   //Size of int32 in bytes
   fmt.Printf("%d bytes\n", unsafe.Sizeof(d))
   fmt.Printf("a's type is %s\n", reflect.TypeOf(d))

   //Declare e int 64
   var e int64 = 9223372036854775807

   //Size of int64 in bytes
   fmt.Printf("%d bytes\n", unsafe.Sizeof(e))
   fmt.Printf("a's type is %s\n", reflect.TypeOf(e))

}

package main

import (
   "fmt"
   "reflect"   "unsafe")

func main() {
   //Declare a float32
   var a float32 = 2

   //Size of float32 in bytes
   fmt.Printf("%d bytes\n", unsafe.Sizeof(a))
   fmt.Printf("a's type is %s\n", reflect.TypeOf(a))

   //Declare a float64
   var b float64 = 2

   //Size of float64 in bytes
   fmt.Printf("%d bytes\n", unsafe.Sizeof(b))
   fmt.Printf("a's type is %s\n", reflect.TypeOf(b))

   //Default is float64 when you don't specify a type
   c := 2.3
   fmt.Printf("b's type is %s\n", reflect.TypeOf(c))
}

package main

import "fmt"

func main() {
   //Default value will be false it not initialized
   var a bool
   fmt.Printf("a's value is %t\n", a)

   //And operation on one true and other false
   andOperation := 1 < 2 && 1 > 3
   fmt.Printf("Ouput of AND operation on one true and other false %t\n", andOperation)

   //OR operation on one true and other false
   orOperation := 1 < 2 || 1 > 3
   fmt.Printf("Ouput of OR operation on one true and other false: %t\n", orOperation)

   //Negation Operation on a false value
   negationOperation := !(1 > 2)
   fmt.Printf("Ouput of NEGATION operation on false value: %t\n", negationOperation)
}

package main

import "fmt"

func main() {

   var a = "initial"
   fmt.Println(a)

   var b = "initial\n"
   fmt.Printf(b)

   var c = `initial\n`
   fmt.Printf(c)
}

package main

import (
   "fmt"
   "reflect"
   "unsafe"
   )

func main() {
   var r byte = 'a'

   //Print Size
   fmt.Printf("Size: %d\n", unsafe.Sizeof(r))

   //Print Type
   fmt.Printf("Type: %s\n", reflect.TypeOf(r))

   //Print Character
   fmt.Printf("Character: %c\n", r)
   s := "abc"

   //This will the decimal value of byte
   fmt.Println([]byte(s))
}

package main

import "fmt"

func main() {
   var a rune = 'A'
   fmt.Println(a)  // 65
}

package main

import "fmt"

func main() {

	i := 1
	for i <= 3 {
		fmt.Println(i)
		i = i + 1
	}

	for j := 7; j <= 9; j++ {
		fmt.Println(j)
	}

	for {
		fmt.Println("loop")
		break
	}

	for n := 0; n <= 5; n++ {
		if n%2 == 0 {
			continue
		}
		fmt.Println(n)
	}
}

package main

import "fmt"

func main() {

   nums := []int{2, 3, 4}
   sum := 0
   for _, num := range nums {
      sum += num
   }
   fmt.Println("sum:", sum)

   for i, num := range nums {
      if num == 3 {
         fmt.Println("index:", i)
      }
   }

   kvs := map[string]string{"a": "apple", "b": "banana"}
   for k, v := range kvs {
      fmt.Printf("%s -> %s\n", k, v)
   }

   for k := range kvs {
      fmt.Println("key:", k)
   }

   for i, c := range "go" {
      fmt.Println(i, c)
   }
}

package main

import "fmt"

func main() {
	x := 10
	y := 20
	if x > y {
		fmt.Println("x lebih besar dari y")
	} else if x == y {
		fmt.Println("x sama dengan y")
	} else {
		fmt.Println("x lebih kecil dari y")
	}
}

package main

import "fmt"

func main() {
	x := 10
	switch x {
	case 1:
		fmt.Println("Nilai x adalah 1")
	case 10:
		fmt.Println("Nilai x adalah 10")
	default:
		fmt.Println("Nilai x tidak ditemukan")
	}
}

package main

import (
	"errors"
	"fmt"
)

func division(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("Tidak bisa dibagi dengan 0")
	}
	return a / b, nil
}

func main() {
	result, err := division(10, 0)
	if err != nil {
		fmt.Println(err)
	} else {
		fmt.Println(result)
	}
}

package main

import (
	"fmt"
)

func main() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Recovered:", r)
		}
	}()
	panic("Panic Error")
}

package main

import (
	"fmt"
)

func main() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Recovered:", r)
		}
	}()
	panic("Panic Error")
}

func add(a int, b int) int {
    return a + b
}

package main

import "fmt"

func add(a int, b int) int {
	return a + b
}

func main() {
	result := add(1, 3)
	fmt.Println(result)
}

func swap(a, b int) (int, int) {
    return b, a
}

x, y := swap(1, 2)

  value := func(){
      fmt.Println("Welcome! to GeeksforGeeks")
  }
  value()

func adder() func(int) int {
	sum := 0
	return func(x int) int {
		sum += x
		return sum
	}
}

add := adder()
fmt.Println(add(1)) // 1
fmt.Println(add(2)) // 3
fmt.Println(add(3)) // 6

func factorial(n int) int {
	if n == 0 {
		return 1
	}
	return n * factorial(n-1)
}

fmt.Println(factorial(5)) // 120

var a float64 = 5.6
var b int = int(a)

fmt.Println(b) // 5

package main

import "fmt"

func main(){
   fmt.Println("Hello World")
}

package main

import "fmt"
import "math"

func main(){
   fmt.Println("Hello World")
   fmt.Println(math.Max(24, 50))
}

var days = [7]string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}

fmt.Println(days)

var mySlice []int
mySlice = append(mySlice, 6)
mySlice = append(mySlice, 10)
fmt.Println(mySlice)

var myMap = map[string]int{"one": 1, "two": 2, "three": 3}
fmt.Println(myMap)
fmt.Println(myMap["two"])

type Person struct {
    name string
    age  int
    address string
}

func main() {
    var p Person
    p.name = "John Doe"
    p.age = 30
    p.address = "123 Main St"

    fmt.Printf("Name: %s\n", p.name)
    fmt.Printf("Age: %d\n", p.age)
    fmt.Printf("Address: %s\n", p.address)
}