
# Why Golang ?

갑자기 Go 언어를 배워보고자 하는 욕구가 뿜뿜하였다.
Go 에 대해서 여러 아티클이나 영상을 접하다 보니 가장 큰 장점을 속도가 겁나 빠르다 인데, 이 매력에 이끌리게 되어서, 좀 더 찾아보고 내가 배워야 할 이유가 충분하더라.

1. 빠르다  
 Go Lang 의 장점을 찾아보면 가장 먼저 Python 과 비교를 하는 아티클을 많이 보게 되는데 속도가 너무 차이가 난다는 것이다. 믿을 수 없을 정도로 빠르다고, 유튜브를 조금만 봐도 나오는 수준… 그리고 컴파일 언어라고 한다.

2. 정적 언어  
 Type 강제하는가 너무 좋아

3. Python 과 C 를 쏙쏙  
 Python 과 C 의 좋은 점들을 뽑아 디자인 됐다 한다, 그래서 포인터도 있고, C 처럼 자료구조를 만들기도 쉽다더라!

4. 동시성 지원  

5. Garbage Collection 지원  
 가비지 컬렉션을 지원해주기 때문에 메모리 할당과 해제에 대해서 신경쓰지 않아도 된다.

6. Static linking 기본 지원  
 기본적으로 static linking 이 지원되기 때문에 binary file 을 생성할수 있고, 이식성이 좋다. 빌드가 성공하고 파일이 생성만 되면 의존성 및 라이브러리 버전등 신경쓰지 않고 사용할 수 있게된다!

7. 갓-글  

물론 단점들도 있고, 익히 듣기도 했지만, 단점이 없는 게 어디 있으랴, 일단 많이 배워보자!

갑자기 Go 언어를 배워보고자 하는 욕구가 뿜뿜하였다. 

Go 에 대해서 여러 아티클이나 영상을 접하다 보니 가장 큰 장점을 속도가 겁나 빠르다 인데, 이 매력에 이끌리게 되어서, 좀 더 찾아보고 내가 배워야 할 이유가 충분하더라.

Why GOLANG ?


Go 에서 변수를 생성/할당하는데는 익히 알고 있듯 2가지 방법이 있다.

**:=** 와 **=** 를 활용하는 것인데, 검색하면 쉽게 나오는 두 방식의 차이에 대해서 먼저 간단하게 설명해보면 아래와 같다.

### 1. =

```
var a int = 5
```

**var** 키워드로 변수임을 알려주고, 변수명을 작성하고, 타입을 작성한 뒤, 선택에 따라서 값을 할당해주면 된다.

### 2. :=

```
a := 5
```

1번의 예제와 동일한 효과를 짧게 내는 구문이다. **:=** 의 공식 명칭은 **short assignment stament** 이다.

그런데, 2번에는 원래 재할당이 되지 않는다.

재할당을 하는 경우에는 아래와 같은 에러를 보게 될 것이다.

![IMG](https://github.com/shinYeongHyeon/dev-blog/assets/74130738/d0c82837-cee0-4677-a95e-ada542aad839)

**:=** 의 왼쪽이 새 변수가 아니라는 뜻이다.

이 말인즉슨, 이미 선언된 변수에는 사용이 불가하다는 것인데, 2개, 3개 이상을 하는 경우에는 재 할당이 가능하다는 특이점이 있다.

```
package main

import "fmt"

func main() {
    a := 2
    b := 3

    a, b, c := 12, 13, 14
    fmt.Println(a, b, c)
}
```

위 코드의 결과는, **12 13 14** 이 출력이 되며 프로그램이 종료된다.


Go 에서 변수를 생성/할당하는데는 익히 알고 있듯 2가지 방법이 있다.

GoLang 변수 할당/생성 := and =


Golang 에서 서비스/어플리케이션 실행시에 Argument 들을 받는 방법에 대해서 알아보도록 하자

서비스를 실행시키는 대표적인 두 방법 Build 와 Run 각각 알아보도록 하려고 한다.

## 1\. Run

```
// stdOut.go
package main

import (
    "fmt"
    "os"
)

func main() {
    myString := ""
    arguments := os.Args
    if len(arguments) == 1 {
        myString = "Please give me one argument !"
    } else {
        myString = arguments[1]
    }

    //fmt.Println(arguments)
    fmt.Println(myString)
}
```

위 파일을 `go run stdOut.go` 로 실행하면 `Please give me one argument !` 로 출력이 된다.  
Args 를 넘기려면 실행문 뒤에 스트링을 붙이면 되는데 예를 들어 `go run stdOut.go abcd 1` 와 같이 실행하게 되면 출력은 **`abcd`** 가 된다.

  
그런데 이상하지 않은가 ? 배열 접근을 \[1\]로 하는데 왜 abcd 가 출력이 되는지..?  
그래서 주석문을 풀고 arguments 를 보면

![R1280x0-7](https://github.com/shinYeongHyeon/dev-blog/assets/74130738/6d74acd9-4f10-4b41-ad60-83975cb74e96)

args 의 첫번째는 이미 채워져 있는 것을 볼 수 있다. 그래서 조건문의 첫번째도 길이가 1인 경우를 체크한다.

이는 실행시 argument가 아무것도 들어오지 않은 것을 의미하기 때문이다.

## 2\. Build

위 파일을 빌드 `go build stdOut.go` 로 빌드 해보자. 빌드한 파일에 인자를 넘기는 방법도 동일하다.

빌드할때가 아닌 실행할때 `./stdOut abcd 1` 과 같이 넘기면 동일한 결과가 나오게 된다.

근데 첫번째 인자는 다른것을 보니, 실행 방법에 따라 인자값이 달라진다.

![R1280x0-8](https://github.com/shinYeongHyeon/dev-blog/assets/74130738/8933c6dd-21ff-4625-83a9-0978e8742f59)

이상으로 golang 의 서비스를 실행할 때 인자를 넘기는 방벙베 대해서 알아보았다.

  
_해당 포스팅은 Mastering Go 원서를 번역 및 실습해본 결과를 포스팅한 것이다._

Golang 에서 서비스/어플리케이션 실행시에 Argument 들을 받는 방법에 대해서 알아보도록 하자
서비스를 실행시키는 대표적인 두 방법 Build 와 Run 각각 알아보도록 하려고 한다.

Golang build & run with Args


**Channel** 은 데이터를 주고 받는 통로라고 볼 수 있다.  
make 를 통해 선언을 한다

```
type job struct {
  title string
  salary int
}

func main() {
  c := make(chan job)
}
```

채널로 값을 전달해준고 받는다고 보면 된다.

```
// 넘기기 (받기전용) chan<- {type}
func receive(channel chan<- job) {

  // 전달
  channel <- job{
    title: "test",
    salary: 1000000
  }
} 
```

```
// goroutine
go receive(c)

// 데이터 받기
received <-c
```

for 문으로도 쓸 수 있다.

Go 에서 어떻게 보면 큰 핵심 중 하나라고 볼 수 있는 Channel 에 대해서 알아보자

Go Channel


Go 에서 Struct 를 주로 이용한다고 했는데, 여기에 메소드도 추가가 가능하다.  
말로 설명하면 길어지니 코드부터 보자.

```
// Account account Structure
type Account struct {
	owner   string
	balance int
}

var errNoMoney = errors.New("can't withdraw")

// NewAccount Creates Account
func NewAccount(owner string) *Account {
	account := Account{owner: owner, balance: 0}

	return &account
}

// Deposit x amount on your account
func (theAccount *Account) Deposit(amount int) {
	theAccount.balance += amount
}

// Balance of your account
func (theAccount Account) Balance() int {
	return theAccount.balance
}

// Withdraw of your account
func (theAccount *Account) Withdraw(amount int) error {
	if theAccount.balance < amount {
		return errNoMoney
	}

	theAccount.balance -= amount
	return nil
}
```

특징을 살펴보도록 하자.

### **1\. main 이 없다.**

main 이 없는 이유는 라이브러리 처럼 사용하기 때문이다.

### **2\. 내가 싫어하는 주석**

필자는 개인적으로 주석이 있는 코드를 안좋아하지만, Go 에서는 Type 및 Method 정의 시 정의문 위에 Method / Type 명을 시작으로 Comment 작성을 권하고, lint 도 그렇게 동작한다.  
따르도록 하자.

### **3\. error 에 대한 정의**

go 에서는 exception 이 없다. 그렇기 때문에 모든 에러 처리를 해주어야 하는데,  
var errNoMoney = errors.New("can't withdraw") 와 같이 에러를 미리 정의 해주면 깔끔해진다.  
또한 에러에 대한 변수명 정의는 Go 에서 err 로 시작하는 것을 권장한다.  
그래서 errNoMoney 라고 변수명을 정한다.

### **4\. Constructor & Pointer**

Go 에서는 pointer 가 존재한다.

```
 // NewAccount Creates Account
func NewAccount(owner string) *Account {
	account := Account{owner: owner, balance: 0}

	return &account
}

// Deposit x amount on your account
func (theAccount *Account) Deposit(amount int) {
	theAccount.balance += amount
}
```

여기에서 보면 NewAccount 함수는 \*Account 를 리턴하는데, 이는 Account 의 복제본을 리턴하는 것이 아니라, 주소를 직접 보낸다.  
이렇게 하는 이유는 생성자가 없기 때문이다. NewAccount 는 생성자를 대신하는 역할이라고 보면 된다.  
또한 메소드는 func 와 메소드명 Deposit 사이에 어떤 Structure 를 받는지 명시해주면 되는데,  
여기서도 theAccount \*Account 로 받는 이유는 그냥 theAccount Account 로 받을 경우엔 값이 변화 되지 않기 때문이다.  
이에 대해서는 어렵다면 포인터의 개념을 조금 더 이해하고 보면 쉽게 이해될 것.

Go 의 구조체에 Method, 그리고 포인터에 대해 알아보자.

Go Method & Pointer


Go 에서는 타 언어에서 주로 사용하던 Class 와 Object 가 없다.  
그래서 이제 알아야 할 Structure 가 중요한데, 그 전에 Map 에 대해서도 알아보자.

### **Map**

기본적으로 key - value 의 형태를 가지고 있고, key 와 value 도 타입이 필요하다.

```
den := map[string]string{"name: "den", "age": "31"}
```

위의 예제처럼 대괄호 \[\] 안에 key에 대한 타입을 명시해주고, 그 뒤에 value에 대한 타입도 지정해준다.  
그러면 사실 나이는 int 형이어야 하고, 실질적으로는 유동적으로 여러 타입이 가진게 유용할텐데, 그런 것들은 어떻게 해야할까?

### **Structure**

위의 문제를 해결해줄 수 있는 것이 Structure 이다.  
코드로 살펴보자

```
type person struct {
  name string
  age int
  favFood []string
}

favFood := []string{"sujebi", "spicy"}
den := person{
  "den"
  31,
  favFood,
}

for key, value := range den {
  fmt.Println(key, value)
}

den2 := person{
  name: "den2",
  age: 31,
  favFood: favFood,
}

fmt.Println(den2)
```

Structure 안에 여러 타입을 지정해서 마치 오브젝트 처럼 사용해줄 수 있다,

또한, 위에 변수를 지정해준 방식처럼 2가지 방식으로 가능한데,

> 1\. 하나는 value만 쓰는 것  
> 2\. 다른 하나는 key 와 value 를 모두 쓰는 것,

개인적으로는 2번의 방법을 더 좋아한다.  
굳이 위의 선언문을 보지 않아도, 명시직이기때문이다.

Go 에서는 타 언어에서 주로 사용하던 Class 와 Object 가 없다.  
그래서 이제 알아야 할 Structure가 중요한데, 그 전에 Map에 대해서도 알아보자.

Map & Structure


### **Array**

Go 에서 Array 는 그 크기를 제한해주어야 한다. 또한, 그 타입도 지정해야 하며, 그 안에 값들을 세팅하는 것도 나로서는 좀 색달랐다.

```
 names := [5]string{"shin", "yeong", "hyeon"} // Define
 
 names[3] = "den"
 names[4] = "den-shin"
```

첫 번째 라인과 같이 대괄호 안에 Array 의 **크기**를 넣어주고 대괄호 뒤에 타입을 지정해준다.  
그리고 값들을 중괄호 안에 넣어서 정의 해준다.  
그 후에 추가하는 것들은 그 아래 라인들과 같이 진행해주고, 만약  
names\[5\] = "anything" 을 해준다면 컴파일 에러가 난다.

그런데, 크기 지정은 사실 실무에서 그렇게 사용하지 않는다,  
크기가 없는 Array 는 어떻게 지정할까 ?

### **Slice**

크기가 없는 Array 는 Slice 라 불리운다.

```
 names := []string{"shin", "yeong", "hyeon"} // Define
 
 names = append(names, "den")
```

선언부는 거의 똑같다, 크기 지정만 빼면.

그리고 추가하는 부분이 다른데, append 라는 함수를 이용해주어야 하며, 해당 함수는 인자로 넘긴 첫번째 Slice \- 예제에서의 names - 를 변화시키는게 아니라, 값을 추가해서 Return 해준다.  
이와 같은 형태는 개발을 하다보면 실질적으로 도움이 된다.  
원래 값을 변화시키지 않고, 리턴하는 것이 디버깅에도 조금 더 효율적이니까,

Go 에서 배열을 다루는 법에 대해서 알아보자.

Array & Slice


## **For**

Go 에서는 다른 언어에서의 forEach, for in 같은 것은 존재 하지 않고 오직 for 만이 있다. 그리고 range 와 보통 사용하는데, go 만의 특색있는 for 문을 살펴보도록 하자,

근데 이런 점들이 참 Go 를 바라보는 시선이 호불호가 많이 갈리는 이유인가보다.

```
func add(numbers ...int) int {
  // with range
  for index, number := range numbers {
    // execute
  }

  // ignore index
  for _, number := range numbers {
    // execute
  }

  // normal for
  for i := 0; i < len(numbers); i++ {
    // execute
  }

  ...생략
}
```

## **If / Switch**

너무 익숙한 If / Switch 문, 그런데 Go 에서는 If / Switch 문 안에서만 사용할 수 있는 변수를 만들어 낼 수 있다.

```
func canIDrink(age int) bool {
  if (age < 18) {
    return false
  } else {
    return true
  }
}

func canIDrinkInKorea(age int) bool {
  if koreanAge := age + 2; koreanAge < 18 {
    return false
  } else {
    return true
  }
}

func canIDrinkSwitchVer(age int) bool {
  switch age {
    case 16:
      return false
    case 18:
      return true
  }

  return false
}

func canIDrinkSwitchVer2(age int) bool {
  switch {
    case age < 18:
      return false
    case age == 18:
      return true
  }
}

func canIDrinkInKoreaSwitchVer(age int) bool {
  switch koreanAge := age + 2; koreanAge {
    case 16:
      return false
    case 18:
      return true
  }
}
```

기본적인 문법인 for, if, statement 에 대해서 알아보자

for, if, switch statement


[이전포스팅](https://den-shin.tistory.com/12) 에서 끝날때 까지 끝나는게 아닌 함수 안의 **defer** 에 대해서 알아보았다.  
defer 를 함수 최상단에 써 두었었는데, 쉬운 이해를 위해서 그랬고 중간에 넣어도 진행이 가능하다.  
defer 는 해당 라인이 됐을 때 그저 스택에 쌓아 둔다.

```go
func a() {
    i := 0
    defer fmt.Println(i)
    i++
    return
}
```

위 함수의 결과물은 0 이다.

실행 자체는 return 후라서 1이 되어야 할 것 같지만, 스택에 쌓인 시점의 i의 값은 0이기 때문이다.

또한, 스택이기 때문에 후입선출이 된다.

```go
func main() {
	fmt.Println("counting")

	for i := 0; i < 10; i++ {
        defer fmt.Println(i)
	}

	fmt.Println("done")
}
```go

위 코드의 결과물은 아래와 같다

```
counting
done
9
8
7
6
5
4
3
2
1
0
```

이전에 알아보았던 Defer 에 대해서 더 알아보는 시간을 가져보자

Defer


Go 에서는 꽤 유용한 기능들이 많고 Go 만의 특이점도 많다.  
아래에서 천천히 살펴보자.

1. 모든 타입 설정

정적 언어이다 보니 당연하게도 파라미터 타입과 리턴 타입을 설정해 주어야 한다. 그런데 만약, multiply 와 같은 곱셈 함수처럼 모든 파라미터가 같을 때 어느 정도 생략이 가능하다.  
```go
func multiply(a int, b int) int {
  return a * b
}

function multiply2(a, b int) int {
  return a * b
}
```
2. 여러 값 반환

다른 언어에서 여러 값들을 반환 하려면 보통 Array / Object 를 이용해서 반환하며, 리턴 타입이 Array / Object 가 된다.  
그러나 Go 에서는 여러 값 반환이 가능하다..!?  
굉장히 자주 쓰인다 !  
```go
func lenAndUpper(name string) (int, string) {
  return len(name), strings.ToUpper(name)
}

func main() {
  stringLength, upperName := lenAndUpper("den")
  
  fmt.Println(stringLength) // 3
  fmt.Println(upperName)  // DEN
}
```

3. Args 받기

갯수를 알 수 없는 파라미터들을 받을 때는 타입에 ...을 사용한다.

```go
func repeatPrint(words ...string) {
  fmt.Println(words)
}

func main() {
  repeatPrint("den", "shin", "garlic") // [den shin yeong]
}
```

4. 리턴 타입에 변수 지정 후 아무 것도 리턴하지 않기

제목을 어떻게 지어야 할지 애매한데, 아무것도 리턴하지 않았는데 리턴이 되는 magic 이 있다. 이를 naked function 이라 한다. Return 타입(들)에 변수명을 미리 지정하기만 하면 된다.  
```go
func lenAndUpper(name string) (length int, uppercase string) {
  length = len(name)
  uppercase = strings.ToUpper(name)
  
  return
}

func main() {
  stringLength, upeprName := lenAndUpper("den")
  
  fmt.Println(stringLength) // 3
  fmt.Println(upperName)  // DEN
}
```
신기해… 근데 사용은 안 할 듯

5. 끝날때 까지 끝난게 아니다

함수가 끝난 뒤에 실행이 되어야 하는 것들이 있다면 보통은 리턴 받고 나서 로직을 넣는데, 이거를 함수 내에서 설정할 수 있다, 즉 함수 자체에서 “내가 끝난 뒤에는 이것을 실행할거야!” 같은 건데,,,  
너무 멋있다…
```go
func lenAndUpper(name string) (length int, uppercase string) {
	defer fmt.Println("I'm Done")

	length = len(name)
	uppercase = strings.ToUpper(name)

	return
}

func main() {
	totalLength, upperName := lenAndUpper("den")

	fmt.Println(totalLength)
	fmt.Println(upperName)
}

// I'm Done
// 3
// DEN
```
이거 너무 멋있지 않나 ? 이거 때문이라도 go 에 빠질듯…

Go 에서는 꽤 유용한 기능들이 많고 Go 만의 특이점도 많다.
아래에서 천천히 살펴보자.

Functions


# Settings And Vars

Go 언어 개발시 특징이 다른 언어와 다르게 디렉토리를 맘대로 가져갈 수 없다는 것이다.
(Mac 기준) *~/go* 디렉토리 안에서 진행해야 한다. (*GO_PATH* 라고 한다).
[Go 를 설치](https://golang.org)하면 자동으로 생성이 된다는데 나는 안돼서 직접 만들었다.

구조는 main.go 가 Entry point 이기에 필수이며 (컴파일 할 경우에 !) 메인 함수가 필수 이다.
또한, package 도 파일별로 필수이다. main 을 살펴보면 기본구조가 아래와 같다.

```go
package main func main() {}
```

기본 제공되는 라이브러리 중 *fmt* 를 가장 먼저 접하게 되는데 (Hello World 찍어봐야지)
사용 방법을 보자면 아래와 같다.
```go
package main import "fmt"

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

*Println* 함수명을 보면 대문자로 시작하는데, 함수를 export 하려면 무조건 대문자로 시작해서 export 하고
사용도 대문자로 시작하여야 한다.

# 변수 & 상수

다른 언어와 똑같이 변수와 상수가 존재하는데 전 포스팅에서 장점으로 말했 듯 Type 이 필요하다.
예제를 보면 이해가 될 것이기에 별다른 설명은 생략한다. 또한, 변수 생성에 축약 버전도 존재하는데 `:=` 를 사용하면 된다.
이 때에는 Type 을 명시 해주지 않는데, 이는 Go 가 알아서 찾아주며 이후에 다른 Type 이 들어오면 에러를 뱉어내준다. (Oh..?)
이에 대한 공식 명칭은 *short assignment statement* 이다.
``` go
const name string = "den"
var gender string = "M"
age := 30
age = 31 // to be ERROR !
```


Go 를 세팅하는 법과 변수/상수에 대해 알아보자
Go 는 타입을 강력하게 정의하기 때문에, typescript를 좋아하는 나에게는 너무 좋다.

Why GOLANG ?

Why Golang ?

GOLANG_알아보기

GoLang 변수 할당/생성 := and =

Golang build & run with Args

Go Channel

Go Method & Pointer

Map & Structure

Array & Slice

for, if, switch statement

Defer

Functions

Golang Settings & Vars

Why GOLANG ?