GO Basic

GO Basic #

Go 기본적인 문법 정리. 하기 사이트 참조.

Hello World #

package main

func main() {
    println("Hello World!")
}

Declare #

선언 및 할당 방식

declare ...

package main

func main() {
	// 선언 및 할당
	var a int
	var b float32 = 11.

	println(a, b)

	// 선언 및 할당
	a = 10
	b = 12.0

	println(a, b)

	// 상수
	const c int = 10
	const d string = "Hello"

	println(c, d)

	// 상수 나열
	const (
		Visa   = "Visa"
		Master = "MasterCard"
		Amex   = "American Express"
	)

	println(Visa, Master, Amex)

	// 상수 나열
	const (
		Apple = iota
		Grape
		Orage
	)

	println(Apple, Grape, Orage)
}

Reserved Keywords #

GO 25개 예약어

break, case, chan, const, continue, const, default, const, defer, else,fallthrough, for, func, go, goto, if, import, interface, map, package, range, return, select, struct, switch, type, var

Declaration of Varialbe and Operators #

변수 선언 및 연산자

declaration of varialbe ...

func main() {
	textLine1 := `첫번째 줄입니다.\n
두번째 줄입니다.\n
	세번째 줄입니다`

	fmt.Println(textLine1)

	textLine2 := "첫번째 줄입니다.\n두번째 줄입니다.\n세번째 줄입니다"

	fmt.Println(textLine2)

	textLine3 := "첫번째 줄입니다.\n" + "두번째 줄입니다.\n" + "세번째 줄입니다"

	fmt.Println(textLine3)

	var a int = 100
	var b uint = uint(a)
	var c float32 = float32(a)

	println(a, b, c)

	str := "ABCDEFG"
	byt := []byte(str)
	stg := string(byt)
	println(str, byt, byt[0], byt[1], stg)
}

operators ...

package main

func main() {
	var a int = 7
	var b int = 3

	//산술연산자
	var c = (a + b) / 5

	println(a, b, c)

	c++
	println(c)

	// 관계연산자
	if b == c {
		println("b==c")
	} else {
		println("b!=c")
	}

	if a != b {
		println("a!=b")
	} else {
		println("a==b")
	}

	if a >= b {
		println("a>=b")
	} else {
		println("a< b")
	}

	// 논리 연산자
	if a >= b && b == c {
		println("a>=b && b==c")
	} else {
		println("not(a>=b && b==c)")
	}

	if a >= b || b > c {
		println("a>=b || b<>c")
	} else {
		println("not(a>=b || b<>c)")
	}

	// Bitwise 연산자
	var d = (a & b)
	var e = (a & b) << 1

	println(d, e)

	// 할당연산자
	a = 10
	println(a)
	a *= 10
	println(a)
	a >>= 1
	println(a)
	a |= 1
	println(a)

	// 포인터 연산자
	var x int = 10
	var p = &x //x's address

	// x = value
	// &x = x's address
	// p = &x = x's address
	// *p = x's address's value
	// &p = p's address
	println(x, &x, p, *p, &p)

	x++

	println(x, &x, p, *p, &p)
}

Conditional Statement #

conditional statement ...

package main

func main() {
	var a = 1

	if a == 1 {
		println("One")
	} else if a == 2 {
		println("Two")
	} else {
		println("Other")
	}

	// Optional Statement
	if b := 1; b < 10 {
		println(b)
	}

	var name string
	var category = 1

	switch category {
	case 1:
		name = "Paper Book"
	case 2:
		name = "eBook"
	case 3, 4:
		name = "Blog"
	default:
		name = "Other"
	}
	println(name)

	// Expression을 사용한 경우
	switch x := category << 2; x - 1 {
	//...
	}

	var score = 80

	switch {
	case score >= 90:
		println("A")
	case score >= 80:
		println("B")
	case score >= 70:
		println("C")
	case score >= 60:
		println("D")
	default:
		println("No Hope")
	}
}

Iteration #

iteration ...

package main

func main() {
	sum := 0

	for i := 1; i <= 100; i++ {
		sum += i
	}

	println(sum)

	n := 2

	for n < 100 {
		n = n * n
	}

	println(n)

	names := []string{"abc", "def", "geh"}

	for index, name := range names {
		println(index, name)
	}

	b := 0

L1:
	for {
		if b == 0 {
			break L1
		}
	}

	println("L1", b)

	var a = 1
	for a < 15 {
		if a == 5 {
			a += 4
			continue
		}
		a++
		println("In", a)
		if a > 9 {
			println("Here", a)
			break
		}
	}
	if a == 11 {
		goto END
	}
	println(a)

END:
	println("End", a)
}

‘goto END’는 END 레이블로 이동 ‘break L1’은 break 레이블로 위치를 이동.

Method #

method ...

package main

func main() {
	msg := "Hello"

	// Function
	say(msg)
	println("2", msg)

	// Pass By Reference
	sayC(&msg)
	println("4", msg)

	// Variadic Function
	sayV("this", "is", "a", "pen")
	sayV("and", "pineapple")

	// Return Value
	total := sum(1, 7, 3, 5, 9)
	println(total)

	// Return Multiple Value
	count, total := sumC(1, 7, 3, 5, 9)
	println(count, total)

	// Named Return Parameter
	count, total = sumN(1, 7, 3, 5, 9)
	println("Named Return Param", count, total)

	// Anonymous Function
	sumA := func(n ...int) int { //익명함수 정의
		s := 0
		for _, i := range n {
			s += i
		}
		return s
	}

	result := sumA(1, 2, 3, 4, 5)
	println("result :", result)

	// add anonymouse function : 함수명을 갖지 않는 함수
	add := func(i int, j int) int {
		return i + j
	}

	// send anonumous function to other function
	r1 := calc(add, 10, 20)
	println("r1 :", r1)

	// First-Calss function : 다른함수에 파라미터나 리턴값으로 사용되는 함수
	r2 := calc(func(x int, y int) int { return x - y }, 10, 20)
	println("r2 :", r2)

	// prototype function
	r3 := calcP(add, 10, 25)
	println("r3 :", r3)

	// closure : 함수 바깥에 있는 변수를 참조하는 Function Value
	next1 := nextValue()
	println("next1", next1())
	println("next1", next1())
	println("next1", next1())

	next2 := nextValue()
	println("next2", next2())
	println("next2", next2())
	println("next1", next1())
}

func say(msg string) {
	println("1", msg)
}

func sayC(msg *string) {
	println("3", *msg)
	*msg = "World"
}

func sayV(msg ...string) {
	for _, s := range msg {
		println(s)
	}
}

func sum(nums ...int) int {
	s := 0
	for _, n := range nums {
		s += n
	}
	return s
}

func sumC(nums ...int) (int, int) {
	s := 0
	count := 0
	for _, n := range nums {
		s += n
		count++
	}
	return count, s
}

func sumN(nums ...int) (count int, total int) {
	for _, n := range nums {
		total += n
	}
	count = len(nums)
	return
}

func calc(f func(int, int) int, a int, b int) int {
	result := f(a, b)
	return result
}

// prototype
type calculator func(int, int) int

// use prototype function
func calcP(f calculator, a int, b int) int {
	result := f(a, b)
	return result
}

// closure
func nextValue() func() int {
	i := 0
	return func() int {
		i++
		return i
	}
}

Array / Slice / Map #

배열은 연속적인 메모리 공간에 동일한 타입의 데이터를 순서적으로 저장하는 자료구조. 슬라이스는 내부적으로 배열에 기초하여 만들어졌으나 크기를 동적으로 변할 수도 있고 부분 배열을 발췌할 수 있음.

array and slice ...

package main

import "fmt"

func main() {
	// Array
	var arr1 [3]int
	arr1[0] = 1
	arr1[1] = 2
	arr1[2] = 3
	println("arr1[0] : ", arr1[0], "arr1[1] : ", arr1[1], "arr1[2] : ", arr1[2])

	var arr2 = [3]int{4, 5, 6}
	var arr3 = [...]int{7, 8, 9}

	println("arr2[0] : ", arr2[0], "arr2[1] : ", arr2[1], "arr2[2] : ", arr2[2])
	println("arr3[0] : ", arr3[0], "arr3[1] : ", arr3[1], "arr3[2] : ", arr3[2])

	// multi array 1
	var arr4 [3][4][5]int
	arr4[0][1][2] = 10
	println("arr4[0][1][2] : ", arr4[0][1][2])

	// multi array 2
	var arr5 = [2][3]int{{1, 2, 3}, {4, 5, 6}}
	println("arr5[1][2] : ", arr5[1][2])

	// Slice
	var slc1 []int
	slc1 = []int{1, 2, 3}
	slc1[1] = 10
	fmt.Println("slc1 : ", slc1)

	// Slice with Make
	slc2 := make([]int, 5, 10)
	println(len(slc2), cap(slc2))
	fmt.Println(slc2)

	// Nil Slice
	var slc3 []int

	if slc3 == nil {
		println("Nil Slice")
	}
	println(len(slc3), cap(slc3))
	fmt.Println(slc3)

	// Sub Slice
	slc4 := []int{0, 1, 2, 3, 4, 5}
	fmt.Println("[0:1] : ", slc4[0:1], ",[2:5] : ", slc4[2:5], ",[1:] : ", slc4[1:], ",[:5] : ", slc4[:5])

	// Slice append / copy
	slc5 := []int{0, 1}

	// append one
	slc5 = append(slc5, 2)

	// append multiple
	slc5 = append(slc5, 3, 4, 5)

	fmt.Println(slc5)

	// Underlying array
	slc6 := make([]int, 0, 3)

	for i := 1; i < 15; i++ {
		slc6 = append(slc6, i)
		fmt.Println("slc6 len, cap : ", len(slc6), cap(slc6))
	}

	fmt.Println(slc6)

	// append slice & ellipsis(...)
	slc7 := []int{1, 2, 3}
	slc8 := []int{4, 5, 6}
	slc7 = append(slc7, slc8...)
	fmt.Println(slc7)

	// slice copy
	slc9 := []int{0, 1, 2}
	slc10 := make([]int, len(slc9), cap(slc9)*2)
	copy(slc10, slc9)
	fmt.Println(slc10)
	println(len(slc10), cap(slc10))
}

Map은 Key에 대응하는 Value를 찾는 Hash Table을 구현한 자료구조.

map ...

package main

import "fmt"

func main() {
	// map 1
	var map01 map[int]string

	map01 = make(map[int]string)
	map01[901] = "Apple"
	map01[134] = "Grape"
	map01[777] = "Tomato"

	str := map01[134]
	println("134 :", str)
	str = map01[999]
	println("999 :", str)
	str = map01[777]
	println("777 :", str)
	delete(map01, 777)
	println("777 :", str)

	// map key check
	map02 := map[string]string{
		"GOO": "Google",
		"MSF": "Microsoft",
		"FBK": "Facebook",
		"AMZ": "Amazon",
	}

	val, exists := map02["MSF"]
	if !exists {
		println("No MSF MAP02")
	}

	println("Exists :", val, exists)

	// map for loop
	map03 := map[string]string{
		"A": "Apple",
		"B": "Banana",
		"C": "Charlie",
	}

	for key, val := range map03 {
		fmt.Println(key, val)
	}
}

Package #

package ...

/lib/lib01.go

package lib01

import "fmt"

var pop map[string]string

func init() {
	pop = make(map[string]string)
	pop["A"] = "Apple"
	pop["B"] = "Banana"
	pop["C"] = "Chocolate"
}

func GetItems(item string) string {
	return pop[item]
}

func getKeys() {
	for _, kv := range pop {
		fmt.Println(kv)
	}
}

main.go

package main

import lib01 "./lib"

func main() {
	// package
	item := lib01.GetItems("A")
	println(item)
}

Struct #

struct ...

package main

import "fmt"

// struct
type person struct {
	name string
	age  int
}

type dict struct {
	data map[int]string
}

func newDict() *dict {
	dic := dict{}
	dic.data = map[int]string{}
	return &dic
}

func main() {
	// person struct
	per1 := person{}

	per1.name = "Lee"
	per1.age = 18

	fmt.Println(per1)

	// person struct 2
	var per2 person
	per2 = person{"Bob", 20}
	per3 := person{name: "Sean", age: 30}
	fmt.Println(per2)
	fmt.Println(per3)

	// person struct 3
	per4 := new(person)
	per4.name = "Kim"

	fmt.Println(per4)

	// constructor
	dic1 := newDict()
	dic1.data[1] = "A"

	fmt.Println(dic1)
}

Method / Interface #

method / interface ...

package main

import (
	"fmt"
	"math"
)

// struct
type Rect struct {
	width, height int
}

// method
func (r Rect) area() int {
	return r.width * r.height
}

// method
func (r *Rect) area2() int {
	r.width++
	return r.width * r.height
}

// interface
type Shpe interface {
	area() float64
	peri() float64
}

type RectF struct {
	width, height float64
}

type CircF struct {
	radius float64
}

// interface
func (r RectF) area() float64 { return r.width * r.height }
func (r RectF) peri() float64 { return 2 * (r.width + r.height) }
func (c CircF) area() float64 { return math.Pi * c.radius * c.radius }
func (c CircF) peri() float64 { return 2 * math.Pi * c.radius }

func showArea(shpe ...Shpe) {
	for _, s := range shpe {
		a := s.area()
		println(a)
	}
}

func main() {
	rect := Rect{10, 20}
	area := rect.area()
	println(area)
	area = rect.area2()
	println(area)

	rectf := RectF{10., 20.}
	circf := CircF{10}
	showArea(rectf, circf)

	// empty interface
	var type_x interface{}
	type_x = 1
	type_x = "Jake"

	printIt(type_x)

	// Type Assertion
	var type_y interface{} = 1
	var_i := type_y
	var_j := type_y.(int)

	println(var_i) // pointer address
	println(var_j) // 1
}

func printIt(type_v interface{}) {
	fmt.Println(type_v)
}

Error / Defer / Panic / Recover #

error / defer / panic / recover ...

package main

import (
	"fmt"
	"os"
)

func main() {
	// // Error 처리
	// f, err := os.Open("C:\\temp\\1.txt")
	// if err != nil {
	// 	println("Error!!!")
	// 	log.Fatal(err.Error())
	// }
	// println(f.Name())

	// // defer
	// f, err := os.Open("1.txt")
	// if err != nil {
	// 	panic(err)
	// }
	// defer f.Close()
	// bytes := make([]byte, 1024)
	// f.Read(bytes)
	// println(len(bytes))

	// panic
	openFile("Invalid.txt")
	println("Done!!!")
}

func openFile(fn string) {
	// defer에 의한 recover 처리
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Open Error", r)
		}
	}()

	f, err := os.Open(fn)
	if err != nil {
		println("Panic Herer!!!")
		panic(err)
	}

	defer f.Close()
}

Goroutine / Channel #

gorutine / channel ...

package main

import (
	"fmt"
	"runtime"
	"sync"
	"time"
)

func say(s string) {
	for i := 0; i < 3; i++ {
		fmt.Println(s, "***", i)
		time.Sleep(time.Second * 1)
	}
}

func say2(s string) {
	for i := 0; i <= 1000000; i++ {
		fmt.Println(s, "***", i)
	}
}

func main() {
	// goroutine
	say("Sync")
	go say("Async1")
	go say("Async2")
	go say("Async3")
	time.Sleep(time.Second * 3)

	// anonymous goroutine
	var wait sync.WaitGroup
	wait.Add(2)
	go func() {
		defer wait.Done()
		fmt.Println("Hello")
	}()
	go func(msg string) {
		defer wait.Done()
		fmt.Println(msg)
	}("Hi")
	wait.Wait()

	// Concurrency vs Parallelism
	runtime.GOMAXPROCS(3)
	go say2("Async1")
	go say2("Async2")
	go say2("Async3")
	time.Sleep(time.Second * 12)

	// channel
	ch := make(chan int)

	go func() {
		ch <- 123
	}()

	var i int
	i = <-ch
	println(i)

	// channel 2
	done := make(chan bool)
	go func() {
		for i := 0; i < 1000; i++ {
			fmt.Println(i)
		}
		done <- true
	}()

	<-done

	// channel deadlock
	// c := make(chan int)
	// c <- 1
	// fmt.Println(<-c)

	// buffer channel
	ch = make(chan int, 1)
	ch <- 101
	fmt.Println(<-ch)

	// channel sending/receiving
	chstr := make(chan string, 1)
	sendChnn(chstr)
	receiveChnn(chstr)

	// channel close
	ch = make(chan int, 3)
	ch <- 1
	ch <- 2
	ch <- 3
	close(ch)
	println(<-ch)
	println(<-ch)
	if _, success := <-ch; !success {
		println("no data")
	}

	// channel receiving 1
	ch = make(chan int, 5)
	ch <- 1
	ch <- 2
	ch <- 3
	ch <- 3
	ch <- 2
	close(ch)
	for i := range ch {
		println(i)
	}

	// channel receiving 2
	ch = make(chan int, 5)
	ch <- 1
	ch <- 2
	ch <- 3
	ch <- 1
	ch <- 4
	close(ch)
	for {
		if i, success := <-ch; success {
			println(i)
		} else {
			break
		}
	}

	// channel select
	done1 := make(chan bool)
	done2 := make(chan bool)

	go run1(done1)
	go run2(done2)

EXIT:
	for {
		select {
		case <-done1:
			println("run1 finished")
		case <-done2:
			println("run2 finished")
			break EXIT
		}
	}
}

func run1(done chan bool) {
	time.Sleep(1 * time.Second)
	done <- true
}

func run2(done chan bool) {
	time.Sleep(2 * time.Second)
	done <- true
}

func sendChnn(ch chan<- string) {
	ch <- "Data"
}

func receiveChnn(ch <-chan string) {
	data := <-ch
	fmt.Println(data)
}

Source : github-go_basic