블록체인하는 만두아빠

Go Lang의 구조체(Struct)는 필드를 하나의 개념으로 묶는 것을 의미합니다.

Go Lang에는 타 언어에서 사용하는 Class와 상속을 지원하지 않습니다. 대신 메소드를 구조체에 연결하는 방식을 통해 Class의 형태를 구현합니다. 이 경우 메소드는 구조체안에서 정의되는 것이 아니라 구조체 밖에서 정의되어 사용합니다.

우선 메소드에 대해 알아보고 구조체를 공부해봅시다.

Go Lang은 객체지향 언어가 아니기 때문에 메소드가 존재합니다.
Go Lang의 메소드란 특정한 구조체에 연결되어 호출되는 함수를 의미합니다. 데이터와 코드를 묶어서 응집도를 높이기 위해 사용하는데, 응집도를 높여서 쓰는 것이 유리한 곳에 활용하기에 좋습니다. (통장 입출금 예제 등)

메소드의 형태

func (구조체변수 구조체이름) 메소드명() 리턴값 {
	구조체 멤버를 접근하여 연산수행 가능
}

통장 입출금 예제를 사용해서 메소드에 대해 더 자세히 알아보도록 하겠습니다.

예제. 통장 인출 메소드 만들기

package main

import "fmt"

type Account struct {
	balance int
}

// 인출 메소드
func (a *Account) withdrawMethod(amount int) {
	a.balance -= amount
}

func main() {
	a := Account{100}
	b := &Account{200}
	// 인출 메소드 사용
	a.withdrawMethod(40)
	b.withdrawMethod(50)

	fmt.Printf("a계좌 : %d, b계좌 : %d", a.balance, b.balance)
}

출력결과물

a계좌 : 60, b계좌 : 150

출금메소드를 생성해서 a와 b 계좌에서 차감하는 예제를 간단히 만들 수 있습니다.

구조체의 형태

struct {
	field1 string
	field2 int
}

구조체 내부는 각각의 필드명과 필드 타입으로 구성됩니다.

예제. 구조체 만들기

package main

import "fmt"

type hero struct {
	name string
	age int
	weapon string
}

var h hero

func main()  {
	h := hero{}
	h.name = "유비"
	h.age = 30
	h.weapon = "자웅일대검"
	fmt.Println(h)
}

출력결과물

{유비 30 자웅일대검}

위의 예제는 person 구조체를 선언하고 그 구조체에 name과 age를 각각 타입 선언하였습니다. person 구조체 하에 변수 p 선언하고 이를 통해 name과 age의 필드값을 설정한 결과값을 출력하였습니다.

구조체 선언 후에 별도 함수를 생성해서 연결하는 것이 가능하고 매우 쉽고 간편합니다.

예제. 함수 연결하기

package main

import "fmt"

type hero struct {
	name string
	age int
	weapon string
}

var h hero

func main()  {
	h := hero{}
	h.name = "유비"
	h.age = 30
	h.weapon = "자웅일대검"
	fmt.Println(h)
	hero01()
    hero02()
}

func hero01()  {
	h.name = "관우"
	h.age = 31
	h.weapon = "청룡언월도"
	fmt.Println(h)
}

func hero02()  {
	h.name = "장비"
	h.age = 28
	h.weapon = "장팔사모"
	fmt.Println(h)
}

출력결과물

{유비 30 자웅일대검}
{관우 31 청룡언월도}
{장비 28 장팔사모}

위에서 보듯 구조체는 크기가 큰 경우도 많습니다. 이런 경우에도 함수는 전달된 인자의 복사본을 사용합니다. 필드가 많은 구조체의 경우 포인터를 통해 인자를 전달하는 것이 메모리 관리에 도움이 됩니다.

포인터 변수를 직접 출력하면 변수가 가리키는 메모리의 주소 값이 나옵니다. 포인터가 나타내는 주소값이 아닌 포인터의 값을 가져오려면 *를 사용합니다.

var i int = 12
var p *int = &i
var q *int = p
fmt.Printf("i의 주소 : %p\n", &i)
fmt.Printf("p의 주소 : %p, p의 값 : %p\n", &p, p)
fmt.Printf("q의 주소 : %p, q의 값 : %p\n", &q, q)

출력결과물

i의 주소 : 0xc0000140b0
p의 주소 : 0xc00000e028, p의 값 : 0xc0000140b0
q의 주소 : 0xc00000e030, q의 값 : 0xc0000140b0

i의 주소값이 p의 값이 되었음을 확인 가능합니다. p와 q 모두 값 자체는 동일하지만 각 포인터가 가리키는 주소값은 다름을 확인할 수 있습니다.

**이중 포인터를 활용해서 주소를 따라가라는 명령을 줄 수 있습니다.

var i int = 12
var p *int = &i
var q **int = &p
fmt.Printf("i의 주소 : %p\n", &i)
fmt.Printf("p의 주소 : %p, p의 값 : %p\n", &p, p)
fmt.Printf("q의 주소 : %p, q의 값 : %p\n", &q, q)

출력결과물

i의 주소 : 0xc0000140b0
p의 주소 : 0xc00000e028, p의 값 : 0xc0000140b0
q의 주소 : 0xc00000e030, q의 값 : 0xc00000e028

포인터를 너무 자주 사용하기보다는 규모가 큰 구조체나 변경이 필요한 구조체의 경우에 용이하게 사용하고, 슬라이스 맵 함수 등에는 내부적으로 포인터가 구현이 되어있으므로 굳이 쓰지 않아도 무방할 것입니다.

Go Lang의 맵(map)은 잘 정리되어 있는 서류 문서함과 같습니다.

Go Lang의 맵은 저장된 값을 키(key)를 통해 접근할 수 있는 자료구조로, 키를 사용해 맵의 데이터를 편리하게 가져 올 수 있습니다.

맵(Map)에서의 선언 역시, 배열과 슬라이스와 유사한 형태를 가집니다.

var 맵이름 map[키type]값type   // 맵 변수의 선언
make(map[키type]값type       // 맵의 실제값 생성

예제. make함수를 활용한 맵 만들기

package main

import "fmt"

func main() {
	Greeting := make(map[string]string)
	Greeting["English"] = "Good morning!"
	Greeting["Français"] = "Bonjour!"
    
	fmt.Println(Greeting)
}

출력결과물

map[English:Good morning! Français:Bonjour!]

위의 예제를 통해 맵에 string타입 지정후, 영어 인사와 프랑스어 인사를 작성해보았습니다.

Go lang에서는 맵의 데이터를 간편하게 저장하고 조회할 수 있습니다.

예제. 맵의 데이터 저장 및 조회하기

package main

import "fmt"

func main() {
	var iMap map[int]int
   	iMap = make(map[int]int)
   	iMap[0] = 3
   	iMap[5] = 9
   	val, suc := iMap[3]
   	fmt.Println(iMap[0], iMap[5], iMap[3])
   	fmt.Println(val, suc)
}

출력결과물

3 9 0
0 false

위의 예제는 iMap에 0이 들어가면 3이 나오고, 5가 들어가면 9가 나오도록 구조를 만든 것 입니다.
맵의 데이터를 조회할 때는 리턴 값에서 두번째 자리(예제에서는 suc)에 키의 존재 여부를 확인하도록 저장되며 iMap에는 값이 없기 때문에 false가 뜨는 것을 확인할 수 있습니다.

이번에는 delete를 활용해서 예제 8에서 사용했던 인사 맵에 저장된 데이터를 삭제해보도록 합시다.

예제. 맵의 데이터 삭제하기

package main

import "fmt"

func main() {
	Greeting := make(map[string]string)
	Greeting["English"] = "Good morning!"
	Greeting["Français"] = "Bonjour!"

	delete(Greeting, "English")

	fmt.Println(Greeting)
}

출력결과물

map[Français:Bonjour!]

Go Lang의 슬라이스(Slice)는 값을 추가하여 확장가능한 자료구조로 크기가 고정되어 있지 않고 동적으로 배열의 크기를 증가시킬 수 있습니다.
슬라이스는 Go Lang 내장 함수인 make를 통해 공간을 확보할 수 있습니다.
make 함수는 (타입type, 길이length, 용량capacity)를 선언하여 사용합니다. 여기서 용량은 내부배열의 최대길이를 의미합니다.

슬라이스 선언은 배열(Array)과 거의 비슷합니다. 다만, []안에 길이 지정을 하지 않습니다.

var 변수명 [] 데이터타입

예제. 슬라이스 선언하고 길이와 용량 확인하기

package main

import "fmt"

func main() {
	s :=  []int{0, 1, 2, 3, 4, 5}
	l := len(s)
	fmt.Println(l, cap(s), s)
}

출력결과물

6 6 [0 1 2 3 4 5]

cap()은 배열의 기본 용량을 알려주고, len()은 배열에 몇 개의 항목이 있는지를 알려주는 함수입니다.
len(s)와 cap(s) 를 통해 슬라이스의 길이와 용량를 확인 할 수 있습니다.

make 함수를 사용해 슬라이스를 조금 더 자세히 다뤄보도록 합시다.

s := make([]int, 3, 3)

s는 정수형 타입에 길이가 3이고 용량 3인 슬라이스입니다.
슬라이스로 부터

s[0] = 1
s[1] = 2
s[2] = 3
fmt.Println(s[1])

각 원소자리에 값을 하나씩 지정해주고 출력을 해봅니다.

출력결과물

2

슬라이싱(Slicing)은 슬라이스의 특정 영역을 추출하는 기능입니다.

예제. 슬라이싱 해보기

package main

import "fmt"

func main() {
	s := make([]int, 3, 3)
	s[0] = 1
	s[1] = 2
	s[2] = 3
	t := s[0:3]
	u := s[:3]
	v := s[1:]
	fmt.Printf("t = %d, u = %d, v = %d", t, u, v)
}

출력결과물

t = [1 2 3], u = [1 2 3], v = [2 3]

슬라이싱의 경우 u는 0번 index부터 3번 index 바로 전까지, v는 2번째 index부터 마지막 index까지 슬라이싱 가능합니다.

예제. 슬라이스의 크기 자동조절 기능 확인하기

package main

import "fmt"

func main() {
	s := make([]int, 0, 3)
	for i := 0; i < 5; i++ {
		s = append(s, i)
		fmt.Printf("cap : %v, len : %v, add : %p\n", cap(s), len(s), s)
	}
}

출력결과물

cap : 3, len : 1, add : 0xc000016160
cap : 3, len : 2, add : 0xc000016160
cap : 3, len : 3, add : 0xc000016160
cap : 6, len : 4, add : 0xc000018120
cap : 6, len : 5, add : 0xc000018120

Go Lang의 슬라이스는 기본 배열의 크기를 자동으로 조절합니다.
append를 통해 추가한 값이 처음 설정된 용량을 넘어서면 더 큰 용량의 새 슬라이스를 반환합니다. 이 때 포인터 주소도 새로운 주소로 변경됩니다.

다른 여러 프로그래밍 언어들과 마찬가지로 Go Lang도 많은 데이터를 다루어야할 경우 사용할 수 있는 자료구조를 제공하고 있습니다.

그 대표적인 것들이 바로 배열(Array), 슬라이스(Slice), 맵(Map)입니다.

이번 시간에는 배열(Array)에 대해 알아보도록 하겠습니다.

Go Lang의 배열은 길이가 고정된 동일한 타입을 갖는 값을 순서대로 저장하는 자료구조입니다.

• Go Lang의 배열에서 인덱스는 0부터 시작합니다.
• 배열이 가지고 있는 각 값을 원소라고 하며 Go Lang의 정수형(int)과 문자열(string), 부동 소수점(float) 등 모든 타입에 대한 배열을 만들 수 있습니다.
• 배열 선언은 대괄호[]를 통해 합니다.

배열의 형태

var 변수명 [배열크기] 데이터타입​

예제. 배열 만들기

package main

import "fmt"

func main() {
	var singleArray [3]int = [3]int {1, 2, 3}
	fmt.Println(singleArray)
}

출력결과물

[1 2 3]

위의 예제 6은 singleArray를 정수형의 3가지 원소를 가진 배열임을 선언하였고, 선언과 동시에 그 3가지 원소값을 1,2,3으로 초기값을 지정해준 예제입니다. 이처럼 배열의 초기값을 지정해주는 것을 배열 초기화라고 합니다.
대괄호[]안에 ...을 사용해 배열크기를 자동으로 지정해줄 수 있습니다.

아래의 식들은 결과적으로 동일한 의미를 나타냅니다.

var singleArray [3]int = [3]int {1, 2, 3}
var singleArray = [3]int {1, 2, 3}
var singleArray = [...]int {1, 2, 3}

singleArray 선언시에 반드시 타입을 지정해주지 않아도 되는 이유는 Go Lang이
R Value를 통해 L Value의 타입을 알 수 있는 언어이기 때문입니다.

다만,

var singleArray [3]int

까지만 지정해서 index 값을 지정해주지 않으면, 출력결과물은 [ 0 0 0 ] 이 됩니다.

예제. 다중 배열 만들기

package main

import "fmt"

func main() {
	var multiArray = [2][3][4]int{
		{{1, 2, 3},
			{1, 2, 3},
			{1, 2, 3}},
		{{1, 2, 3},
			{1, 2, 3},
			{1, 2, 3}},
	}
	fmt.Println(multiArray)
}

출력결과물

[[[1 2 3 4] [1 2 3 4] [1 2 3 4]] [[1 2 3 4] [1 2 3 4] [1 2 3 4]]]

위의 예제는 1,2,3,4의 [4]배열이 [3]개 있고, 그 [3]배열이 다시 [2]개 더 있는 형태입니다.

예제. 배열 초기화

package main

import "fmt"

func main() {
	var iArray = [10]int {
		5: 10, 9: 23,
	}
	fmt.Println(iArray)
}

출력결과물

[0 0 0 0 0 10 0 0 0 23]

배열의 index는 0부터 시작되기 때문에 5번째 index에 10이라는 정수값을 초기화해주려면 4: 10을 입력해야합니다. 위의 예제에서는 5: 10, 9: 23으로 초기화했으므로 10개의 원소 중 6번째와 10번째 값에 각각 10과 23이라는 값이 지정되었음을 확인할 수 있습니다.

지금까지는 함수에 대한 특별한 안내가 없었지만 Go Lang에서 미리 정의된 함수를 충분히 잘 활용해왔습니다.

지금부터는 함수를 조금 더 상세히 알아봄으로써 Go Lang에 미리 정의된 함수 외에도 직접 함수를 정의하고 활용해보도록 합시다.

Go Lang에서 함수는 func를 통해 나타냅니다.
Go Lang에서 함수 func에는 { 이 반드시 같은 줄에서 시작되어야합니다.

함수의 기본 형태

func 함수명 (매개변수 type)​

처음 우리가 func을 만난 것은 func main() {} 의 형태였습니다. 기본 형태를 알았으니 이제 우리는 func main()이 main함수를 의미하는 것임을 알 수 있습니다.

함수에 인자를 전달하기 위해서는 하나 이상의 매개변수(Parameter)를 선언해주어야 합니다. 둘 이상의 매개변수는 ,를 통해 구분해줍니다.

func add (var a int, var b int) {
}

위와 같은 함수가 있다고 해봅시다. add라는 함수명을 가진 함수 안의 a와 b는 각각 정수형(int)으로 선언된 매개변수입니다.
func 함수 안에 다음과 같이 선언된 변수는 지역(local)에 종속된 지역변수입니다. 따라서 a와 b는 함수 사용 지역 외에서의 사용은 되지 않습니다.

먼저 swap이라는 이름의 함수를 만들어봅시다.

func swap(a int, b int) {
	temp := a
	a = b
	b = temp
	fmt.Printf("a = %d, b = %d\n", a, b)
}

func 뒤에 swap으로 함수 이름을 작성하고 매개변수 a와 b를 각각 정수형(int) 선언합니다. a와 b의 위치를 바꾸기 위해 temp 변수를 정의하여 a와 b의 값을 서로 넘겨주는 함수 형식을 제작합니다. fmt.Printf 함수를 통해 a와 b 값을 한 눈에 알아볼 수 있게 출력합니다.

 데이터타입 %d?

정수값(int)를 부호가 있는 10진수의 형태로 출력​

swap함수를 정의했으니 이제 swap함수가 제대로 작동할 수 있게 main함수를 작성합니다.

package main

import "fmt"

func main() {
	a := 1
	b := 2
	swap(a, b)
}

func main함수 안에 a와 b를 각각 정수형 1, 2 변수로 선언하고 swap 함수의 매개변수로 지정하였습니다. main함수는 swap함수를 실행시켜 줄 것입니다.

예제. swap 함수 만들기

package main

import "fmt"

func main() {
	a := 1
	b := 2
	swap(a, b)
}

func swap(a int, b int) {
	temp := a
	a = b
	b = temp
	fmt.Printf("a = %d, b = %d", a, b)
}

출력결과물

a = 2, b = 1​

위의 예제를 통해 우리가 만든 swap함수가 잘 실행되어 a와 b의 값이 서로 swap되었음을 확인합니다.

지금은 조금 생소하지만 곧 알아보게될 포인터라는 개념을 통해서 해당 식을 조금 더 상세히 분석해볼 수 있습니다.

예제. 포인터를 활용해 swap 함수 사용하기

package main

import "fmt"

func main() {
	a := 1
	b := 2
	fmt.Printf("a = %d, b = %d \n", a, b)
	fmt.Println("호출 후")
	swap(&a, &b)
}

func swap(i *int, j *int) {
	temp := *i
	*i = *j
	*j = temp
	fmt.Printf("a = %d, b = %d \n", *i, *j)
}

&a는 a := 1에서, a의 값(1)을 저장한 주소값을 나타냅니다.
&b는 b := 2에서, b의 값(2)을 저장한 주소값을 나타냅니다.
여기서 포인터 을 사용하여 i, *j로 주소를 찾아 해당 주소값에 저장된 값을 저장합니다.
정수값 a, 정수값 b, 주소값 j, 주소값 i가 차례대로 메모리 스택의 아래에부터 쌓이며 그 가장 위에 temp 변수가 저장됩니다.

위의 예제의 변수들이 메모리에 저장된 순서  (Last in First Out 방식)

temp 변수
*i (주소값)
*j (주소값)
b (정수값)
a (정수값)​

함수 실행 시 i가 먼저 주소를 찾아가서 b 자리에 있는 정수값 2를 정수값 1로 대체하고, j가 a 자리의 정수값 1을 2로 대체하여 swap이 완성됩니다. swap함수의 지역변수인 temp는 이 과정이 끝나면 사라집니다.

swap함수의 실행결과가 main함수에 반영되면서 최종 결과물을 출력합니다.

출력결과물

a = 1, b = 2 
호출 후
a = 2, b = 1

이번에는 if문을 활용한 Divide 함수를 만들어보도록 합시다.

func main() {
	mok, suc := divide(4, 2)
	fmt.Println(mok, suc)
}

몫은 mok, 나눗셈 성공 여부를 suc로 확인할 수 있도록 작성합니다.
이제 divide 함수를 통해서 divide(4, 2)라는 함수에 의미를 부여해줍니다.

func divide(a int, b int) (int, bool) {

함수 divide는 정수형 a와 b를 매개변수로 하는 함수입니다. 각각 결과값이 int, bool형으로 나타날 수 있게 함수와 { 사이에 타입을 지정해줍니다.
나눗셈에서 0으로 나누는 식은 허용되지 않기 때문에 b값에 0이 오면 오류 메시지를 반환할 수 있도록 if문을 활용합니다.

	if b == 0 {
		return 0, false
	}

	return a / b, true
}

b == 0이 아니면 if문은 a / b를 리턴하도록 합니다. 이제 이 소스 코드들을 조립해서 하나의 완성된 코드를 실행시켜봅시다.

예제. divide 함수 만들기

package main

import "fmt"

func main() {
	mok, suc := divide(4, 2)
	fmt.Println(mok, suc)
}

func divide(a int, b int) (int, bool) {
	if b == 0 {
		return 0, false
	}

	return a / b, true
}

출력결과물

2 true

divde(4, 0)과 같이 0으로 나눌 경우 0 false를 반환

Go Lang에서 반복문은 For문 하나 만을  사용합니다.

Go Lang의 for 반복문은 기본적으로 for 초기값; 조건식; 증감식 {} 의 형태를 가집니다.
괄호()는 사용하지 않으며, 사용시 오류 메시지를 반환합니다.

아래의 예제들을 통해 for문에 대해 상세히 알아보도록 하겠습니다.

예제. For문

package main

import "fmt" 

func main() {
    sum := 0
    for a := 1; a <= 10; a++ {
        sum += a
    }
    fmt.Println(sum)
}

출력결과값

55​

위의 예제는 sum을 먼저 0으로 선언하고 a 변수에 for문을 통한 반복으로 10까지 증감한 값을 sum에 더하면서 대입한 결과를 출력하는 형태입니다.

즉, a가 1부터 시작해서 증감식 a++을 통해 1씩 늘어나는 반복식을 sum에 계속 합산하도록 구성하여 1+2+3+...+10을 구현해놓은 것입니다.

Go Lang에서 for문을 사용한 무한루프를 사용하는 방법은 매우 간단합니다.

예제. For문 무한루프

package main

import "fmt"

func main() {
	for {
    	fmt.Println("무한루프 진행중")
    }
}

* 주의 : 가급적 실행은 시키지 마세요! 

for 외의 아무것도 입력하지 않으면 무한 루프가 되며, 무한 루프에서 탈출하는 방법은 CTRL + C 입력을 통해 가능합니다.

for문과 함께 사용할 수 있는 range문에 대해서도 알아보겠습니다.

range문은 이후에 더 상세히 알아볼 배열(Array), 슬라이스(Slice), 맵(Map)과 같은 컬렉션에서 하나씩의 요소들을 가져와 for문을 실행하도록 합니다.

range는 두 개의 값을 반환하는데 첫번째는 key(index)값이고, 두번째는 value입니다.

for ~ range문의 형태

for index, value := range​

예제. for ~ range문

package main

import "fmt"

func main() {
	numbers := []int{1, 2, 3}
		for _, num := range numbers {
		fmt.Println(num)
	}
}

출력결과값

1
2
3​

위의 예제에서 for 뒤의 _ 는 for ~ range의 반환값인 index와 value 중 index 값을 직접 입력하지 않고 함수를 실행시키기 위해 사용합니다.

다음으로는 for문에서의 break, continue, goto문에 대해 알아보도록 합시다.

for문의 반복을 바로 중단하기 위해서는 break를 사용합니다. 또, for의 반복 루프 도중에 뒤의 문장을 실행하지 않고 for문의 시작지점으로 가기 위해서는 continue를 사용합니다. goto는 다음 지정하는 값의 위치로 이동할 수 있게 해주는 역할을 합니다.

예제. for ~ continue, break문

package main

import "fmt"

func main() {
	for a := 0; a < 10; a++ {
		if a == 3 { 
			continue  // a == 3이 되면 continue로 다시 for문의 시작점으로
		}
		fmt.Println(a)
		if a == 4 {
			break    // a == 4가 되면 break로 for 루프를 탈출
		}
	}
}

출력결과물

0
1
2
4​

위의 예제에서 볼 수 있듯이 continue는 if 조건식을 만족할 시 해당 if문을 실행하지 않고 for문의 시작점으로 이동시켜주어 3은 출력되지 않았습니다.

이번에는 goto를 활용한 예제를 살펴보도록 하겠습니다.

예제. for ~ goto문

package main

import "fmt"

func main() {
	a := 0
	for ; a < 10; a++ {
		if a == 3 {
			continue
		}
		fmt.Println(a)
		if a == 7 {
			break
		}

		if a == 4 {
			goto L1 // a == 4가 되면 L1으로 점프
		}
	}
	fmt.Println("a의 값은 :", a)
L1:
	fmt.Println("goto문으로 도달")
}

출력결과물

0
1
2
4
goto문으로 도달​

위의 예제에서는 a == 4에 도달한 시점에서 goto를 통해 L1의 Println을 실행하고 종료되었습니다.

break 레이블에 대해서도 추가로 알아보도록 합시다. 일반적으로는 break만을 사용해 for 반복루프를 빠져나오는 식을 구현할 수도 있지만, break 레이블을 통해 for 루프를 빠져나와 지정된 레이블로 이동하고 break가 속한 for 반복문 전체의 다음 문장을 실행하도록 할 수 있습니다.

예제. for문 break레이블

package main

import "fmt"

func main() {
	i := 0
L1:      
	for {
		for {
			if i == 0 {
				break L1    // 위의 L1으로 이동하는 레이블을 작성
			}
		}
	}
	fmt.Println("무사히 탈출!")
}

출력결과물

무사히 탈출!​

위의 예제는 for 반복문에 의해 무한루프에 갇힐 것 같은 예제이지만 실제 출력을 보면 그렇지 않습니다.

break 후 L1으로 이동한 해당 문장에서는 break가 포함되어있는 for 반복문을 건너뛴 후 Println을 무사히 출력시키고 종료되었습니다.

Go Lang의 switch문은 여러 분기에 걸친 조건문들을 표현합니다.

switch문을 사용하면 일일이 if를 통해 나열하는 것보다 훨씬 간편하게 조건문을 만들 수 있습니다.

switch문은 switch와 case를 통해 순차적으로 조건을 판단합니다.

switch문은 정수형뿐만 아니라 문자열 형태도 사용이 가능합니다.

package main

import "fmt"

func main() { 
	a := 3 
	fmt.Print("a 값 : ") 
	switch a { 
	case 1: 
		fmt.Println("1 입니다") 
	case 2: 
		fmt.Println("2 입니다") 
	case 3: 
		fmt.Println("3 입니다") 
	} 
}

출력결과값

a 값 : 3 입니다​

위의 예제는 a를 3으로 선언한 후, switch문과 case를 통해 a값이 1, 2, 3의 각각 case에 해당하는지 순서대로 체크합니다.
결과적으로 해당 switch문은 true값에 해당하는 case 3의 함수를 출력하게 됩니다.

switch문은 if문에서 마지막 else와 같이 해당 조건문을 빠져나오는 방법으로 default를 사용합니다.

switch문 분기의 마지막에, 이전 모든 case에 해당하지 않을 경우 default 함수를 실행합니다.

위의 예제처럼 모든 조건문을 나타내기 위해 일일이 case를 나누지 않고 동일한 case의 경우 ','를 통해 구분하여 사용할 수 있습니다.

switch문을 통해 세 가지 경우를 한 번에 확인할 수 있는 예제 또한 쉽게 만들어 볼 수 있습니다.

package main

import "fmt"

func main() {
	a := 3
	b := 5
	c := 6

	fmt.Print("a 값 : ")
	switch a {
	case 1:
		fmt.Println("1 입니다")
	case 2:
		fmt.Println("2 입니다")
	case 3:
		fmt.Println("3 입니다")
	}

	fmt.Print("b 값 : ")
	switch b {
	case 1:
		fmt.Println("1 입니다")
	case 2:
		fmt.Println("2 입니다")
	case 3, 4, 5:
		fmt.Println("3 또는 4 또는 5입니다")
	}

	fmt.Print("c 값 : ")
	switch c {
	case 1:
		fmt.Println("1 입니다")
	case 2:
		fmt.Println("2 입니다")
	case 3, 4, 5:
		fmt.Println("3 또는 4 또는 5입니다")
	default:
		fmt.Println("6 이상입니다")
	}
}

출력결과값

a 값 : 3 입니다
b 값 : 3 또는 4 또는 5입니다
c 값 : 6 이상입니다​

Go Lang의 조건문은 특정 조건을 만족하는 경우에만 실행되는 코드 블록을 말합니다.

 코드블록(Code Block)
{ }로 감싼 하나 이상의 명령문으로 이루어진 영역

Go Lang은 다른 대부분의 언어와 마차가지로 여러 개의 분기 조건을 만들 수 있습니다.
조건문에서는 코드블록의 실행 여부를 결정할 때 Bool 표현식(true or False)을 사용합니다. 
예제를 통해 살펴보도록 하겠습니다.

예제. If문

package main

import "fmt"

func main() {
	var a int  = 2
	if a == 1 {
		fmt.Println("a는 1입니다")
	} else if a >= 2 {
		fmt.Println("a는 2보다 크거나 같습니다")
	} else {
		fmt.Println("a는 1도 아니고, 2보다 크거나 같지도 않습니다")
	}
}

if문은 if를 사용해서 현재 조건식이 참인지 거짓인지를 확인하고 그 결과를 토대로 다음의 함수를 실행시킬 수 있도록 도와줍니다. 

• if문은 if 조건문 {}의 형태로 사용합니다.
• if문은 조건식을 여러개 만들고 싶을 때 else를 사용하여 조건식을 이어나갈 수 있습니다.
• 더이상 추가할 조건식이 없을 때는 위에 나열된 조건식이 아닐 경우 else로 조건식을 마무리합니다.
• 반드시 else를 사용해야하는 것은 아니고 if문만을 사용하더라도 문제없이 사용할 수 있습니다.

위의 예제에서는 a가 2라고 선언했으므로 두번째 if식인 a >= 2가 true가 되어 해당 코드블록의 Print를 실행합니다

출력 결과물

a는 2보다 크거나 같습니다​

if문을 사용해서 성적을 입력하면 등급이 나오도록 예문을 작성해봅시다.

예제. If, else문

package main

import "fmt"

func main() {
	var score = 0
	fmt.Scan(&score)

	if score >= 90 {
		fmt.Println("A등급")
	} else if score >= 80 {
		fmt.Println("B등급")
	} else if score >= 70 {
		fmt.Println("C등급")
	} else if score >= 60 {
		fmt.Println("D등급")
	} else {
		fmt.Println("F등급")
	}
}

출력결과물

(직접 입력하는 값에 따라 A ~ F등급이 나옵니다)​

Go Lang에서 사용되는 연산자에 대해 알아보도록 합시다.

Go Lang의 연산자는 다른 대부분의 언어들과 유사합니다.

Go Lang 산술 연산자

기본 사칙연산자와 증감연산자의 표현 방법입니다

a + b   (덧셈)
a - b   (뺄셈)
a * b   (곱셈)
a / b   (나눗셈)
a % b   (나머지)
a++     (증가)
a--     (감소)

Go Lang 비교 연산자

비교의 결과값은 bool값으로 true 혹은 false가 됩니다

a == b   (같다)
a != b   (같지 않다)
a >= b   (a가 b보다 크거나 같다)
a <= b   (a가 b보다 작거나 같다)

Go Lang 논리 연산자

AND, OR, NOT 표현에 사용됩니다

a && b   (AND, 두 값이 모두 true인지 확인)
a || b   (OR, 두 값 중 어느 하나라도 true인지 확인)
!a       (true면 false, false면 true를 출력)

Go Lang 할당 연산자

- 할당 연산자는 연산 후 대입까지 하는 기능을 가진 연산자를 말합니다

a := 2    (a에 2를 대입)   
a += 3    (a에 3을 더한 후 대입)
a -= 4    (a에 4를 뺀 후 대입)
a *= 5    (a에 5를 곱한 후 대입)
a /= 6    (a에 6을 나눈 후 대입)

Go Lang에서 변수(variable)란 입력된 값을 가진 저장공간을 의미합니다.

Go Lang에서는 변수 선언을 통해 변수명을 부여할 수 있습니다.

Go Lang에서 변수 선언은 'var'를 통해서 이루어집니다.

var a int

위의 예제에서 a는 변수명, int는 변수의 타입을 의미합니다.

Go Lang에서 사용되는 변수 타입들에 대해 우선 알아볼 필요가 있습니다.

1. 문자열(string)

문자열은 텍스트 문자를 나타냅니다. 코드 내에서 문자열을 직접 정의하고 사용할 수 있습니다.

"Hello World"와 같이 주로 ""를 사용해서 문자열을 표현합니다

2. 정수(integer)

정수형 문자열은 숫자를 나타냅니다. int로 나타내는 정수형 타입에서는 3.14와 같은 부동 소수점 숫자를 사용할 수 없어 별도로 정의합니다.

var a int 의 형식으로 나타내며 int8, int16, int32, int64 / uint8, uint16, uint32, uint64 등으로 사용합니다 (u는 음수 미포함)
int 처럼 뒤에 비트값을 따로 지정하지 않으면 해당 운영체제의 비트값을 따라갑니다. (64비트의 경우 int64)

3. 부동 소수점(float)

float로 부동 소수점 숫자 타입을 나타냅니다. 정수가 아닌, 소수부를 가진 숫자 값을 저장하며 주로 float32, 64을 사용하며 뒤의 숫자는 비트값을 의미합니다.

4. 참과 거짓(boolean)

어떠한 값의 참과 거짓을 가려내기 위한 타입을 나타냅니다. 주로 조건문에서 사용되며 이 경우 어떠한 조건이 참 혹은 거짓인 경우에만 특정한 코드를 실행할 수 있도록 합니다.

5. 룬(rune)

단일 문자를 나타냅니다. 룬은 해당 문자를 나타내는 유니코드 코드값을 사용하기 때문에 Println으로 출력하면 문자가 아닌 숫자 코드 형태로 출력됩니다.

Go Lang은 정적 타입 언어입니다. 프로그램 실행 전에 타입을 미리 알아내어 타입을 잘못된 위치에 사용하게 되면 오류 메시지를 반환합니다. 사용자가 미리 코드 내의 타입 문제를 체크할 수 있습니다.

타입 체크를 위해서 reflect 패키지의 TypeOf 함수를 사용할 수 있습니다.

package main

import (
          "fmt"
          "reflect"
)

func main() {
         fmt.Println(reflect.TypeOf("Hello World"))
         fmt.Println(reflect.TypeOf(23))
         fmt.Println(reflect.TypeOf(3.14))
         fmt.Println(reflect.TypeOf(true))
}

출력 결과값으로 다음과 같이 해당 입력값의 타입을 알 수 있습니다.

string
int
float64
bool

var를 통해 변수에 값을 할당하면 변수를 사용할 수 있습니다. 변수의 사용까지의 순서는 다음과 같이 진행됩니다.

var a int                변수 선언
a = 23                   변수값 할당
fmt.Println(a)           변수 사용

var를 통해 변수 선언하지 않고도 변수를 선언함과 동시에 값을 지정해줄 수 있습니다.

var a int = 23

일반적으로 Go Lang에서 변수의 선언과 동시에 값을 할당하는 경우 단축 변수 선언을 많이 사용합니다.

연산자 := 를 사용해서 타입을 선언하고 값을 할당하는 과정을 한 번에 수행할 수 있게 됩니다.

a := 23