├── helloworld.go
├── other
    └── other.go
├── boolean.go
├── comment.go
├── number.go
├── .idea
    ├── misc.xml
    ├── .gitignore
    ├── modules.xml
    └── belajar-golang-dasar.iml
├── break.go
├── continue.go
├── package-initialization.go
├── database
    └── database.go
├── function.go
├── helper
    └── sayhello.go
├── import.go
├── constant.go
├── type-declarations.go
├── pointer-method.go
├── string.go
├── function-parameter.go
├── interface-kosong.go
├── math.go
├── function-as-value.go
├── function-return-multiple-value.go
├── function-return-value.go
├── closure.go
├── defer.go
├── function-return-named-value.go
├── ring.go
├── function-variadic.go
├── regexp.go
├── boolean-operator.go
├── comparation-operator.go
├── conversion.go
├── nil.go
├── panic.go
├── math-operation.go
├── interface-error.go
├── os.go
├── type-assertions.go
├── if.go
├── function-as-parameter.go
├── variable.go
├── time.go
├── strconv.go
├── container-list.go
├── array.go
├── flag.go
├── function-recursive.go
├── map.go
├── strings.go
├── for.go
├── interface.go
├── sort.go
├── switch.go
├── struct.go
├── function-anonymous.go
├── pointer.go
├── reflect.go
└── slice.go


/helloworld.go:
--------------------------------------------------------------------------------
1 | package main
2 | 
3 | import "fmt"
4 | 
5 | func main(){
6 | 	fmt.Println("Hello World")
7 | }


--------------------------------------------------------------------------------
/other/other.go:
--------------------------------------------------------------------------------
1 | package other
2 | 
3 | import "fmt"
4 | 
5 | func SayHello(name string){
6 | 	fmt.Println("Hello", name)
7 | }
8 | 


--------------------------------------------------------------------------------
/boolean.go:
--------------------------------------------------------------------------------
1 | package main
2 | 
3 | import "fmt"
4 | 
5 | func main() {
6 | 	fmt.Println("Benar = ", true)
7 | 	fmt.Println("Salah = ", false)
8 | }
9 | 


--------------------------------------------------------------------------------
/comment.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | /**
 4 | komentar
 5 | multi line
 6 | tidak terbatas
 7 |  */
 8 | func main() {
 9 | 	// Ini komentar single line
10 | }
11 | 
12 | 


--------------------------------------------------------------------------------
/number.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	fmt.Println("Satu = ", 1)
 7 | 	fmt.Println("Dua = ", 2)
 8 | 	fmt.Println("Tiga Koma Lima = ", 3.5)
 9 | }
10 | 


--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="JavaScriptSettings">
4 |     <option name="languageLevel" value="ES6" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/break.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	for i := 0; i < 10; i++ {
 7 | 		if i == 5 {
 8 | 			break
 9 | 		}
10 | 		fmt.Println("Perulangan ke ", i)
11 | 	}
12 | }
13 | 


--------------------------------------------------------------------------------
/continue.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	for i := 0; i < 10; i++ {
 7 | 		if i % 2 == 0 {
 8 | 			continue
 9 | 		}
10 | 		fmt.Println("Perulangan ke", i)
11 | 	}
12 | }
13 | 


--------------------------------------------------------------------------------
/package-initialization.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"belajar-golang-dasar/database"
 5 | 	"fmt"
 6 | )
 7 | 
 8 | func main() {
 9 | 	result :=  database.GetDatabase()
10 | 	fmt.Println(result)
11 | }
12 | 


--------------------------------------------------------------------------------
/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 | # Datasource local storage ignored files
5 | /dataSources/
6 | /dataSources.local.xml
7 | # Editor-based HTTP Client requests
8 | /httpRequests/
9 | 


--------------------------------------------------------------------------------
/database/database.go:
--------------------------------------------------------------------------------
 1 | package database
 2 | 
 3 | import "fmt"
 4 | 
 5 | var connection string
 6 | 
 7 | func init(){
 8 | 	fmt.Println("Init dipanggil")
 9 | 	connection = "MySQL"
10 | }
11 | 
12 | func GetDatabase() string {
13 | 	return connection
14 | }
15 | 


--------------------------------------------------------------------------------
/function.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func sayHello() {
 6 | 	fmt.Println("Hello World")
 7 | 	fmt.Println("Hello World")
 8 | 	fmt.Println("Hello World")
 9 | }
10 | 
11 | func main() {
12 | 	for i := 0; i < 10; i++ {
13 | 		sayHello()
14 | 	}
15 | }
16 | 


--------------------------------------------------------------------------------
/helper/sayhello.go:
--------------------------------------------------------------------------------
 1 | package helper
 2 | 
 3 | import "fmt"
 4 | 
 5 | var version = 1
 6 | var Application = "Belajar Golang"
 7 | 
 8 | func SayHello(name string){
 9 | 	fmt.Println("Hello", name)
10 | }
11 | 
12 | func sayGoodbye(name string){
13 | 	fmt.Println("Goodbye", name)
14 | }


--------------------------------------------------------------------------------
/import.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"belajar-golang-dasar/helper"
 5 | 	"fmt"
 6 | )
 7 | 
 8 | func main() {
 9 | 	helper.SayHello("Eko")
10 | 	// helper.sayGoodbye("Eko") // error
11 | 	fmt.Println(helper.Application)
12 | 	// fmt.Println(helper.version) // error
13 | }
14 | 


--------------------------------------------------------------------------------
/constant.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	const (
 7 | 		firstName string = "Eko"
 8 | 		lastName         = "Khannedy"
 9 | 		value            = 1000
10 | 	)
11 | 
12 | 	fmt.Println(firstName)
13 | 	fmt.Println(lastName)
14 | 	fmt.Println(value)
15 | }
16 | 


--------------------------------------------------------------------------------
/type-declarations.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	type NoKTP string
 7 | 	type Married bool
 8 | 
 9 | 	var noKtpEko NoKTP = "18741982741897419874"
10 | 	var marriedStatus Married = true
11 | 	fmt.Println(noKtpEko)
12 | 	fmt.Println(marriedStatus)
13 | }
14 | 


--------------------------------------------------------------------------------
/pointer-method.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | type Man struct {
 6 | 	Name string
 7 | }
 8 | 
 9 | func (man *Man) Married() {
10 | 	man.Name = "Mr. " + man.Name
11 | }
12 | 
13 | func main() {
14 | 	eko := Man{"Eko"}
15 | 	eko.Married()
16 | 
17 | 	fmt.Println(eko.Name)
18 | }
19 | 


--------------------------------------------------------------------------------
/string.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	fmt.Println("Eko")
 7 | 	fmt.Println("Eko Kurniawan")
 8 | 	fmt.Println("Eko Kurniawan Khannedy")
 9 | 
10 | 	fmt.Println(len("Eko"))
11 | 	fmt.Println("Eko Kurniawan"[0])
12 | 	fmt.Println("Eko Kurniawan Khannedy"[1])
13 | }
14 | 


--------------------------------------------------------------------------------
/function-parameter.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func sayHelloTo(firstName string, lastName string) {
 6 | 	fmt.Println("Hello", firstName, lastName)
 7 | }
 8 | 
 9 | func main() {
10 | 	firstName := "Eko"
11 | 	sayHelloTo(firstName, "Kurniawan")
12 | 	sayHelloTo("Budi", "Nugraha")
13 | }
14 | 


--------------------------------------------------------------------------------
/interface-kosong.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func Ups(i int) interface{} {
 6 | 	if i == 1 {
 7 | 		return 1
 8 | 	} else if i == 2 {
 9 | 		return true
10 | 	} else {
11 | 		return "Ups"
12 | 	}
13 | }
14 | 
15 | func main() {
16 | 	var data interface{} = Ups(3)
17 | 	fmt.Println(data)
18 | }
19 | 


--------------------------------------------------------------------------------
/math.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"math"
 6 | )
 7 | 
 8 | func main() {
 9 | 	fmt.Println(math.Round(1.7))
10 | 	fmt.Println(math.Round(1.3))
11 | 	fmt.Println(math.Floor(1.7))
12 | 	fmt.Println(math.Ceil(1.3))
13 | 
14 | 	fmt.Println(math.Max(10, 20))
15 | 	fmt.Println(math.Min(10, 20))
16 | }
17 | 


--------------------------------------------------------------------------------
/function-as-value.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func getGoodBye(name string) string {
 6 | 	return "Good Bye " + name
 7 | }
 8 | 
 9 | func main() {
10 | 
11 | 	sayGoodBye := getGoodBye
12 | 
13 | 	result := sayGoodBye("Eko")
14 | 	fmt.Println(result)
15 | 	fmt.Println(getGoodBye("Eko"))
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectModuleManager">
4 |     <modules>
5 |       <module fileurl="file://$PROJECT_DIR$/.idea/belajar-golang-dasar.iml" filepath="$PROJECT_DIR$/.idea/belajar-golang-dasar.iml" />
6 |     </modules>
7 |   </component>
8 | </project>


--------------------------------------------------------------------------------
/.idea/belajar-golang-dasar.iml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <module type="WEB_MODULE" version="4">
3 |   <component name="NewModuleRootManager">
4 |     <content url="file://$MODULE_DIR$" />
5 |     <orderEntry type="inheritedJdk" />
6 |     <orderEntry type="sourceFolder" forTests="false" />
7 |   </component>
8 | </module>


--------------------------------------------------------------------------------
/function-return-multiple-value.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func getFullName() (string, string, string) {
 6 | 	return "Eko", "Kurniawan", "Khannedy"
 7 | }
 8 | 
 9 | func main() {
10 | 	firstName, _, _ := getFullName()
11 | 	fmt.Println(firstName)
12 | 	// fmt.Println(middleName)
13 | 	// fmt.Println(lastName)
14 | }
15 | 


--------------------------------------------------------------------------------
/function-return-value.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func getHello(name string) string {
 6 | 	if name == "" {
 7 | 		return "Hello Bro"
 8 | 	} else {
 9 | 		return "Hello " + name
10 | 	}
11 | }
12 | 
13 | func main() {
14 | 	result := getHello("Eko")
15 | 	fmt.Println(result)
16 | 
17 | 	fmt.Println(getHello(""))
18 | }
19 | 


--------------------------------------------------------------------------------
/closure.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	name := "Eko"
 7 | 	counter := 0
 8 | 
 9 | 	increment := func() {
10 | 		name := "Budi"
11 | 		fmt.Println("Increment")
12 | 		counter++
13 | 		fmt.Println(name)
14 | 	}
15 | 
16 | 	increment()
17 | 	increment()
18 | 
19 | 	fmt.Println(counter)
20 | 	fmt.Println(name)
21 | }
22 | 


--------------------------------------------------------------------------------
/defer.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func logging(){
 6 | 	fmt.Println("Selesai memanggil function")
 7 | }
 8 | 
 9 | func runApplication(value int){
10 | 	defer logging()
11 | 	fmt.Println("Run application")
12 | 	result := 10 / value
13 | 	fmt.Println("Result", result)
14 | }
15 | 
16 | func main() {
17 | 	runApplication(10)
18 | }
19 | 


--------------------------------------------------------------------------------
/function-return-named-value.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func getFullName2() (firstName string, middleName string, lastName string) {
 6 | 	firstName = "Eko"
 7 | 	middleName = "Kurniawan"
 8 | 	lastName = "Khannedy"
 9 | 
10 | 	return
11 | }
12 | 
13 | func main() {
14 | 	a, b, c := getFullName2()
15 | 	fmt.Println(a)
16 | 	fmt.Println(b)
17 | 	fmt.Println(c)
18 | }
19 | 


--------------------------------------------------------------------------------
/ring.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"container/ring"
 5 | 	"fmt"
 6 | 	"strconv"
 7 | )
 8 | 
 9 | func main() {
10 | 	var data *ring.Ring = ring.New(5)
11 | 
12 | 	for i := 0; i < data.Len() ; i ++ {
13 | 		data.Value = "Data " + strconv.FormatInt(int64(i), 10)
14 | 		data = data.Next()
15 | 	}
16 | 
17 | 	data.Do(func(value interface{}) {
18 | 		fmt.Println(value)
19 | 	})
20 | }
21 | 


--------------------------------------------------------------------------------
/function-variadic.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func sumAll(numbers ...int) int {
 6 | 	total := 0
 7 | 	for _, value := range numbers {
 8 | 		total += value
 9 | 	}
10 | 	return total
11 | }
12 | 
13 | func main() {
14 | 	total := sumAll(10, 90, 30, 50, 40)
15 | 	fmt.Println(total)
16 | 
17 | 	slice := []int{10,20,30,40,50}
18 | 	total = sumAll(slice...)
19 | 	fmt.Println(total)
20 | }
21 | 


--------------------------------------------------------------------------------
/regexp.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"regexp"
 6 | )
 7 | 
 8 | func main() {
 9 | 	var regex *regexp.Regexp = regexp.MustCompile("e([a-z])o")
10 | 
11 | 	fmt.Println(regex.MatchString("eko"))
12 | 	fmt.Println(regex.MatchString("eto"))
13 | 	fmt.Println(regex.MatchString("eDo"))
14 | 
15 | 	search := regex.FindAllString("eko eka edo eto eyo eki", -1)
16 | 	fmt.Println(search)
17 | }
18 | 


--------------------------------------------------------------------------------
/boolean-operator.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	var ujian = 80
 8 | 	var absensi = 75
 9 | 
10 | 	var lulusUjian = ujian >= 80
11 | 	var lulusAbsensi = absensi >= 80
12 | 	fmt.Println(lulusUjian)
13 | 	fmt.Println(lulusAbsensi)
14 | 
15 | 	var lulus = lulusAbsensi && lulusUjian
16 | 	fmt.Println(lulus)
17 | 
18 | 	fmt.Println(ujian >= 80 && absensi >= 80)
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/comparation-operator.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	var name1 = "Eko"
 8 | 	var name2 = "Budi"
 9 | 
10 | 	var result bool = name1 == name2
11 | 	fmt.Println(result)
12 | 
13 | 	var value1 = 100
14 | 	var value2 = 200
15 | 
16 | 	fmt.Println(value1 > value2)
17 | 	fmt.Println(value1 < value2)
18 | 	fmt.Println(value1 == value2)
19 | 	fmt.Println(value1 != value2)
20 | 
21 | }
22 | 


--------------------------------------------------------------------------------
/conversion.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	var nilai32 int32 = 129
 7 | 	var nilai64 int64 = int64(nilai32)
 8 | 	var nilai8 int8 = int8(nilai32)
 9 | 
10 | 	fmt.Println(nilai32)
11 | 	fmt.Println(nilai64)
12 | 	fmt.Println(nilai8)
13 | 
14 | 	var name = "Eko"
15 | 	var e byte = name[0]
16 | 	var eString string = string(e)
17 | 
18 | 	fmt.Println(name)
19 | 	fmt.Println(eString)
20 | }
21 | 


--------------------------------------------------------------------------------
/nil.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func NewMap(name string) map[string]string {
 6 | 	if name == "" {
 7 | 		return nil
 8 | 	} else {
 9 | 		return map[string]string{
10 | 			"name": name,
11 | 		}
12 | 	}
13 | }
14 | 
15 | func main() {
16 | 	var person map[string]string = NewMap("Eko")
17 | 
18 | 	if person == nil {
19 | 		fmt.Println("Data Kosong")
20 | 	}else {
21 | 		fmt.Println(person)
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/panic.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func endApp(){
 6 | 	message := recover()
 7 | 	if message != nil {
 8 | 		fmt.Println("Error dengan message:", message)
 9 | 	}
10 | 	fmt.Println("Aplikasi selesai")
11 | }
12 | 
13 | func runApp(error bool){
14 | 	defer endApp()
15 | 	if error {
16 | 		panic("APLIKASI ERROR")
17 | 	}
18 | 	fmt.Println("Aplikasi berjalan")
19 | }
20 | 
21 | func main() {
22 | 	runApp(true)
23 | 	fmt.Println("Eko")
24 | }
25 | 


--------------------------------------------------------------------------------
/math-operation.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	var result = 10 + 10
 8 | 	fmt.Println(result)
 9 | 
10 | 	var a = 10
11 | 	var b = 10
12 | 	var c = a * b
13 | 	fmt.Println(c)
14 | 
15 | 	var i = 10
16 | 	i += 10 // i = i + 10
17 | 	fmt.Println(i)
18 | 
19 | 	i++ // i = i + 1
20 | 	fmt.Println(i)
21 | 
22 | 	var negative = -100
23 | 	var positive = +100
24 | 	fmt.Println(negative)
25 | 	fmt.Println(positive)
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/interface-error.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 	"fmt"
 6 | )
 7 | 
 8 | func Pembagi(nilai int, pembagi int) (int, error) {
 9 | 	if pembagi == 0 {
10 | 		return 0, errors.New("Pembagi tidak boleh 0")
11 | 	}else {
12 | 		result := nilai / pembagi
13 | 		return result, nil
14 | 	}
15 | }
16 | 
17 | func main() {
18 | 	hasil, err := Pembagi(100, 0)
19 | 	if err == nil{
20 | 		fmt.Println("Hasil", hasil)
21 | 	}else {
22 | 		fmt.Println("Error", err.Error())
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/os.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"os"
 6 | )
 7 | 
 8 | func main() {
 9 | 	args := os.Args
10 | 	fmt.Println("Argument : ")
11 | 	fmt.Println(args)
12 | 
13 | 	name, err := os.Hostname()
14 | 	if err == nil {
15 | 		fmt.Println("Hostname : ", name)
16 | 	} else {
17 | 		fmt.Println("Error", err.Error())
18 | 	}
19 | 
20 | 	username := os.Getenv("APP_USERNAME")
21 | 	password := os.Getenv("APP_PASSWORD")
22 | 
23 | 	fmt.Println(username)
24 | 	fmt.Println(password)
25 | }
26 | 


--------------------------------------------------------------------------------
/type-assertions.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func random() interface{} {
 6 | 	return "Eko"
 7 | }
 8 | 
 9 | func main() {
10 | 	var result interface{} = random()
11 | 	//var resultString string = result.(string)
12 | 	//fmt.Println(resultString)
13 | 
14 | 	switch value := result.(type) {
15 | 	case string:
16 | 		fmt.Println("Value", value, "is string")
17 | 	case int:
18 | 		fmt.Println("Value", value, "is int")
19 | 	default:
20 | 		fmt.Println("Unknown type")
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/if.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	var name = "Kurniawan"
 7 | 
 8 | 	if name == "Eko" {
 9 | 		fmt.Println("Hello Eko")
10 | 	} else if name == "Joko" {
11 | 		fmt.Println("Hello Joko")
12 | 	} else if name == "Budi" {
13 | 		fmt.Println("Hello Budi")
14 | 	} else {
15 | 		fmt.Println("Hi, kenalan donk")
16 | 	}
17 | 
18 | 	if length := len(name); length > 5 {
19 | 		fmt.Println("Terlalu Panjang")
20 | 	} else {
21 | 		fmt.Println("Nama sudah benar")
22 | 	}
23 | }
24 | 


--------------------------------------------------------------------------------
/function-as-parameter.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | type Filter func(string) string
 6 | 
 7 | func sayHelloWithFilter(name string, filter Filter) {
 8 | 	nameFiltered := filter(name)
 9 | 	fmt.Println("Hello", nameFiltered)
10 | }
11 | 
12 | func spamFilter(name string) string {
13 | 	if name == "Anjing" {
14 | 		return "..."
15 | 	}else {
16 | 		return name
17 | 	}
18 | }
19 | 
20 | func main() {
21 | 	sayHelloWithFilter("Eko", spamFilter)
22 | 	sayHelloWithFilter("Anjing", spamFilter)
23 | }
24 | 


--------------------------------------------------------------------------------
/variable.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	var name string
 7 | 
 8 | 	name = "Eko Kurniawan"
 9 | 	fmt.Println(name)
10 | 
11 | 	name = "Eko Khannedy"
12 | 	fmt.Println(name)
13 | 
14 | 	var friendName = "Budi"
15 | 	fmt.Println(friendName)
16 | 
17 | 	var age = 30
18 | 	fmt.Println(age)
19 | 
20 | 	country := "Indonesia"
21 | 	fmt.Println(country)
22 | 
23 | 	var (
24 | 		firstName = "Eko"
25 | 		lastName = "Khannedy"
26 | 	)
27 | 
28 | 	fmt.Println(firstName)
29 | 	fmt.Println(lastName)
30 | }
31 | 


--------------------------------------------------------------------------------
/time.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"time"
 6 | )
 7 | 
 8 | func main() {
 9 | 	now := time.Now()
10 | 
11 | 	fmt.Println(now)
12 | 	fmt.Println(now.Year())
13 | 	fmt.Println(now.Month())
14 | 	fmt.Println(now.Day())
15 | 	fmt.Println(now.Hour())
16 | 	fmt.Println(now.Minute())
17 | 	fmt.Println(now.Second())
18 | 	fmt.Println(now.Nanosecond())
19 | 
20 | 	utc := time.Date(2020, 10, 10, 10, 10, 10, 10, time.UTC)
21 | 	fmt.Println(utc)
22 | 
23 | 	layout := "2006-01-02"
24 | 	parse, _ := time.Parse(layout, "1990-03-20")
25 | 	fmt.Print(parse)
26 | }
27 | 


--------------------------------------------------------------------------------
/strconv.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"strconv"
 6 | )
 7 | 
 8 | func main() {
 9 | 	boolean, err := strconv.ParseBool("true")
10 | 	if err == nil {
11 | 		fmt.Println(boolean)
12 | 	} else {
13 | 		fmt.Println(err.Error())
14 | 	}
15 | 
16 | 	number, err := strconv.ParseInt("1000000", 10, 64)
17 | 	if err == nil {
18 | 		fmt.Println(number)
19 | 	} else {
20 | 		fmt.Println(err.Error())
21 | 	}
22 | 
23 | 	value := strconv.FormatInt(1000000, 10)
24 | 	fmt.Println(value)
25 | 
26 | 	valueInt, _ :=  strconv.Atoi("2000000")
27 | 	fmt.Println(valueInt)
28 | }
29 | 


--------------------------------------------------------------------------------
/container-list.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"container/list"
 5 | 	"fmt"
 6 | )
 7 | 
 8 | func main() {
 9 | 	data := list.New()
10 | 
11 | 	data.PushBack("Eko")
12 | 	data.PushBack("Kurniawan")
13 | 	data.PushBack("Khannedy")
14 | 	data.PushFront("Budi")
15 | 
16 | 	// dari depan ke belakang
17 | 	for element := data.Front(); element != nil; element = element.Next() {
18 | 		fmt.Println(element.Value)
19 | 	}
20 | 
21 | 	// dari belakang ke depan
22 | 	for element := data.Back(); element != nil; element = element.Prev() {
23 | 		fmt.Println(element.Value)
24 | 	}
25 | }
26 | 


--------------------------------------------------------------------------------
/array.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	var names [3]string
 8 | 
 9 | 	names[0] = "Eko"
10 | 	names[1] = "Kurniawan"
11 | 	names[2] = "Khannedy"
12 | 
13 | 	fmt.Println(names[0])
14 | 	fmt.Println(names[1])
15 | 	fmt.Println(names[2])
16 | 
17 | 	var values = [3]int{
18 | 		90,
19 | 		95,
20 | 		80,
21 | 	}
22 | 
23 | 	fmt.Println(values)
24 | 	fmt.Println(values[0])
25 | 	fmt.Println(values[1])
26 | 	fmt.Println(values[2])
27 | 
28 | 	fmt.Println(len(names))
29 | 	fmt.Println(len(values))
30 | 
31 | 	var lagi [10]string
32 | 
33 | 	fmt.Println(len(lagi))
34 | }
35 | 


--------------------------------------------------------------------------------
/flag.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"fmt"
 6 | )
 7 | 
 8 | func main() {
 9 | 	var host *string = flag.String("host", "localhost", "Put your database host")
10 | 	var user *string = flag.String("user", "root", "Put your database user")
11 | 	var password *string = flag.String("password", "root", "Put your database password")
12 | 	var number *int = flag.Int("number", 100, "Put your number")
13 | 
14 | 	flag.Parse()
15 | 
16 | 	fmt.Println("Host : ", *host)
17 | 	fmt.Println("User : ", *user)
18 | 	fmt.Println("Password : ", *password)
19 | 	fmt.Println("Number : ", *number)
20 | }
21 | 


--------------------------------------------------------------------------------
/function-recursive.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func factorialLoop(value int) int {
 6 | 	result := 1
 7 | 	for i := value; i > 0; i-- {
 8 | 		result *= i // result = result * i
 9 | 	}
10 | 	return result
11 | }
12 | 
13 | func factorialRecursive(value int) int {
14 | 	if value == 1 {
15 | 		return 1
16 | 	} else {
17 | 		return value * factorialRecursive(value-1)
18 | 	}
19 | }
20 | 
21 | func main() {
22 | 	loop := factorialLoop(10)
23 | 	fmt.Println(loop)
24 | 	// fmt.Println(5 * 4 * 3 * 2 * 1)
25 | 
26 | 	recursive := factorialRecursive(10)
27 | 	fmt.Println(recursive)
28 | }
29 | 


--------------------------------------------------------------------------------
/map.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	person := map[string]string{
 8 | 		"name":    "Eko",
 9 | 		"address": "Subang",
10 | 	}
11 | 
12 | 	person["title"] = "Programmer"
13 | 
14 | 	fmt.Println(person)
15 | 	fmt.Println(person["name"])
16 | 	fmt.Println(person["address"])
17 | 
18 | 	var book map[string]string = make(map[string]string)
19 | 	book["title"] = "Belajar Go-Lang"
20 | 	book["author"] = "Eko"
21 | 	book["ups"] = "Salah"
22 | 	fmt.Println(book)
23 | 	fmt.Println(len(book))
24 | 
25 | 	delete(book, "ups")
26 | 
27 | 	fmt.Println(book)
28 | 	fmt.Println(len(book))
29 | }
30 | 


--------------------------------------------------------------------------------
/strings.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"strings"
 6 | )
 7 | 
 8 | func main() {
 9 | 	fmt.Println(strings.Contains("Eko Kurniawan", "Eko"))
10 | 	fmt.Println(strings.Contains("Eko Kurniawan", "Budi"))
11 | 
12 | 	fmt.Println(strings.Split("Eko Kurniawna Khannedy", " "))
13 | 
14 | 	fmt.Println(strings.ToLower("Eko Kurniawan Khannedy"))
15 | 	fmt.Println(strings.ToUpper("Eko Kurniawan Khannedy"))
16 | 	fmt.Println(strings.ToTitle("eko kurniawan khannedy"))
17 | 
18 | 	fmt.Println(strings.Trim("      Eko Kurniawan     ", " "))
19 | 	fmt.Println(strings.ReplaceAll("Eko Joko Eko", "Eko", "Budi"))
20 | }
21 | 


--------------------------------------------------------------------------------
/for.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	for counter := 1; counter <= 10; counter++ {
 7 | 		fmt.Println("Perulangan ke", counter)
 8 | 	}
 9 | 
10 | 	slice := []string{"Eko", "Kurniawan", "Khannedy", "Budi", "Joko"}
11 | 
12 | 	for i := 0; i < len(slice); i++ {
13 | 		fmt.Println(slice[i])
14 | 	}
15 | 
16 | 	for i, value := range slice {
17 | 		fmt.Println("Index", i, "=", value)
18 | 	}
19 | 
20 | 	person := make(map[string]string)
21 | 	person["name"] = "Eko"
22 | 	person["title"] = "Programmer"
23 | 
24 | 	for key, value := range person {
25 | 		fmt.Println(key, "=", value)
26 | 	}
27 | }
28 | 


--------------------------------------------------------------------------------
/interface.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | type HasName interface {
 6 | 	GetName() string
 7 | }
 8 | 
 9 | func SayHello(hasName HasName) {
10 | 	fmt.Println("Hello", hasName.GetName())
11 | }
12 | 
13 | type Person struct {
14 | 	Name string
15 | }
16 | 
17 | func (person Person) GetName() string {
18 | 	return person.Name
19 | }
20 | 
21 | type Animal struct {
22 | 	Name string
23 | }
24 | 
25 | func (animal Animal) GetName() string {
26 | 	return animal.Name
27 | }
28 | 
29 | func main() {
30 | 	var eko Person
31 | 	eko.Name = "Eko"
32 | 
33 | 	SayHello(eko)
34 | 
35 | 	cat := Animal{
36 | 		Name: "Push",
37 | 	}
38 | 	SayHello(cat)
39 | }
40 | 


--------------------------------------------------------------------------------
/sort.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"sort"
 6 | )
 7 | 
 8 | type User struct {
 9 | 	Name string
10 | 	Age  int
11 | }
12 | 
13 | type UserSlice []User
14 | 
15 | func (value UserSlice) Len() int {
16 | 	return len(value)
17 | }
18 | 
19 | func (value UserSlice) Less(i, j int) bool {
20 | 	return value[i].Age < value[j].Age
21 | }
22 | 
23 | func (value UserSlice) Swap(i, j int) {
24 | 	value[i], value[j] = value[j], value[i]
25 | }
26 | 
27 | func main() {
28 | 	users := []User {
29 | 		{"Eko", 30},
30 | 		{"Jokok", 35},
31 | 		{"Budi", 31},
32 | 		{"Rudi", 25},
33 | 	}
34 | 
35 | 	fmt.Println(users)
36 | 	sort.Sort(UserSlice(users))
37 | 	fmt.Println(users)
38 | }
39 | 


--------------------------------------------------------------------------------
/switch.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	name := "Kurniawan"
 8 | 
 9 | 	switch name {
10 | 	case "Eko":
11 | 		fmt.Println("Hello Eko")
12 | 		fmt.Println("Hello Eko")
13 | 	case "Joko":
14 | 		fmt.Println("Hello Joko")
15 | 		fmt.Println("Hello Joko")
16 | 	default:
17 | 		fmt.Println("Kenalan Donk")
18 | 		fmt.Println("Kenalan Donk")
19 | 	}
20 | 
21 | 	//switch length := len(name); length > 5 {
22 | 	//case true:
23 | 	//	fmt.Println("Nama terlalu panjang")
24 | 	//case false:
25 | 	//	fmt.Println("Nama sudah benar")
26 | 	//}
27 | 
28 | 	length := len(name)
29 | 	switch {
30 | 	case length > 10:
31 | 		fmt.Println("Nama terlalu panjang")
32 | 	case length > 5:
33 | 		fmt.Println("Nama lumayan panjang")
34 | 	default:
35 | 		fmt.Println("Nama sudah benar")
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/struct.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | type Customer struct {
 6 | 	Name, Address string
 7 | 	Age           int
 8 | }
 9 | 
10 | func (customer Customer) sayHi(name string){
11 | 	fmt.Println("Hello", name, "My Name is", customer.Name)
12 | }
13 | 
14 | func (a Customer) sayHuuu(){
15 | 	fmt.Println("Huuuuuu from", a.Name)
16 | }
17 | 
18 | func main() {
19 | 	var eko Customer
20 | 	eko.Name = "Eko"
21 | 	eko.Address = "Indonesia"
22 | 	eko.Age = 30
23 | 
24 | 	eko.sayHi("Joko")
25 | 	eko.sayHuuu()
26 | 
27 | 	//fmt.Println(eko.Name)
28 | 	//fmt.Println(eko.Address)
29 | 	//fmt.Println(eko.Age)
30 | 	//
31 | 	//joko := Customer{
32 | 	//	Name:    "Joko",
33 | 	//	Address: "Cirebon",
34 | 	//	Age:     35,
35 | 	//}
36 | 	//fmt.Println(joko)
37 | 	//
38 | 	//budi := Customer{"Budi", "Jakarta", 35}
39 | 	//fmt.Println(budi)
40 | }
41 | 


--------------------------------------------------------------------------------
/function-anonymous.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | type Blacklist func(string) bool
 6 | 
 7 | func registerUser(name string, blacklist Blacklist) {
 8 | 	if blacklist(name) {
 9 | 		fmt.Println("You are blocked", name)
10 | 	} else {
11 | 		fmt.Println("Welcome", name)
12 | 	}
13 | }
14 | 
15 | //func blacklistAdmin(name string) bool {
16 | //	return name == "admin"
17 | //}
18 | //
19 | //func blacklistRoot(name string) bool {
20 | //	return name == "root"
21 | //}
22 | 
23 | func main() {
24 | 	blacklist := func(name string) bool {
25 | 		return name == "admin"
26 | 	}
27 | 
28 | 	registerUser("admin", blacklist)
29 | 	registerUser("eko", blacklist)
30 | 
31 | 	registerUser("root", func(name string) bool {
32 | 		return name == "root"
33 | 	})
34 | 	registerUser("eko", func(name string) bool {
35 | 		return name == "root"
36 | 	})
37 | }
38 | 


--------------------------------------------------------------------------------
/pointer.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | type Address struct {
 6 | 	City, Province, Country string
 7 | }
 8 | 
 9 | func ChangeCountryToIndonesia(address *Address){
10 | 	address.Country = "Indonesia"
11 | }
12 | 
13 | func main() {
14 | 	var address1 Address = Address{"Subang", "Jawa Barat", "Indonesia"}
15 | 	// var address4 *Address = &Address{"Subang", "Jawa Barat", "Indonesia"}
16 | 	var address2 *Address = &address1
17 | 	var address3 *Address = &address1
18 | 
19 | 	address2.City = "Bandung"
20 | 
21 | 	*address2 = Address{"Malang", "Jawa Timur", "Indonesia"}
22 | 
23 | 	fmt.Println(address1)
24 | 	fmt.Println(address2)
25 | 	fmt.Println(address3)
26 | 
27 | 	var address4 *Address = new(Address)
28 | 	address4.City = "Jakarta"
29 | 	fmt.Println(address4)
30 | 
31 | 	var alamat = Address{
32 | 		City:     "Subang",
33 | 		Province: "Jawa Barat",
34 | 		Country:  "",
35 | 	}
36 | 	var alamatPointer *Address = &alamat
37 | 	ChangeCountryToIndonesia(alamatPointer)
38 | 	fmt.Println(alamat)
39 | }
40 | 


--------------------------------------------------------------------------------
/reflect.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"reflect"
 6 | )
 7 | 
 8 | type Sample struct {
 9 | 	Name string `required:"true" max:"10"`
10 | }
11 | 
12 | type ContohLagi struct {
13 | 	Name string `required:"true"`
14 | 	Description string `required:"true"`
15 | }
16 | 
17 | func IsValid(data interface{}) bool {
18 | 	t := reflect.TypeOf(data)
19 | 	for i := 0; i < t.NumField(); i++ {
20 | 		field := t.Field(i)
21 | 		if field.Tag.Get("required") == "true" {
22 | 			value := reflect.ValueOf(data).Field(i).Interface()
23 | 			if value == "" {
24 | 				return false
25 | 			}
26 | 		}
27 | 	}
28 | 	return true
29 | }
30 | 
31 | func main() {
32 | 	sample := Sample{"Eko"}
33 | 
34 | 	var sampleType reflect.Type = reflect.TypeOf(sample)
35 | 
36 | 	fmt.Println(sampleType.NumField())
37 | 	fmt.Println(sampleType.Field(0).Name)
38 | 	fmt.Println(sampleType.Field(0).Tag.Get("required"))
39 | 	fmt.Println(sampleType.Field(0).Tag.Get("max"))
40 | 
41 | 	sample.Name = ""
42 | 	fmt.Println(IsValid(sample))
43 | 
44 | 	contoh := ContohLagi{"Eko", "Oke"}
45 | 	fmt.Println(IsValid(contoh))
46 | }
47 | 


--------------------------------------------------------------------------------
/slice.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 	var months = [...]string{
 7 | 		"Januari",
 8 | 		"Februari",
 9 | 		"Maret",
10 | 		"April",
11 | 		"Mei",
12 | 		"Juni",
13 | 		"Juli",
14 | 		"Agustus",
15 | 		"September",
16 | 		"Oktober",
17 | 		"November",
18 | 		"Desember",
19 | 	}
20 | 
21 | 	var slice1 = months[4:7]
22 | 	fmt.Println(slice1)
23 | 	fmt.Println(len(slice1))
24 | 	fmt.Println(cap(slice1))
25 | 
26 | 	//months[5] = "Diubah"
27 | 	//fmt.Println(slice1)
28 | 
29 | 	//slice1[0] = "Mei Lagi"
30 | 	//fmt.Println(months)
31 | 
32 | 	var slice2 = months[11:]
33 | 	fmt.Println(slice2)
34 | 
35 | 	var slice3 = append(slice2, "Eko")
36 | 	fmt.Println(slice3)
37 | 	slice3[1] = "Bukan Desember"
38 | 	fmt.Println(slice3)
39 | 
40 | 	fmt.Println(slice2)
41 | 	fmt.Println(months)
42 | 
43 | 	newSlice := make([]string, 2, 5)
44 | 
45 | 	newSlice[0] = "Eko"
46 | 	newSlice[1] = "Kurniawan"
47 | 
48 | 	fmt.Println(newSlice)
49 | 	fmt.Println(len(newSlice))
50 | 	fmt.Println(cap(newSlice))
51 | 
52 | 	copySlice := make([]string, len(newSlice), cap(newSlice))
53 | 	copy(copySlice, newSlice)
54 | 	fmt.Println(copySlice)
55 | 
56 | 	iniArray := [5]int{1, 2, 3, 4, 5}
57 | 	iniSlice := []int{1, 2, 3, 4, 5}
58 | 
59 | 	fmt.Println(iniArray)
60 | 	fmt.Println(iniSlice)
61 | }
62 | 


--------------------------------------------------------------------------------