(🐭Go) Syntax

Overview

C++ 개발자임에도 C를 별로 좋아하지는 않는다. 객체지향만을 위한 언어는 아니지만 엄연히 C++는 객체지향 언어이고 C언어는 아니기 때문이다. 개발진 모두가 C++의 복잡성이 싫어서 Go를 개발했다고 말을 했지만, 나는 Go의 문법의 생김새도 API들의 시그니쳐도 보기가 싫다. 마치 C언어 같기 때문이다.

그럼에도 Go는 뛰어난 장점들이 있어 멀리 둘 수가 없는데, 그중 제일은 많은 회사들에서 Golang을 채용하고 사용하기 시작했기 때문이다ㅜ 특히나 인프라 개발에 있어서 Go는 좋은 도구로 여겨지고 있다. docker와 kubernates 역시 golang으로 개발되었다.

두 번째는 두 번째로 언급된게 억울할 정도로 좋은 기능인 goroutine이다.

**[미] MuliThreadProgramming [mʌ́ ltiθred-|proʊgrӕmɪŋ]** : 1. 흑마술, 마공 2. 위력이 강대하나 다루기 어려워 잘 쓰이지 않는 기술  

멀티쓰레드 프로그래밍의 지난함을 경험한 프로그래머는 goroutine 하나만으로도 go를 사용할 이유가 충분하다. goroutine의 사용법에 대해서는 별도의 포스트로 간단하게 소개할 예정이다.

세 번째는 간결함이다. 사실 가장 중요한 요소일 수 있다. 대부분을 내장 API만을 사용해서 구현할 수 있기에 repository에서 열심히 라이브러리를 가져오고 배포하는 일이 별로 필요없다. 그리고 무엇보다 문법 또한 간단하다. 이쁘게 다이어트를 하는걸 넘어서 아주 뼈만 남은 느낌이다.

이외에도 GC를 통한 메모리 관리, 좋은 생태계와 도구 등 여러가지 장점이 있다.

Rival

처음에는 Golang의 라이벌은 Rust라고 생각했었다. 일반적으로 두 언어 모두 C/C++을 대체하기 위한 시스템 프로그래밍 언어로 알려져 있었기 때문이다.

하지만 실제로 Golang은 그러한 방향으로 나아가고 있지 않으며 사용법을 생각해보면 오히려 Python의 스크립팅 용도를 대체하고 있는게 아닌가 싶다. Python의 생태계가 아직 훨씬 커보이지만 성능은 Go의 압승이다. 그리고 Rust는 진정한 시스템 프로그래밍 언어로 가고 있는게 아닌지…(개인적으로 호감도는 Rust의 압승이다)

Syntax

Python과 마찬가지로 아주 디테일한 문법사항을 정리하지는 않을 생각이다. 수많은 자료와 책이 있기 때문이다. 그래도 Python만큼 간단하지는 않기 때문에 내용은 더 많을 것 같다.

package와 main 함수

package main    // 이 파일이 main 패키지에 포함된다는 뜻이다  
  
import "fmt"    // built in 패키지를 import하여 사용한다  
  
func main() {  
    fmt.Println("Hello world!")  
}   

main 함수가 없어도 라이브러리 개념으로 다른곳에서 사용할 수 있지만,
그런 경우 단독으로 컴파일은 되지 않는다.

접근 지정자 개념

package something  
  
import "fmt"  
  
func SayHello() {  
	fmt.Println("Hello")  
}  

별도의 파일에 something 패키지에 포함될 내용을 작성해보았다.
여기서 접근지정자 개념이 나오는데,

• sayHello => private
• SayHello => public export

대소문자에 의해 export 여부를 결정한다. 언뜻보면 이상하지만 Convention rule을 겸하는 문법이라 좋은거 같기도 하다. 이것을 이용해서 하나의 package를 다른 언어의 클래스, 대문자로 시작하는 함수를 interface라고 생각해볼 수도 있겠다.

Structure

type Account struct {  
	owner   string  
	Balance int			// 대문자라 외부에서 참조 가능  
}  

Structure에서도 member의 가시성을 첫 문자의 대소문자를 통해 구분할 수 있다.
위 경우 Balance만 밖에서 접근할 수 있다.

Implicit type determine :=

package main  
  
import "fmt"  
  
func main() {  
	name := "hoo"  
	name = "lynn"  
	fmt.Println(name)  
}  

:=는 무척 이상하게 생겼지만 암시적으로 타입을 결정할 수 있는 연산자이다. 이 문법을 사용하면 변수를 추정하여 타입없이 바로 선언과 초기화를 할 수 있으며, 함수 안에서만 선언가능하고 전역적으로는 선언할 수 없다.

:=
이렇게 단독으로 써보니 약간 귀여운거 같기도 하다. 엄청 많이 사용하는 문법이기 때문에 잘 모르고 코드를 봤을때, 이거때문에 코드가 엄청 외계어처럼 보였었다.

Function

package main  
  
import (  
	"fmt"  
	"strings"  
)  
  
// 뒤에 괄호에 리턴형을 지정하고 멀티 리턴이 가능하다!  
func lenAndUpper(name string) (int, string) {  
	return len(name), strings.ToUpper(name)  
}  
  
// ...으로 가변 인자가 가능하다  
func repeatMe(words ...string) {  
	fmt.Println(words)  
}  
  
func main() {  
	totalLenght, _ := lenAndUpper("hoo")  
	fmt.Println(totalLenght)  
}  

Multi return과 가변 인자를 지원한다. 이건 상당한 큰 편의를 제공할 것 같다.

naked return과 defer

func lenAndUpper(name string) (length int, uppercase string) {    // 리턴 변수를 바로 선언 가능  
	defer fmt.Println("I'm done")    // 함수가 끝난 뒤 코드가 실행되도록 한다  
	length = len(name)  
	uppercase = strings.ToUpper(name)  
	return  
}  

두 번째 괄호안의 변수명 지정은 naked return 이라는 기능이다. 리턴 변수를 바로 괄호에서 지정해서 함수내에서 따로 선언을 할 필요가 없다. 리턴할 변수를 미리 선언하고 값을 채워넣는 패턴을 많이 사용했을텐데 그럴때 유용하다.

그리고 defer 키워드는 뒤에 있는 문장을 함수가 끝난뒤에 실행하도록 해준다. Post process를 정의하는데 유용하다.

반복문과 조건문

// 반복문은 오직 for문 뿐이다  
total := 0  
for index, number := range numbers {	// index를 사용하지 않을때는 _, number 이런식으로 사용  
	total += number  
}  
  
if koreanAge := age + 2; koreanAge < 18 {  
	return false  
}  

Variable expression

switch koreanAge := age + 2; koreanAge {  
	case 10:  
		return false  
	case 18:  
		return true  
    case koreanAge > 18:  
        return true;  
}  

modern c++에서도 추가되었던 사항이다. 내용처럼 if문 안에서 변수를 선언할 수 있다. if 블록 안에서만 사용할 수 있으므로 더 숨길 수 있어 좋다. switch에서도 variable expression을 사용할 수 있고, case에서 조건도 가능하므로 if~else를 대체할 수 있다.

Pointer

func main() {  
	fmt.Println(canIDrink(18))  
	a := 2  
	b := &a  
	*b = 2020;  
	fmt.Println(a, *b)  
}  

개념과 연산자 등 모두 C언어에서의 사용법과 동일하다.

Array와 Slice

import "fmt"  
  
func main() {  
	names := [5]string{"hoo", "lynn", "dal"}   // 크기를 지정하면 Array  
  
	names := []string{"hoo", "lynn", "dal"}    // 크기를 비워두면 Slice  
	names = append(names, "flynn")  
	fmt.Println(names)  
}  

Golang의 태생을 고려할때, c언어에 익숙하면 아주 개념이 잘 달라붙는다. Array는 크기가 불변인 C언어의 Array와 동일하며, Slice는 append 함수를 통해 STL의 vector처럼 추가가 가능하다. 다만…append의 사용법은 전혀 객체지향적으로 보이지 않는다.

Map

import "fmt"  
  
func main() {  
	hoo := map[string]int{"name": 3, "age": 7}  
    value, exist := hoo["name"]  
	for key, value := range hoo {  
		fmt.Println(key, value)  
	}  
}  
  
func (d Dictionary) Delete(word string) {  
	delete(d, word)  
}  

에러처리

func (a *Account) Withdraw(amount int) error {  
	if a.balance < amount {  
		return errNoMoney  
	}  
	a.balance -= amount  
	return nil  
}  

golang에는 try/catch와 같은 문법이 없다. if 문을 통해 에러 처리는 위와 같이 한다.
에러가 아닐 때 nil을 반환하는 것을 주목한다.

toString

func (a Account) String() string {  
	return fmt.Sprint(a.Owner(), "’s account.\nHas: ", a.Balance())  
}  

structure에 위와 같이 정의하면 자바의 toString()처럼 호출된다.

type

package mydict  
  
import "errors"  
  
// Dictionary type  
type Dictionary map[string]string  
  
var errNotFound = errors.New("Not Found")  
  
// Search for a word  
func (d Dictionary) Search(word string) (string, error) {  
	value, exists := d[word]  
	if exists {  
		return value, nil  
	}  
	return "", errNotFound  
}  

type은 C언어의 typedef와 같은 개념인데 메소드를 가질 수 있다.
어떤 것이든 타입으로 어떠한 이름을 짓고 그것에 대한 메소드를 가질 수 있는 것이다.

다중 변수 초기화

// 여러 변수를 이렇게 초기화할 수도 있다  
var (  
	errNotFound   = errors.New("Not Found")  
	errCantUpdate = errors.New("Cant update non-existing word")  
	errWordExists = errors.New("That word already exists")  
)  
  
// 파라메터의 변수가 동일한 경우 한번만 작성해도 된다  
func (a, b int) Balance() int {  
	return a.balance  
}  

Example

은행 어플리케이션을 간단하게 구현하는 것을 코드로 구현해보도록 하자.

import "fmt"  
  
type person struct {  
	name    string  
	age     int  
	favFood []string  
}  
  
func main() {  
	favFood := []string{"kimchi", "ramen"}  
	hoo := person{name: "hoo", age: 18, favFood: favFood}  
	fmt.Println(hoo.name)  
}  
  
package accounts  
  
// Account struct  
type Account struct {  
	owner   string  
	balance int  
}  
  
// NewAccount creates Account  
func NewAccount(owner string) *Account {  
	account := Account{owner: owner, balance: 0}  
	return &account  
}  

Golang에는 생성자 개념이 없기때문에 위 NewAccount에서처럼 사용하는 패턴을 사용한다. 위 structure에서 owner, balance는 소문자로 시작하기 때문에 초기화할 수 없다. 대신 같은 package내의 NewAccount에서 생성하고 주소를 반환하면서 참조를 받는 것이다.

account := accounts.NewAccount("hoo")
이런 식으로 호출하여 생성한다. accounts는 패키지 이름이다.

// Deposit x amount on your account  
func (a Account) Deposit(amount int) {    // 앞에 괄호는 Receiver라는 녀석이다  
	a.balance += amount  
}  
  
// Balance of your account  
func (a Account) Balance() int {  
	return a.balance  
}  

structure에 대한 method도 이렇게 구현할 수 있다. 충분히 객체지향적인 구현이 가능하고 최소한 C언어와 같은 스파게티 코드는 피하고도 남는다. 상속이 없어도 캡슐화, 정보은닉 그리고 덕 타이핑(Duck typing)을 이용한 다형성 정도는 가능할거 같다.

그런데 잘 생각해보면 Deposit은 잘작동하지 않는다.
C언어 기초를 생각해보면 알수있다. a는 복사본이다.

func (a *Account) Deposit(amount int) {  
	a.balance += amount  
}  

C언어를 안다면 익숙할 것이다. 저 매개변수의 *는 참조가 아니라 포인터를 의미한다. 별것도 아닌데 그렇게 사람들을 괴롭힌다는 Call by pointer. 그리고 Balance의 경우에는 그렇다고 하더라도 잘 동작할것이다.