vscode에서 제공하는 개발용 컨테이너를 만드는 방법에 대해 소개합니다.

vscode extension; remote-containers

extension 설치

설치 링크 remote-containers

에러 발생 및 docker desktop 설치 진행

위 과정 이전에 Docker desktop을 먼저 설치해도 상관없습니다.

Docker desktop 의존성, WSL2 설치

WSL2 커널 업데이트하라는 문구와 함께 설치를 마치면 Restart를 누르도록 합니다.

커널 업데이트 링크 누르면 아래 주소로 리다이렉트됩니다.

https://learn.microsoft.com/ko-kr/windows/wsl/install-manual#step-4---download-the-linux-kernel-update-package

볼드체 링크를 누르면 다운로드가 시작됩니다.

PowerShell 관리자모드로 실행 및 커맨드를 입력합니다.

Docker desktop Restart 및 Tutorial

아래는 Docker desktop tutorial 과정입니다. 해당 튜토리얼 과정을 진행해도 좋습니다. (스킵하시면 ## Docker image build 를 보시면 됩니다.)

Docker image build

컨테이너 환경을 만들기 위해 image를 빌드합니다. 빌드할 베이스 이미지는 microsoft에서 제공하는 우분투로 합니다. vscode extension; remote-containers를 사용한 이미지 빌드에서는 아래와 같은 file 구조가 필요합니다.

mount_directory
    ⨽ .devcontainer
        ⊢ devcontainer.json
        ⨽ Dockerfile

저는 vamos라는 디렉터리 를 컨테이너에 마운트해서 사용합니다.

mount_directory 디렉터리에서 우클릭 후, vscode로 해당 디렉터리를 열고 위와 같이 file 구조를 만듭니다. (vscode에서 mount_directory 열기)

파일 작성

참고 https://code.visualstudio.com/docs/remote/containers#_installation

devcontainer.json

json은 주석을 지원하지 않지만, vscode 내 configuration 항목들에 대한 json 내의 주석은 허용됩니다.

// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
// https://github.com/microsoft/vscode-dev-containers/tree/v0.245.2/containers/ubuntu
{
    "name": "Ubuntu",
    "build": {
        "dockerfile": "Dockerfile",
        // Update 'VARIANT' to pick an Ubuntu version: jammy / ubuntu-22.04, focal / ubuntu-20.04, bionic /ubuntu-18.04
        // Use ubuntu-22.04 or ubuntu-18.04 on local arm64/Apple Silicon.
        "args": { "VARIANT": "ubuntu-18.04" }
    },
>
    // Use 'forwardPorts' to make a list of ports inside the container available locally.
    // "forwardPorts": [],
>
    // Use 'postCreateCommand' to run commands after the container is created.
    // "postCreateCommand": "uname -a",
>
    // Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
      "workspaceMount": "source=${localWorkspaceFolder}/workspace,target=/workspace,type=bind",
      // container 실행 시, workspaceFolder 설정한 곳에서 시작함
    "workspaceFolder": "/home/eon",
      // 사용자 eon으로 시작함
    "remoteUser": "eon",
    "features": {
        "docker-in-docker": "latest",
        "git": "os-provided",
        "sshd": "latest"
    }
}

Dockerfile

# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.245.2/containers/ubuntu/.devcontainer/base.Dockerfile
>
# [Choice] Ubuntu version (use ubuntu-22.04 or ubuntu-18.04 on local arm64/Apple Silicon): ubuntu-22.04, ubuntu-20.04, ubuntu-18.04
ARG VARIANT="ubuntu-18.04"
FROM mcr.microsoft.com/vscode/devcontainers/base:${VARIANT}
>
# [Optional] Uncomment this section to install additional OS packages.
# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
#     && apt-get -y install --no-install-recommends <your-package-list-here>
>
# vscode가 기본 user이고, 기본 값으로 설정돼 있던 user를 eon으로 변경함
ARG USERNAME=eon
ARG OLDNAME=vscode
RUN usermod -l $USERNAME $OLDNAME \
    && groupmod -n $USERNAME $OLDNAME \
    && usermod -d /home/$USERNAME -m $USERNAME
>
# [Optional] https://code.visualstudio.com/remote/advancedcontainers/add-nonroot-user
RUN echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME \
    && chmod 0440 /etc/sudoers.d/$USERNAME
>   
USER $USERNAME

이미지 빌드

vscode에서 F1을 누르고, Remote-Containers: Rebuild Container를 선택하면 빌드가 시작되고, 컨테이너가 실행됩니다.

빌드된 이미지는 로컬 환경에서 Docker desktop을 통해 관리합니다.

https://code.visualstudio.com/remote/advancedcontainers/overview

이상 개발용 컨테이너 생성에 대한 내용이었습니다. 감사합니다.👍

이번에 다룰 내용은 메서드입니다.

📝 Method

메서드는 함수와 큰 차이가 없으나, 객체에 속한다는 특징이 있습니다. 함수는 객체와 상관없이 호출하면 사용이 가능하지만, 메서드는 해당 객체를 통해서만 호출이 가능합니다.

package main

import "fmt"

type Parameter struct {
    XX string
}

func nameOfFunction(p *Parameter) {
    p.XX = "YY"
}

func main() {
    p := Parameter{}
    p.XX = "XX"
    nameOfFunction(&p)
    fmt.Println(p)
}

package main

import "fmt"

type Receiver struct {
    XX string
}

func (r *Receiver) nameOfMethod() {
    r.XX = "YY"
}

func main() {
    r := Receiver{}
    r.XX = "XX"
    r.nameOfMethod()
    fmt.Println(r)
}

📌 왜 Method를 사용할까?

그렇다면 왜 제약조건이 더 붙은 메서드를 사용할까? 유지보수 측면에서 더 유리할 수 있습니다. 프로그램이 동작하는 데에 있어서는 큰 차이가 없으나, 객체의 타입마다 사용할 수 있는 메서드를 제한할 수 있습니다.

• 어떤 객체에서 에러가 발생
  • 그 객체의 메서드를 디버깅하여 개선할 수 있음
• 기능을 분리하여 객체지향 모델을 만들 수 있음
  • 기능을 독립적으로 수행하게 하기 위함

📍 Receiver

메서드는 위에 함수와 다르게 함수명과 함수 선언부 사이에 리시버가 들어갑니다. Receiver는 어떤 타입의 객체가 사용할 수 있는 메서드인지 제한하고, 해당 타입의 객체만 이 메서드를 사용할 수 있게 합니다.

func (s *Student) StudentInfoUpdate() {
// TODO: update student's information
...
}

여기서 StudentInfoUpdate()라는 메서드는 Student라는 타입의 리시버가 지정되어 있습니다. Student 객체 말고는 이 메서드를 사용할 수 없습니다.

📌 사용법

함수와 마찬가지로 포인터형과 밸류형이 있습니다.

포인터형은 당연하게도 인스턴스를 직접 조작합니다. 밸류형은 값을 복사해서 사용하기 때문에 포인터형과 다르게 인스턴스를 새로 만들어서 조작합니다.

📍 포인터형 리시버 / 메서드

package main

import "fmt"

type Student struct {
    Name  string
    Age   int8
    Email string
}

func (s *Student) HappyNewYear() {
    s.Age += 1
}

func (s *Student) UpdateEmail(NewEmail string) {
    s.Email = NewEmail
}

func main() {
    s1 := new(Student)
    s1.Name = "David"
    s1.Age = 20
    s1.Email = "empty@email.invalid"
    s1.HappyNewYear()
    s1.UpdateEmail("david@email.com")
    fmt.Println(*s1)
}

/* output
{David 21 david@email.com}
*/

위와 같이 반환값이 없어도 포인터로 인스턴스를 직접 조작하기 때문에 변경된 값이 유지되는 것을 볼 수 있습니다.

📍 밸류형 리시버 / 메서드 (반환 없이)

package main

import "fmt"

type Student struct {
    Name  string
    Age   int8
    Email string
}

func (s Student) HappyNewYear() {
    s.Age += 1
}

func (s Student) UpdateEmail(NewEmail string) {
    s.Email = NewEmail
}

func main() {
    s2 := Student{}
    s2.Name = "David"
    s2.Age = 20
    s2.Email = "empty@email.invalid"
    s2.HappyNewYear()
    s2.UpdateEmail("david@email.com")
    fmt.Println(s2)
}


/* output
{David 20 empty@email.invalid}
*/

위와 같이 반환하지 않고 객체를 밸류형으로 조작하는 경우, 호출된 메서드에서 새로운 인스턴스 가 만들어집니다.

func (s Student) UpdateEmail(NewEmail string) {
    s.Email = NewEmail
    fmt.Println(s.Email)
}
/* output
david@email.com
*/

이렇게 UpdateEmail() 메서드 내에서는 값이 정상적으로 변경된 것을 확인할 수 있습니다. 값 반환을 하지 않았기 때문에 해당 메서드 내에서 변경된 값은 의도한 s2 객체에 아무런 영향을 주지 않습니다.

📍 밸류형 리시버 / 메서드 (반환 포함)

package main

import "fmt"

type Student struct {
    Name  string
    Age   int8
    Email string
}

func (s Student) HappyNewYear() Student {
    s.Age += 1
    return s
}

func (s Student) UpdateEmail(NewEmail string) string {
    s.Email = NewEmail
    return s.Email
}

func main() {
    s2 := Student{}
    s2.Name = "David"
    s2.Age = 20
    s2.Email = "empty@email.invalid"
    s2 = s2.HappyNewYear()
    s2.Email = s2.UpdateEmail("david@email.com")
    fmt.Println(s2)
}


/* output
{David 21 david@email.com}
*/

위와 같이 알맞게 값을 반환했더니 의도한 대로 Age와 Email이 변경된 것을 확인할 수 있습니다.

이번 포스트는 메서드에 대한 내용이었습니다.

감사합니다.👍

📝 슬라이스

📌 슬라이스란?

Golang의 동적 배열입니다. 배열과 다르게 배열 길이의 확장과 축소가 가능합니다.

📌 슬라이스 변수의 선언

📍 일반적 선언

var intSlice1 []int
var intSlice2 []int = []int{1, 2, 3, 4, 5}
var intSlice3 = []int{6, 7, 8, 9, 10}
intSlice4 := []int{}
intSlice5 := []int{11, 12, 13, 14, 15}

슬라이스 변수의 요소 타입을 int로 선언하려면 위와 같이 []int로 타입을 지정하면 됩니다.

📍 슬라이스 안의 슬라이스

var slSlice1 [][]int
var slSlice2 [][]int = [][]int{{1, 2, 3, 4, 5}, {6, 7, 8}}
var slSlice3 = [][]int{{6, 7, 8}, {1, 2, 3, 4, 5}}
slSlice4 := [][]int{}
slSlice5 := [][]int{{}} // [][]int{{}, {}} // [][]int{{}, {}, {}}
slSlice6 := [][]int{{6, 7, 8}, {1, 2, 3, 4, 5}}

위와 같이 슬라이스를 이중으로 사용할 수도 있습니다. 이 경우, 동적 이차원 배열이 됩니다.

📍 슬라이스 인덱스 별 지정하여 선언

var intSlice1 []int = []int{0: 1, 3: 4, 5, 6}
fmt.Println(intSlice1)
/* output
[1 0 0 4 5 6]
*/

위와 같이 인덱스를 지정하여 선언할 수 있습니다. 초기화되지 않은 인덱스는 zero-value로 초기화됩니다.

var intSlice1 []int = []int{3: 4, 7, 8, 9, 0: 1, 5, 6}
fmt.Println(intSlice1)
/* output
[1 5 6 4 7 8 9]
*/

이렇게 인덱스 순서를 다르게 하면 마지막에 지정한 인덱스 뒤에, 인덱스를 지정하지 않은 값들을 순서대로 초기화됩니다. 위의 상황에서 5, 6으로 초기화 시킨 값 뒤에 인덱스 하나를 더 추가할 경우, 0번 인덱스 초기화 뒤에 이미 2개의 값이 들어갔고 그 뒤 3번 인덱스로 인식이 되어 duplicated index 에러가 발생합니다.

📝 슬라이스의 구성

📌 slice는 string과 비슷하다?

slice는 string과 비슷합니다. 단순 값 복사를 하면 헤더가 복사돼, 서로 다른 변수라도 같은 slice를 가리키게 됩니다. string을 복사할 때, StringHeader가 복사된 것처럼slice도 SliceHeader가 복사되기 때문입니다.

📍 SliceHeader

// SliceHeader is the runtime representation of a slice.
// It cannot be used safely or portably and its representation may
// change in a later release.
// Moreover, the Data field is not sufficient to guarantee the data
// it references will not be garbage collected, so programs must keep
// a separate, correctly typed pointer to the underlying data.
type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}
>
...
type StringHeader struct {
    Data uintptr
    Len  int
}
...

SliceHeader는 Data, Len, Cap 필드를 가지고 있습니다. StringHeader는 Data와 Len 필드를 가지고 있습니다.

Data field

실제 데이터의 위치를 가리킵니다.

Len field (Length)

데이터의 길이를 나타냅니다.

Cap field (Capacity)

데이터를 수용할 수 있는 범위를 나타냅니다.

📝 슬라이스 활용

📌 slice related golang built-in functions

📍 make()

// The make built-in function allocates and initializes an object of type
// slice, map, or chan (only). Like new, the first argument is a type, not a
// value. Unlike new, make's return type is the same as the type of its
// argument, not a pointer to it. The specification of the result depends on
// the type:
//    Slice: The size specifies the length. The capacity of the slice is
//    equal to its length. A second integer argument may be provided to
//    specify a different capacity; it must be no smaller than the
//    length. For example, make([]int, 0, 10) allocates an underlying array
//    of size 10 and returns a slice of length 0 and capacity 10 that is
//    backed by this underlying array.
//    Map: An empty map is allocated with enough space to hold the
//    specified number of elements. The size may be omitted, in which case
//    a small starting size is allocated.
//    Channel: The channel's buffer is initialized with the specified
//    buffer capacity. If zero, or the size is omitted, the channel is
//    unbuffered.
func make(t Type, size ...IntegerType) Type

slice, map, chan의 선언 및 초기화하는 방법 중 하나이며, golang 내장함수입니다. new는 포인터 타입을 반환하지만, make는 지정한 타입으로 반환합니다.

• make의 인자 (for slice)
  • 첫 번째 인자는 요소의 타입
  • 두 번째 인자는 Len
  • 세 번째 인자는 Cap

var slice []int = make([]int, 10, 12)
fmt.Println(slice)
/* output
[0 0 0 0 0]
*/

길이가 10이고 최대 길이가 12인 []int 슬라이스를 생성합니다. 생성된 슬라이스는 zero-value로 초기화됩니다.

📍 append()

// The append built-in function appends elements to the end of a slice. If
// it has sufficient capacity, the destination is resliced to accommodate the
// new elements. If it does not, a new underlying array will be allocated.
// Append returns the updated slice. It is therefore necessary to store the
// result of append, often in the variable holding the slice itself:
//    slice = append(slice, elem1, elem2)
//    slice = append(slice, anotherSlice...)
// As a special case, it is legal to append a string to a byte slice, like this:
//    slice = append([]byte("hello "), "world"...)
func append(slice []Type, elems ...Type) []Type

슬라이스의 끝에 요소를 '덧붙이는' golang 내장함수입니다. capacity가 여유있는 경우엔 새 요소를 그대로 붙이고, 여유가 없는 경우에는 새로운 슬라이스가 할당됩니다. append() 내장함수는 새로 업데이트된 슬라이스를 반환합니다.

slice = append(slice, elem1, elem2)
slice = append(slice, anotherSlice...)

위와 같이 사용 가능합니다. 물론 요소의 자료형은 slice 요소의 자료형과 동일해야 합니다. (slice... 의 ...은 슬라이스를 덧붙일 때 사용합니다.)

append()의 메모리 할당

func main() {
    slice := []int{1, 2, 3, 4, 5}
    slHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
    fmt.Printf("slHeader.Data : %v\n", slHeader.Data)
    fmt.Printf("slHeader.Len : %v\n", slHeader.Len)
    fmt.Printf("slHeader.Cap : %v\n", slHeader.Cap)
    fmt.Println()
    slice = append(slice, 6, 7, 8)
    slHeader = (*reflect.SliceHeader)(unsafe.Pointer(&slice))
    fmt.Printf("slHeader.Data : %v\n", slHeader.Data)
    fmt.Printf("slHeader.Len : %v\n", slHeader.Len)
    fmt.Printf("slHeader.Cap : %v\n", slHeader.Cap)
}
/* output
slHeader.Data : 824634273488
slHeader.Len : 5
slHeader.Cap : 5
>
slHeader.Data : 824634433536
slHeader.Len : 8
slHeader.Cap : 10
*/

append()를 사용했을 때, 기존 슬라이스의 공간이 부족하면 두 배 크기의 공간을 할당해서 완전히 새로운 슬라이스를 만들어서 반환합니다.

...
slice2 := []int{6, 7, 8, 9, 10, 11}
slice = append(slice, slice2...)
...
/* output
slHeader.Data : 824634318848
slHeader.Len : 11
slHeader.Cap : 12
*/

만약 위와 같이 새로 덧붙여지는 요소 / 슬라이스의 크기가 기존의 슬라이스보다 큰 경우, 더 큰 크기의 슬라이스를 기준으로 두 배의 공간을 할당해서 새로운 슬라이스를 만들고 반환합니다.

📍 copy()

// The copy built-in function copies elements from a source slice into a
// destination slice. (As a special case, it also will copy bytes from a
// string to a slice of bytes.) The source and destination may overlap. Copy
// returns the number of elements copied, which will be the minimum of
// len(src) and len(dst).
func copy(dst, src []Type) int

src 슬라이스를 dst 슬라이스로 복사합니다. string의 byte 값을 []byte 자료형으로 하여 복사하기도 합니다. copy() 내장함수는 복사된 요소의 개수를 반환합니다.

📌 슬라이스의 사용

📍 슬라이스 대입

func main() {
    slice1 := []int{1, 2, 3, 4, 5}
    slice2 := slice1
    fmt.Println(slice2)
}
/* output
[1 2 3 4 5]
*/

위와 같이 슬라이스 대입을 수행하면, 같은 값을 가지는 걸 볼 수 있습니다.

slice1[0] = 100
fmt.Println(slice2)
/* output
[100 2 3 4 5]
*/

이렇게 slice1을 수정하면 slice2까지 영향을 받는 걸 볼 수 있습니다. 슬라이스를 대입 연산을 하면 슬라이스 헤더가 대입되어 두 변수 모두 하나의 인스턴스를 가리키게 됩니다.

func main() {
    slice1 := []int{1, 2, 3, 4, 5}
    slice2 := slice1
    fmt.Println(slice2)
    slice1[0] = 100
    fmt.Println(slice2)
    slHeader1 := (*reflect.SliceHeader)(unsafe.Pointer(&slice1))
    slHeader2 := (*reflect.SliceHeader)(unsafe.Pointer(&slice2))
    fmt.Println()
    fmt.Println("*-*-*-*-* slice1 *-*-*-*-*")
    fmt.Printf("slHeader1.Data : %v\n", slHeader1.Data)
    fmt.Printf("slHeader1.Len : %v\n", slHeader1.Len)
    fmt.Printf("slHeader1.Cap : %v\n", slHeader1.Cap)
    fmt.Println()
    fmt.Println("*-*-*-*-* slice2 *-*-*-*-*")
    fmt.Printf("slHeader2.Data : %v\n", slHeader2.Data)
    fmt.Printf("slHeader2.Len : %v\n", slHeader2.Len)
    fmt.Printf("slHeader2.Cap : %v\n", slHeader2.Cap)
}
/* output
[1 2 3 4 5]
[100 2 3 4 5]
>
*-*-*-*-* slice1 *-*-*-*-*
slHeader1.Data : 824634376240
slHeader1.Len : 5
slHeader1.Cap : 5
>
*-*-*-*-* slice2 *-*-*-*-*
slHeader2.Data : 824634376240
slHeader2.Len : 5
slHeader2.Cap : 5
*/

같은 Data 필드를 가진 것을 볼 수 있습니다.

📍 슬라이스 복사

슬라이스 순회를 이용한 복사

func main() {
    slice1 := []int{1, 2, 3, 4, 5}
    slice2 := make([]int, len(slice1))
    for i, v := range slice1 {
        slice2[i] = v
    }
    fmt.Println(slice2)
}
/* output
[1 2 3 4 5]
*/

이 방법은 slice1와 같은 길이를 가지는 slice2를 빈 값으로 선언 및 초기화를 먼저 진행합니다. 그리고 빈 슬라이스인 slice2에 slice1의 요소를 순회하며 대입하는 방식으로, 값은 같으나 서로 다른 인스턴스를 가리키게 합니다. (서로 같은 인스턴스를 가리키는지 확인하려면 위의 SliceHeader를 출력하는 구문을 사용하면 됩니다.)

append() 내장함수를 이용한 복사

func main() {
    slice1 := []int{1, 2, 3, 4, 5}
    slice2 := append([]int{}, slice1...)
    fmt.Println(slice2)
}
/* output
[1 2 3 4 5]
*/

append() 내장함수를 사용하여 새로운 빈 슬라이스에 기존 슬라이스를 덧붙여, 같은 값을 가지지만 서로 다른 인스턴스인 슬라이스를 생성할 수 있습니다.

copy() 내장함수를 이용한 복사

func main() {
    slice1 := []int{1, 2, 3, 4, 5}
    slice2 := make([]int, 3)
    copy(slice2, slice1)
    fmt.Println(slice2)
}
/*    output
[1 2 3]
*/

func copy(dst, src []Type) int 의 dst의 크기 내에서 src를 복사합니다. dst의 범위를 벗어나는 요소는 복사해오지 않습니다.

📍 슬라이스 요소 제거

특정 인덱스를 제거한 새로운 슬라이스

func SubElement(index int, slice []int) (subSlice []int) {
    subSlice = []int{}
    for i, v := range slice {
        if index == i {
            continue
        }
        subSlice = append(subSlice, v)
    }
    return
}
func main() {
    slice1 := []int{1, 2, 3, 4, 5}
    slice2 := SubElement(3, slice1)
    slice2Header := (*reflect.SliceHeader)(unsafe.Pointer(&slice2))
    fmt.Println("slice2 :", slice2)
    fmt.Println("*-*-*-*-* slice2 *-*-*-*-*")
    fmt.Printf("slice2Header.Data : %v\n", slice2Header.Data)
    fmt.Printf("slice2Header.Len : %v\n", slice2Header.Len)
    fmt.Printf("slice2Header.Cap : %v\n", slice2Header.Cap)
}
/*    output
slice2 : [1 2 3 5]
*-*-*-*-* slice2 *-*-*-*-*
slice2Header.Data : 824634425344
slice2Header.Len : 4
slice2Header.Cap : 4
*/

기존 슬라이스를 보존하면서 특정 인덱스를 뺀 슬라이스를 새로 만듭니다.

기존 슬라이스에서 특정 인덱스를 제거

func main() {
    slice := []int{1, 2, 3, 4, 5}
    index := 3
    beforeHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
    fmt.Println("slice :", slice)
    fmt.Println("*-*-*-*-* slice *-*-*-*-*")
    fmt.Println(beforeHeader)
    for i := index + 1; i < len(slice); i++ {
        slice[i-1] = slice[i]
    }
    slice = slice[:len(slice)-1]
    fmt.Println()
    resultHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
    fmt.Println("slice :", slice)
    fmt.Println("*-*-*-*-* slice *-*-*-*-*")
    fmt.Println(resultHeader)
}
/* output
slice : [1 2 3 4 5]
*-*-*-*-* slice *-*-*-*-*
&{824634376240 5 5}
>
slice : [1 2 3 5]
*-*-*-*-* slice *-*-*-*-*
&{824634376240 4 5}
*/

슬라이스를 처음 만들었을 때의 capacity가 유지되는 것을 볼 수 있습니다.

슬라이싱

func main() {
    slice1 := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println(slice1[:3])
    fmt.Println(slice1[5:])
    fmt.Println(slice1[:])
    fmt.Println(slice1[2:5])
}
/* output
[1 2 3]
[6 7 8 9 10]
[1 2 3 4 5 6 7 8 9 10]
[3 4 5]
*/

slice[포함부터 : 전까지] 슬라이스를 위와 같은 방법으로 절단할 수 있습니다.

슬라이싱으로 특정 인덱스 제거

func main() {
    slice := []int{1, 2, 3, 4, 5}
    index := 3
    beforeHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
    fmt.Println("slice :", slice)
    fmt.Println("*-*-*-*-* slice *-*-*-*-*")
    fmt.Println(beforeHeader)
    slice = append(slice[:index], slice[index+1:]...)
    fmt.Println()
    resultHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
    fmt.Println("slice :", slice)
    fmt.Println("*-*-*-*-* slice *-*-*-*-*")
    fmt.Println(resultHeader)
}
/* output
slice : [1 2 3 4 5]
*-*-*-*-* slice *-*-*-*-*
&{824634384432 5 5}
>
slice : [1 2 3 5]
*-*-*-*-* slice *-*-*-*-*
&{824634384432 4 5}
*/

슬라이스를 처음 만들었을 때의 capacity가 유지되는 것을 볼 수 있습니다.

copy() 내장함수로 특정 인덱스 제거

func main() {
    slice := []int{1, 2, 3, 4, 5}
    index := 3
    beforeHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
    fmt.Println("slice :", slice)
    fmt.Println("*-*-*-*-* slice *-*-*-*-*")
    fmt.Println(beforeHeader)
    copy(slice[index:], slice[index+1:])
    slice = slice[:len(slice)-1]
    fmt.Println()
    resultHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
    fmt.Println("slice :", slice)
    fmt.Println("*-*-*-*-* slice *-*-*-*-*")
    fmt.Println(resultHeader)
}
/* output
slice : [1 2 3 4 5]
*-*-*-*-* slice *-*-*-*-*
&{824634376240 5 5}
>
slice : [1 2 3 5]
*-*-*-*-* slice *-*-*-*-*
&{824634376240 4 5}
*/

슬라이스를 처음 만들었을 때의 capacity가 유지되는 것을 볼 수 있습니다.

📍 슬라이스 요소 삽입

슬라이스 요소 밀어내어 삽입

func main() {
    slice := []int{1, 2, 3, 4, 5}
    slice = append(slice, 0)
    index := 3
    const location = 2
    for i := len(slice) - location; i >= index; i-- {
        slice[i+1] = slice[i]
    }
    slice[index] = 100
    fmt.Println(slice)
}
/* output
[1 2 3 100 4 5]
*/

길이를 하나 늘리면, 기존 슬라이스의 마지막 인덱스는 len(바뀐 슬라이스)-2에 위치합니다. 슬라이스의 요소들을 index 기준으로 하나씩 뒤로 미루고, index 위치에 새로운 요소를 삽입합니다.

append() 내장함수와 슬라이싱으로 요소 삽입

func main() {
    slice := []int{1, 2, 3, 4, 5}
    index := 3
    slice = append(slice[:index], append([]int{100}, slice[index:]...)...)
    fmt.Println(slice)
}
/* output
[1 2 3 100 4 5]
*/

(미포함)까지인 슬라이스에, append(추가하려는 요소 + (포함)슬라이스)를 덧붙입니다. 단, append() 내에서 임시로 만든 새 슬라이스에 (포함)슬라이스를 덧붙이는 과정에 임시 버퍼를 사용한다는 단점이 존재합니다.

copy() 내장함수와 슬라이싱으로 요소 삽입

func main() {
    slice := []int{1, 2, 3, 4, 5}
    index := 3
    slice = append(slice, 0)
    copy(slice[index+1:], slice[index:])
    slice[index] = 100
    fmt.Println(slice)
}
/* output
[1 2 3 100 4 5]
*/

zero-value 요소를 추가하고, 특정 인덱스부터의 요소를 한 칸씩 밀어냅니다. 이 과정에서 slice[index]의 값은 유지가 되어, slice[index+1]과 동일한 값을 가집니다.

이번 포스트는 슬라이스에 관한 내용이었습니다. 감사합니다.👍

📝 Package

Golang의 코드를 묶는 단위이며, 모든 코드는 패키지에 속해야 합니다.

📌 패키지를 선언하는 방법

📍 package main

package main
>
func main(){...}

main 패키지를 선언할 수 있고, main() 함수를 작성할 수 있습니다.

main 패키지가 가지는 의미는 다음과 같습니다. '프로그램의 시작 패키지' 모든 Golang 프로그램은 main 패키지의 main()함수부터 실행됩니다. (아래에서 다루지만 패키지 초기화 함수와는 다릅니다.)

📍 package other

package other
>
func mainIsNotAllowed(){...}

main 패키지 외에는 main() 함수를 가질 수 없습니다.

📌 패키지를 사용하는 방법

package main
>
import "fmt"
>
func main() {
    fmt.Println("Hello World!!")
}
// Hello World!!

import를 하고 나면 그 패키지가 제공하는 것들(함수, 구조체 등)을 사용할 수 있습니다.

package other
>
import "some-other-package"
>
func OtherFunc() {
    someotherpackage.SOPfunc()
}

'-'를 포함한 import를 하면, 패키지를 사용할 때 '-'를 빼고 사용할 수 있습니다.

package other
>
import "some_other_package"
>
func OtherFunc() {
    some_other_package.SOPfunc()
}

'_'를 포함한 import는 변형없이 사용할 수 있습니다.

package other
>
import (
    "github.com/just/awsome"
    va "github.com/very/awsome"
    na "github.com/not/awsome"
)
>
func OtherFunc() {
    awsome.JustAwsomeFunc()
    va.VeryAwsomeFunc()
    na.NotAwsomeFunc()
}

import한 패키지명이 길고 복잡하거나 겹치는 경우, 위와 같이 alias를 줄 수 있습니다.

package other
>
import    _ "github.com/just/initialize"

특정 패키지의 초기화가 필요한 경우, 위와 같이 직접적으로 사용하지 않아도 특정 패키지를 포함할 수 있습니다.

📍 같은 패키지, 다른 .go 파일

같은 패키지 내의 모든 소스코드는 안의 자원을 공유합니다.

${GOSRC}/example/
    ⊢ ex1.go
    ∣    ⊢ UpperSth()
    ∣    ⨽ lowerSth()
    ⨽ ex2.go
        ⊢ ExportSth()
        ⨽ cannotExportSth()

package example

두 파일 모두 같은 패키지 내에 있습니다. 이 때, ex1.go 의 아무 함수 내에 ex2.go의 모든 함수를 호출할 수 있습니다. (파일이 분리되어 있어도 패키지가 같으면 바로 사용이 가능) 단, 패키지 외부에서 함수를 호출할 때는 함수 이름이 대문자로 시작하는 경우만 호출할 수 있습니다. https://velog.io/@vamos_eon/Golang-function#-the-rule-of-naming-in-golang

📍 패키지 초기화 함수

func init(){...}

init() 함수는 패키지가 import될 때, 호출없이 가장 먼저 실행되는 함수입니다. 패키지 내에서 중복해서 선언도 가능하며, 사용자 임의로 호출은 불가합니다. 프로그램 실행 시, main 함수보다도 먼저 호출됩니다.

init() 함수 실행 순서

• 가장 안쪽 패키지부터
• 파일 정렬 위에서 아래로
• 함수 정렬 위에서 아래로

📝 Module

모듈은 종속성 관리를 위해 Golang이 지원하는 것입니다. 모듈은 패키지의 모음이며, 모듈 파일이 있는 곳이 패키지의 루트 경로가 됩니다. (모듈 : 패키지 = 1 : N)

📌 Module의 초기화

go mod init module_path        # 1
>
go mod init module            # 2
go mod init module/test        # 3

모듈은 위와 같이 초기화할 수 있습니다. 2번의 경우, 빌드하면 실행파일 이름이 module이 되고, root 패키지의 경로는 module/ 입니다. 3번의 경우, 빌드하면 실행파일 이름이 test가 되고, root 패키지의 경로는 module/test/ 입니다.

📌 Module의 구성

>
module module/test
>
go 1.17
>
require (
    github.com/package/example v1.2.0
    ...
)

go.mod 파일을 보면 모듈 이름과 Golang 버전이 표기됩니다. 그리고 외부 패키지를 포함했다면, 외부 패키지의 버전도 함께 표시합니다. indirect가 붙으면 직접적으로 사용하지 않더라도 사용한 외부 패키지에 import 돼 있는 의존성 패키지입니다.

Golang wiki 페이지에 정리된 내용이 있습니다. https://github.com/golang/go/wiki/Modules https://github.com/golang/go/wiki/Modules#can-a-module-consume-a-package-that-has-not-opted-in-to-modules

📍 go.sum ?

위에서 go.mod에 대한 내용을 다뤘습니다. 외부 패키지를 포함하여 빌드를 하고 나면 go.sum 파일이 생성됩니다. go.sum은 외부 패키지의 버전에 대한 checksum을 모아둔 파일입니다. go.sum 파일이 없으면 빌드할 때 다시 생성합니다.

📝 Workspace

Golang 코드가 짜여지고 관리되는 공간입니다. 권장 방법은 링크를 참고하시면 됩니다. https://go.dev/doc/gopath_code#Workspaces

문서와는 조금 다르게, 조금 더 간단하게 사용할 수도 있습니다. /home/user/ 아래에 workspace로 사용할 디렉터리를 만들고 사용할 수 있습니다. /home/user/awsome-project/ (단일 프로그램 또는 프로젝트) /home/user/go-practice/ (여러 프로그램 또는 프로젝트) 위와 같이 여러 workspace를 만들 수도 있습니다.

📌 Workspace 구조

~/awsome-project/
    ⊢ go.mod
    ⊢ go.sum
    ⊢ main.go
    ⊢ package_dir
    ∣    ⊢ hello.go
    ∣    ⨽ bye.go
    ⨽ other_package_dir
        ⊢ other_code1.go
        ⨽ other_code2.go

위와 같이 하나의 프로그램을 위한 workspace를 만들고 관리할 수 있습니다.

~/go-practice/
    ⊢ awsome-project/
    ∣    ⊢ go.mod
    ∣    ⊢ go.sum
    ∣    ⊢ main.go
    ∣    ⊢ package_dir
    ∣    ∣    ⊢ hello.go
    ∣    ∣    ⨽ bye.go
    ∣    ⨽ external_pkg_used_dir
    ∣        ⊢ ext_used1.go
    ∣        ⨽ ext_used2.go
    ⊢ hello-bye
    ∣    ⊢ hello-bye*
    ∣    ⊢ go.mod
    ∣    ⊢ main.go
    ∣    ⨽ hello-bye
    ∣        ⊢ hello.go
    ∣        ⨽ bye.go
    ⨽ calculator
        ⊢ calculator*
        ⊢ go.mod
        ⊢ main.go
        ⨽ arithmetic-operation
            ⊢ sum.go
            ⊢ sub.go
            ⊢ mul.go
            ⊢ div.go
            ⨽ mod.go

위와 같이 여러 개의 프로그램을 위한 workspace를 만들고 관리할 수 있습니다.

📌 Visual Studio Code Golang workspace

Vscode 를 사용하시는 분이라면 연습용 디렉터리 내에 여러 프로그램을 작성하고 테스트하고 싶을 겁니다. 하지만 Vscode의 Explorer Folder 내에 같은 이름의 모듈이 존재하면 빨갛게 표시됩니다.

이는 테스트할 때마다 불편하게 합니다. (빌드도 정상적으로 되는데 괜히 마음 불편한..) go mod init main 명령어로 간단하게 모듈 이름 상관없이 짓고 빌드하고 싶을 때 말입니다. go.work를 작성하면 이런 불편이 사라집니다.

📍 go.work 작성

~/go-practice/go.work

go 1.17
>
directory (
    ./awsome-project
    ./hello-bye
    ./calculator
)

go.work file을 생성하기만 해도 모듈 이름 중복에 대한 문제는 해결됩니다. 다만 workspace를 지정해서 사용하려면 위와 같이 디렉터리 별로 설정할 수도 있습니다.

vscode go workspace 관련 이슈 : https://github.com/golang/go/issues/45713

📝 직접 만들고 사용해보자

1. main 패키지 작성

📍 workspace 세팅 및 main.go 작성

${GOSRC}/example/
    ⨽ main.go

package main
>
func main(){}

2. 모듈 초기화

📍 모듈명 설정

~/${GOSRC}/example$ go mod init local_package

3. 로컬 패키지 생성

📍 패키지 파일 생성 및 작성

${GOSRC}/example/
    ⊢ go.mod
    ⊢ main.go
    ⨽ something
        ⊢ ex1.go
        ⨽ ex2.go

ex1.go

package something
>
import "fmt"
>
type CaseStruct struct {
    UpperValue string
    lowerValue string
}
>
func UpperSth(){
    fmt.Println("UpperSth() Called")
}
>
func lowerSth(){
    fmt.Println("lowerSth() Called")
}

ex2.go

package something
>
import "fmt"
>
func ExportSth(){
    fmt.Println("ExportSth() Called")
}
>
func cannotExportSth(){
    fmt.Println("cannotExportSth() Called")
}

4. 로컬 패키지 사용

📍 main.go 추가 작성

package main
>
import "local_package/something"
>
func main() {
    // added
    sth_case := something.CaseStruct{}
    sth_case.UpperValue = "Upper value."
    fmt.Println("sth_case's UpperValue:", sth_case.UpperValue)
    something.UpperSth()
}

📍 빌드 하기

~/${GOSRC}/example$ go build

~/${GOSRC}/example$ ls -alF

# output
total 1748
drwxrwxr-x 3 eon eon    4096 Mar 16 12:04 ./
drwxrwxr-x 4 eon eon    4096 Mar 16 11:57 ../
-rw-rw-r-- 1 eon eon      30 Mar 16 12:01 go.mod
-rwxrwxr-x 1 eon eon 1766536 Mar 16 12:04 local_package*
-rw-rw-r-- 1 eon eon      86 Mar 16 12:05 main.go
drwxrwxr-x 2 eon eon    4096 Mar 16 12:05 something/

실행 파일 이름 지정하여 빌드

~/${GOSRC}/example$ go build -o bin-name

📍 실행하기

~/${GOSRC}/example$ ./local_package

# output
sth_case's UpperValue: Upper value.
UpperSth() Called

5. 동일 패키지 함수 사용

📍 ex1.go에서 ex2.go 함수 호출하기

ex1.go

package something
>
import "fmt"
>
func UpperSth() {
    fmt.Println("UpperSth() Called")
    lowerSth()
    ExportSth()
    cannotExportSth()
}
>
func lowerSth() {
    fmt.Println("lowerSth() Called")
}

빌드 후 실행 결과

UpperSth() Called
lowerSth() Called
ExportSth() Called
cannotExportSth() Called

6. 외부 패키지 사용

📍 외부 패키지 import 및 사용

ex2.go

package something
>
import (
    "fmt"
>
    "github.com/google/uuid"
)
>
func ExportSth() {
    fmt.Println("ExportSth() Called")
}
>
func cannotExportSth() {
    fmt.Println("cannotExportSth() Called")
}
>
// added
func ExternalPackage() {
    fmt.Println(uuid.New())
}

main.go

package main
>
import "local_package/something"
>
func main() {
    // function call edited
    something.ExternalPackage()
}

📍 외부 패키지 다운로드 및 초기화

(1) 모듈 정리(다운로드, 종속관계 정리) 후 빌드

go mod tidy
go build

(2) 다운로드만 하고 빌드

go get github.com/google/uuid
go build

${GOSRC}/example/
    ⊢ go.mod
    ⊢ go.sum
    ⊢ main.go
    ⨽ something
        ⊢ ex1.go
        ⨽ ex2.go

• go.sum

  • 위의 두 경우 (1), (2) 모두 go.sum 파일이 생성되며 checksum을 기록합니다.

• 모듈 정리를 안할 경우

  • go.mod

    module local_package
    

  go 1.17

  require github.com/google/uuid v1.3.0 // indirect ``` 직접 import하는 외부 패키지임에도 불구하고 위와 같이 indirect 문구가 붙으며 사용되지 않은, 간접 dependency로써 존재하게 됩니다. 따라서 모듈을 정리해주는 과정이 필요합니다.

• 외부 패키지 종속성이 변경되었다면 빌드 전에 go mod tidy 명령어를 꼭 실행하는 것을 권장*합니다. go mod tidy 명령어 실행 후에는 // indirect 문구는 사라집니다.

(3) 빌드 후 실행 결과

c1c36290-2516-4e2a-ad60-696e90ec6328

7. 패키지 초기화 함수 init() 사용

📍 init() 동작 순서 테스트

main.go

package main
>
import "local_package/something"
>
func main() {
    something.ExternalPackage()
}
>
// function added
func init(){
    fmt.Println("init called in main package")
}

ex1.go

package something
>
import "fmt"
>
func init() {
    fmt.Println("ex1.go init 1")
}
>
func UpperSth() {
    fmt.Println("UpperSth() Called")
    lowerSth()
    ExportSth()
    cannotExportSth()
}
>
func lowerSth() {
    fmt.Println("lowerSth() Called")
}
>
func init() {
    fmt.Println("ex1.go init 2")
}

ex2.go

package something
>
import (
    "fmt"
>
    "github.com/google/uuid"
)
>
func ExportSth() {
    fmt.Println("ExportSth() Called")
}
>
func cannotExportSth() {
    fmt.Println("cannotExportSth() Called")
}
>
func init() {
    fmt.Println("ex2.go init 1")
}
>
func init() {
    fmt.Println("ex2.go init 2")
}
>
func ExternalPackage() {
    fmt.Println(uuid.New())
}

빌드 후 실행 결과

ex1.go init
ex1.go init2
ex2.go init
ex2.go init2
init called in main package
f4887be3-d7db-4b3e-9760-51a1b676cf96

📍 init() 내에서 전역변수 설정

main.go

package main
>
import (
    "fmt"
    "local_package/something"
)
>
func main() {
    fmt.Println("final Cnt :", something.Cnt)
}
>
func init() {
    something.Cnt = 1
}

ex1.go

package something
>
import (
    "fmt"
)
>
func init() {
    fmt.Println("ex1.go init 1")
    Cnt = 10
}
>
func UpperSth() {
    fmt.Println("UpperSth() Called")
    lowerSth()
    ExportSth()
    cannotExportSth()
}
>
func lowerSth() {
    fmt.Println("lowerSth() Called")
}

ex2.go

package something
>
import (
    "fmt"
)
>
var Cnt int8
>
func ExportSth() {
    fmt.Println("ExportSth() Called")
}
>
func cannotExportSth() {
    fmt.Println("cannotExportSth() Called")
}
>
func init() {
    fmt.Println("ex2.go init 1")
    Cnt = 20
}

빌드 후 실행 결과

ex1.go init 1
ex2.go init 1
final Cnt : 1

이상 패키지 / 모듈 / 워크스페이스에 대한 내용이었습니다. 감사합니다.👍

📝 문자열 (string)

문자의 집합이자 문자들로 이루어진 배열입니다. 프로그래밍을 처음 시작할 때 출력하는 "Hello World!!" 또한 문자열입니다. 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!', '!' 위의 문자들이 모여, 하나의 문자열을 구성한 것입니다. golang의 자료형 중, string과 rune으로 표현할 수 있습니다.

📌 유니코드

ASCII code (0~255; 1byte)로는 표현할 수 있는 문자에 한계가 있었습니다. https://www.ascii-code.com/ 그래서 개발된 게 유니코드입니다. 유니코드는 국제 표준이며, 여러 가지 종류가 있습니다. (utf-1, utf-7, utf-8, utf-EBCDIC, utf-16, utf-32)

• utf-16
  • 문자 하나를 표현하는 데에 2 바이트가 필요합니다.
  • 장점 : 모든 문자를 2바이트로 표현 가능합니다.
  • 단점 : 1바이트로 표현 가능한 문자도 2바이트를 차지합니다.
• utf-8 (golang에서 사용되는 문자 인코딩 방식)
  • 문자 하나를 표현하는 데에 1 ~ 4 바이트가 필요합니다.
  • 장점 : ASCII 1바이트 문자들로 구성을 많이 할수록 메모리를 적게 사용합니다.
  • 단점 : 그 외의 문자들의 사용이 많아질수록 메모리 사용량이 커집니다.

📍 utf-8

인터넷 공간의 데이터 중 80%를 영어와 숫자가 차지한다고 합니다. 이러한 점에서 utf-8은 매우 효율적인 인코딩 방식이라고 볼 수 있습니다.

모든 문자에 대하여 같은 메모리가 아닌, 모든 문자에 각각 필요로 하는 만큼 메모리를 할당합니다.

1바이트 : ASCII 0~127 총 128개 2바이트 : 그리스어, 키릴어, 콥트어, 아르메니아어, 히브리어, 아랍어, 시리아어, 타나 문자, 분음 부호 결합 총 1920개 3바이트 : 대부분의 중국어, 일본어, 한국어 4바이트 : 다른 평면 문자, 일반적이지 않은 한중일어, 수학 기호, 이모지 등이 포함

한글의 자음, 모음, 받침을 합쳐서 3바이트인 것인가하는 추측은 하지 말아야 합니다. 전혀 그렇지 않고, 그저 국제 표준일 뿐입니다.

📝 문자열의 활용

📌 문자열의 선언

var str string
var str string = "Hello World!!"
var str string = `Hello World!!`
var str string = `
Hello 
World!!
`

문자열의 선언은 위의 방법 네 가지가 있습니다.

1) 초기화 없이 선언합니다. 이 때, 값은 "" 빈 문자열이 됩니다. 2) Hello World!!로 초기화를 합니다. 동일한 줄에서 큰 따옴표를 닫아야 합니다. 3) ` `로 초기화합니다. 4) 3)에서 초기화한 값에 개행을 포함하여 초기화합니다. 개행은 마지막 줄을 제외한 모든 줄에 포함돼 있습니다.

📌 문자열의 순회

문자열은 반복문 제어를 통해 그 안의 문자들을 순회할 수 있습니다. 방법은 아래와 같습니다.

📍 len()

golang의 기본 built-in 함수입니다. string 타입을 넣으면 string 변수의 바이트 길이가 반환됩니다. builtin.go에서 len()에 대하여 다음과 같은 설명을 포함합니다.

// The len built-in function returns the length of v, according to its type:
//    Array: the number of elements in v.
//    Pointer to array: the number of elements in *v (even if v is nil).
//    Slice, or map: the number of elements in v; if v is nil, len(v) is zero.
//    String: the number of bytes in v.
//    Channel: the number of elements queued (unread) in the channel buffer;
//             if v is nil, len(v) is zero.
// For some arguments, such as a string literal or a simple array expression, the
// result can be a constant. See the Go language specification's "Length and
// capacity" section for details.
func len(v Type) int

📍 C-like for문 순회 (영어)

C-like 순회는 바이트 단위로 순회합니다.

var str string = "Hello Wolrd!!"
for i := 0; i < len(str); i++ {
    fmt.Printf("Type : %T, Character : %c, Code : %d\n", str[i], str[i], str[i])
}
/* OUTPUT
Type : uint8, Character : H, Code : 72
Type : uint8, Character : e, Code : 101
Type : uint8, Character : l, Code : 108
Type : uint8, Character : l, Code : 108
Type : uint8, Character : o, Code : 111
Type : uint8, Character :  , Code : 32
Type : uint8, Character : W, Code : 87
Type : uint8, Character : o, Code : 111
Type : uint8, Character : l, Code : 108
Type : uint8, Character : r, Code : 114
Type : uint8, Character : d, Code : 100
Type : uint8, Character : !, Code : 33
Type : uint8, Character : !, Code : 33
*/

string은 문자들의 배열입니다. 그리고 C-like for문은 바이트 단위로 순회합니다. "Hello World!!" 안의 모든 문자는 각각 1바이트입니다. 따라서 위와 같이 for문 순회를 했을 때, 아무런 문제 없이 원했던 결과를 얻을 수 있었습니다.

📍 C-like for문 순회 (한글)

var 스트링 string = "헬로 월드!!"
for i := 0; i < len(스트링); i++ {
    fmt.Printf("Type : %T, Character : %c, Code : %d\n", 스트링[i], 스트링[i], 스트링[i])
}
/* OUTPUT
Type : uint8, Character : í, Code : 237
Type : uint8, Character : , Code : 151
Type : uint8, Character : ¬, Code : 172
Type : uint8, Character : ë, Code : 235
Type : uint8, Character : ¡, Code : 161
Type : uint8, Character : , Code : 156
Type : uint8, Character :  , Code : 32
Type : uint8, Character : ì, Code : 236
Type : uint8, Character : ode : 155
Type : uint8, Character : , Code : 148
Type : uint8, Character : ë, Code : 235
Type : uint8, Character : , Code : 147
Type : uint8, Character : , Code : 156
Type : uint8, Character : !, Code : 33
Type : uint8, Character : !, Code : 33
*/

앞서 설명한 바와 같이, utf-8에서 한글은 글자 하나 당 3바이트로 구성됩니다. C-like for문 순회는 len()을 사용해야 하는데, len()은 바이트 길이를 반환합니다. 그리고 C-like for문은 바이트 길이만큼 순회를 하기 때문에 한글 글자 하나를 구성하는 3개 바이트 중 하나씩만 읽을 수 있습니다. 때문에 바이트 순회로는 한글을 온전히 읽지 못합니다. 위의 결과에서 사이에 공백과 맨 아래 느낌표를 제외하고 나머지 부분에서 3개 바이트 당 한글 글자 1개라는 것을 유추할 수 있습니다.

📍 for-range 순회 (영어)

var str string = "Hello Wolrd!!"
for _, v := range str {
    fmt.Printf("Type : %T, Character : %c, Code : %d\n", v, v, v)
}
/* OUTPUT
Type : int32, Character : H, Code : 72
Type : int32, Character : e, Code : 101
Type : int32, Character : l, Code : 108
Type : int32, Character : l, Code : 108
Type : int32, Character : o, Code : 111
Type : int32, Character :  , Code : 32
Type : int32, Character : W, Code : 87
Type : int32, Character : o, Code : 111
Type : int32, Character : l, Code : 108
Type : int32, Character : r, Code : 114
Type : int32, Character : d, Code : 100
Type : int32, Character : !, Code : 33
Type : int32, Character : !, Code : 33
*/

영어는 무리 없이 range로 순회되는 모습을 볼 수 있습니다. 단, 한 가지 차이점이 있다면 Type이 int32로 출력되는 모습을 볼 수 있습니다.

📍 for-range : string -> rune

range에 string을 넣으면 rune 타입으로 변환하여 순회를 하기 때문에 그렇습니다. golang for-range의 특징이라고 보시면 됩니다. rune타입은 string처럼 바이트 단위로 쪼개지 않고도 문자 하나를 온전히 표현하는 4바이트의 크기를 가지고 있기 때문에 온전히 모든 문자의 표현이 가능합니다.

📍 for-range 순회 (한글)

var 스트링 string = "헬로 월드!!"
for _, v := range 스트링 {
    fmt.Printf("Type : %T, Character : %c, Code : %d\n", v, v, v)
}
/* OUTPUT
Type : int32, Character : 헬, Code : 54764
Type : int32, Character : 로, Code : 47196
Type : int32, Character :  , Code : 32
Type : int32, Character : 월, Code : 50900
Type : int32, Character : 드, Code : 46300
Type : int32, Character : !, Code : 33
Type : int32, Character : !, Code : 33
*/

for-range로 순회를 했더니 한글도 문제없이 출력되는 모습을 확인할 수 있습니다.

📍 C-like for문 순회 (한글); []rune

var 스트링 string = "헬로 월드!!"
var 룬슬라이스 []rune = []rune(스트링)
for i := 0; i < len(룬슬라이스); i++ {
    fmt.Printf("Type : %T, Character : %c, Code : %d\n", 룬슬라이스[i], 룬슬라이스[i], 룬슬라이스[i])
}
/* OUTPUT
Type : int32, Character : 헬, Code : 54764
Type : int32, Character : 로, Code : 47196
Type : int32, Character :  , Code : 32
Type : int32, Character : 월, Code : 50900
Type : int32, Character : 드, Code : 46300
Type : int32, Character : !, Code : 33
Type : int32, Character : !, Code : 33
*/

len()은 위에 써있듯이 슬라이스에 대해서는 요소의 개수를 반환합니다. 따라서 []rune의 요소인 rune 타입의 값들을 출력합니다.

📌 문자열의 연산

문자열은 연산이 가능합니다. 단, 사칙연산 중에는 덧셈만 가능하고, 대입 연산이나 비교 연산이 가능합니다.

📍 문자열의 연산 : 덧셈 연산

덧셈 연산이 가능합니다.

var str1 string = "Hello"
var str2 string = "World"
var strMerge string = str1 + " " + str2 + "!!"
fmt.Println(strMerge)
// Hello World!!

위와 같이 "Hello"라는 문자열과 "World!!"라는 문자열을 하나의 문자열로 합치는 게 가능합니다.

📍 문자열의 연산 : 대입 연산

대입 연산이 가능합니다.

var str1 string = "Hello"
var str2 string = ""
str2 = str1
fmt.Println(str2)
// Hello

str2는 빈 문자열로 초기화를 했다가, str1을 대입했습니다. str2의 값으로 Hello가 출력된 것을 볼 수 있습니다. 문자로 이루어진 배열이라 했지만 길이가 서로 다른 문자열끼리도 대입 연산이 가능합니다.

📍 문자열의 연산 : 비교 연산

문자열은 문자들로 이루어진 배열입니다. 각각의 요소는 문자이며, golang은 utf-8을 지원하고 utf-8은 모든 문자를 4byte 내로 표현할 수 있습니다. golang에서 문자는 rune 타입이며 rune 타입은 utf-8의 모든 문자를 표현할 수 있는 4바이트 크기의 int32의 별칭 타입입니다. 그래서 문자 코드는 정수로 표현할 수 있습니다. 문자열의 비교 연산은 문자 코드의 비교입니다.

var str1 string = "ABCDE"
var str2 string = "abcde"
if str1 > str2 {
    fmt.Println("str1 > str2")
} else if str1 < str2 {
    fmt.Println("str1 < str2")
}
// str1 < str2

문자열의 비교 연산은 각 문자의 문자 코드 단위로 이루어집니다. A와 a를 비교하고, B와 b, C와 c 순으로 비교합니다. 조건문 str1 > str2의 비교를 하면, 맨 처음 비교하게 되는 A와 a의 비교에서 이미 조건을 만족하지 않기 때문에 뒤에 오는 문자의 비교는 하지 않습니다. 바로 다음 조건문으로 넘어가, 모든 문자열 요소들에 대해 조건을 만족하는지 확인합니다.

📝 문자열 덧셈, 대입 연산 시, 메모리의 동작

문자열은 문자의 배열이라고 했습니다. golang에서는 배열의 크기가 한 번 정해지면 변경이 불가합니다. 문자열의 덧셈 연산이 가능하다고 해서 한 번 정한 크기를 변경할 수 있는 것은 아닙니다. 내부 동작에서 메모리 할당을 알아서 해주니 사용자는 신경 쓸 필요가 없습니다. 다만, 알고는 있어야 메모리 사용량을 줄일 수 있을 것입니다.

📌 문자열 변수의 실제 메모리 크기

string 변수 str를 선언하고 초기화를 하면 실제로 할당되는 메모리의 크기는 다음과 같습니다.

len(str)+ unsafe.Sizeof(reflect.StringHeader{}) 문자열 바이트 길이 + StringHeader의 크기

📍 StringHeader

문자열에 대한 정보를 담고 있습니다.

type StringHeader struct {
    Data uintptr
    Len  int
}

Data : 실제 값이 저장된 메모리 주소 Len : 문자열의 길이

📌 문자열의 덧셈, 대입 연산

var str1 string = "Hello"
var str2 string = "World"
str2 += str1
var str3 string = str2
strHeader1 := (*reflect.StringHeader)(unsafe.Pointer(&str1))
strHeader2 := (*reflect.StringHeader)(unsafe.Pointer(&str2))
strHeader3 := (*reflect.StringHeader)(unsafe.Pointer(&str3))
fmt.Println("Value of strHeader1 :", strHeader1)
fmt.Println("Value of strHeader2 :", strHeader2)
fmt.Println("Value of strHeader3 :", strHeader3)
fmt.Printf("Pointer value of strHeader1 : %p\n", strHeader1)
fmt.Printf("Pointer value of strHeader2 : %p\n", strHeader2)
fmt.Printf("Pointer value of strHeader3 : %p\n", strHeader3)
>
/* OUTPUT
Value of strHeader1 : &{4807070 5}
Value of strHeader2 : &{824634400768 10}
Value of strHeader3 : &{824634400768 10}
Pointer value of strHeader1 : 0xc00008a210
Pointer value of strHeader2 : 0xc00008a220
Pointer value of strHeader3 : 0xc00008a230
*/

위의 Pointer value 결과를 보면, 각 str1, str2, str3의 주소값은 모두 다른 것을 볼 수 있으며, 그 차이가 16바이트인 것을 확인할 수 있습니다. 위 그림과 같이 str1, str2, str3 변수가 선언되고 초기화될 때마다 16바이트씩 메모리가 할당된 것을 볼 수 있습니다. 문자열을 더하든, 대입하든 string 변수 자체는 16바이트 크기의 StringHeader 를 가지기 때문에 이러한 연산이 가능합니다. 단, 유동적으로 string 변수의 크기를 줄였다가 늘렸다가 할 수 있는 것이 아니기 때문에 연산을 할 때마다 새로 메모리를 할당한다는 단점이 있습니다.

📝 문자열 일부 변경이 가능할까?

string 타입만으로는 불가능합니다. 문자열 일부 변경은 타입 변환을 통해서 수행가능합니다.

📌 string to rune (or byte), rune (or byte) to string

var str string = "a"
var slice []rune = []rune(str)
// var slice []byte = []byte(str)

문자열의 일부를 변경하기 위해서는 먼저 []rune or []byte 타입으로 변환해야 합니다. 위와 같이 문자 1개로만 이루어진 string 변수도 마찬가지입니다.

str = string(slice)

[]run 타입의 변수를 string으로 변환하기 위해서는 위와 같이 작성하면 됩니다.

📌 슬라이스 변수의 실제 메모리 크기

slice 변수 slice를 선언하고 초기화를 하면 실제로 할당되는 메모리의 크기는 다음과 같습니다. len(slice)+ unsafe.Sizeof(reflect.SliceHeader{}) 슬라이스 바이트 길이 + SliceHeader의 크기

📍 SliceHeader

슬라이스에 대한 정보를 담고 있습니다.

type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

Data : 실제 값이 저장된 메모리 주소 Len : 슬라이스의 길이 Cap : 슬라이스의 용량 (슬라이스의 길이를 늘릴 경우, Capacity를 넘지 않으면 그냥 붙여서 늘리고, Capacity를 넘어서면 새로운 슬라이스를 기존의 용량의 두 배로 만듭니다.)

📌 문자열 일부 변경하기

var str string = "hello world"
var runeSlice []rune = []rune(str)
fmt.Println("Original string value :", str)
strHeader := (*reflect.StringHeader)(unsafe.Pointer(&str))
fmt.Println("Value of strHeader :", strHeader)
fmt.Printf("Pointer value of strHeader : %p\n\n", strHeader)
for i, v := range runeSlice {
    if v == 'o' {
        runeSlice[i] = '!'
    }
}
sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&runeSlice))
fmt.Println("Value of sliceHeader :", sliceHeader)
fmt.Println("Size of Slice :", unsafe.Sizeof(runeSlice))
fmt.Println()
str = string(runeSlice)
fmt.Println("Changed string value :", str)
fmt.Println("Value of strHeader :", strHeader)
fmt.Printf("Pointer value of strHeader : %p\n", strHeader)
/* OUTPUT
Original string value : hello world
Value of strHeader : &{4815093 11}
Pointer value of strHeader : 0xc000010240
>
Value of sliceHeader : &{824633811136 11 12}
Size of Slice : 24
>
Changed string value : hell! w!rld
Value of strHeader : &{824633819312 11}
Pointer value of strHeader : 0xc000010240
*/

string타입의 변수 str을 []rune타입으로 변환한 뒤, 순회를 합니다. 순회 중, 알파벳 o를 만나면 해당[]rune에 !로 값을 바꾸도록 했습니다. 다시 []rune타입을 string으로 변환 후에 출력하니, 값이 바뀐 것을 확인할 수 있었습니다.

이상 문자열에 대한 내용이었습니다. 감사합니다.👍

이번 포스트는 포인터에 대한 내용입니다.

📝 포인터란?

'메모리 주소를 가리키는 것' 을 의미합니다. 변수를 선언하면 메모리 영역에 공간이 할당되는데, 그 메모리 영역의 주소를 가리키는 것을 포인터라고 합니다. 포인터 변수는 메모리 주소를 값으로 가집니다.

📝 인스턴스란?

메모리의 실체를 말합니다. 우리가 변수를 선언하면 변수의 자료형 크기만큼 메모리가 할당됩니다. 인스턴스는, 그 할당된 메모리의 실체를 가리키는 말입니다.

📝 포인터는 왜 사용할까?

포인터를 사용하면 메모리 영역에 직접 접근하여 인스턴스를 조작할 수 있습니다. 어디서든 인스턴스에 접근할 수 있어, 메모리를 중복으로 할당하는 경우를 줄이고 불필요한 메모리 낭비를 막을 수 있습니다.

• 퍼포먼스를 신경쓸 때
  • 포인터는 퍼포먼스를 고려하지 않을 땐 사용할 이유가 없다. 물론, 포인터타입을 반환하는 함수를 사용할 땐 사용할 수 밖에 없다.
  • 인스턴스를 메모리에 통째로 복사해서 사용할 때, 인스턴스의 주소만 넘김으로써 메모리 낭비를 줄일 때 사용한다.

📝 포인터

📌 포인터의 초기화

var p1 *int
>
// var a int
var p1 *int = &a
>
p1 := &a
>
// type Sth struct {}
p1 := &Sth{}
>
p1 := new(int)

위의 선언은 각기 다른 포인터 변수의 선언 방법을 나타낸다.

• var p1 *int : pointer int형의 변수 p1을 선언한다. 이때, p1의 값은 nil이다. (아래 내용 참조)
• var p1 *int = &a, p1 := &a : pointer int형의 변수 p1을 선언하고 &a로 초기화한다. &a는 변수 a의 주소값이다.
• p1 := &Sth{} : pointer Sth{}형의 변수 p1을 선언한다.
• p1 := new(int) : pointer int형의 변수 p1을 선언한다. new(Type)은 pointer Type의 zero value를 반환한다.

📌 포인터 변수의 기본값은 nil

var pt *int
fmt.Println(pt)
// <nil>

• 초기화를 하지 않고 zero value 상태의 포인터 변수를 출력하면 <nil>이 출력된다.
• nil은 출력할 때 항상 <, >을 포함한다.
• 포인터 변수의 값이 nil이라는 것은 가리키고 있는 인스턴스가 없음을 말한다.

📍 nil이란?

builtin.go

// nil is a predeclared identifier representing the zero value for a
// pointer, channel, func, interface, map, or slice type.
var nil Type // Type must be a pointer, channel, func, interface, map, or slice type

nil은 pointer, channel, func, interface, map, or slice type의 zero value(기본값)이다. (예 : int의 zero value는 0이다.)

📌 포인터의 사용

📍 예시 1

var a int = 10
var b int = 20
>
var p1 *int = &a
var p2 *int = &b
>
fmt.Printf("variable a : %d, address : %p\n", a, p1)
fmt.Printf("variable b : %d, address : %p\n", b, p2)
fmt.Printf("variable p1 is pointing a : %d\n", *p1)
>
// ***** result of the output *****
// variable a : 10, address : 0xc0000a8000
// variable b : 20, address : 0xc0000a8008
// variable p1 is pointing a : 10

• 변수 a와 b를 int형으로 선언하고, 각각 10, 20으로 초기화한다.
• 변수 p1과 p2를 *int형(pointer int형)으로 선언하고, 각각 a와 b의 주소값으로 초기화한다.
• 초기화한 값들을 출력하여 확인한다. 여기서 a와 b의 주소값의 차이가 8만큼 나는 것을 확인할 수 있다. 둘 다 int형 변수이고, 64비트 OS라서 int형이 8byte의 사이즈를 가진다. a의 메모리를 할당하고 가장 빠른 메모리 영역이 8만큼 뒤의 영역이고, b는 a의 바로 뒤에 메모리가 할당되었다는 것을 알 수 있다.
• 포인터 자료형의 출력은 %p로 할 수 있다.
• *p1으로 p1이 가리키는 인스턴스의 값을 나타내고, 출력하여 값을 확인할 수 있다. 여기서 p1은 a의 주소값을 가지고 있고 해당 주소값을 * (pointer)로 가리켜, 인스턴스의 값을 나타낸다.

📍 예시 2

package main
>
import (
    "fmt"
    "unsafe"
)
>
type pTest struct {
    pStr string
    pInt int
}
>
func setStr(getStruct *pTest) {
    getStruct.pStr = "struct pTest's byte size :"
}
>
func setInt(getStruct *pTest) {
    getStruct.pInt = int(unsafe.Sizeof(pTest{}))
}
>
func main() {
    var example pTest
>
    setStr(&example)
    setInt(&example)
>
    fmt.Println(example)
}
// {struct pTest's byte size : 24}

위와 같이 다른 서로 다른 함수에서 같은 구조체 인스턴스인 example에 접근하여 요소를 조작했다. 출력 결과를 통해, 같은 인스턴스에 대하여 조작했다는 것을 확인할 수 있다.

📍 예시 3

package main
>
import (
    "fmt"
    "sync"
)
>
type pTest struct {
    pStr string
    pInt int
}
>
func addStr(wg *sync.WaitGroup, getStruct *pTest, str rune) {
    getStruct.pStr = getStruct.pStr + string(97+str)
    defer wg.Done()
}
>
func addInt(wg *sync.WaitGroup, getStruct *pTest, num int) {
    getStruct.pInt += num
    defer wg.Done()
}
>
func printStruct(wg *sync.WaitGroup, getStruct *pTest, num int) {
    fmt.Println(getStruct)
    defer wg.Done()
}
>
func main() {
    var example pTest
    defer fmt.Println("===== Finished =====")
    wg := sync.WaitGroup{}
    defer wg.Wait()
    for i := 0; i <= 10; i++ {
        wg.Add(1)
        go addStr(&wg, &example, rune(i))
        wg.Add(1)
        go addInt(&wg, &example, i)
        wg.Add(1)
        go printStruct(&wg, &example, i)
    }
}

위의 코드를 실행하면 실행할 때마다 결과가 바뀐다. goroutine(golang의 멀티 쓰레드)을 사용한 것인데, golang에서 동시성 프로그래밍을 할 때 사용한다. (os 쓰레드보다 훨씬 가볍게 동작하는 가상 쓰레드이며, 비동기(asynchronously) 실행을 한다.) 아무튼 위와 같이 사용하면 인스턴스를 사용자가 예측 불가하게 무작위로 조작하기 때문에, 동시에 같은 인스턴스에 접근 및 조작하는 로직을 구현할 때는 주의해야 한다.

📝 스택 & 힙 메모리

📌 스택 메모리

스택 메모리는 함수 호출 시에 함수에 자동으로 할당되는 메모리를 말합니다. 함수가 끝날 때 자동으로 정리되는 메모리입니다.

📌 힙 메모리

힙 메모리는 프로그래머가 수동으로 할당하는 메모리를 말합니다. 수동으로 할당하기 때문에 프로그래머가 수동으로 해제해야 하는 메모리입니다. 그렇지 않으면 메모리에서 자동으로 해제되지 않기 때문에 메모리 낭비로 이어집니다.

📌 메모리 관리는 어떻게 해야 할까?

Golang은 스택이든 힙이든 가비지 컬렉터가 알아서 메모리를 정리해줍니다. 때문에 사용자가 고심하며 메모리 할당에 대해 고민할 필요가 없습니다. 물론, 나중에 무거운 기능을 수행하는 코드를 작성할 때에는 고려해야만 합니다.

예를 들어, file을 읽어오는데 그 file의 크기를 이미 알고 있다면 그에 맞게 메모리를 할당해, 힙 영역에 메모리가 생기지 않게 하는 것이 좋습니다.

📍 힙은 비용이 비싸다?

힙은 스택에 비해 비용이 비쌉니다. 비용이 비싸다는 것은, "힙은 엑세스와 메모리 해제가 스택에 비해 느리다" 라는 것을 말합니다. 여러 관점에서, 힙에 메모리가 할당되는 것은 지양하는 것이 좋습니다.

📌 탈출 분석

탈출 분석은 함수에서 함수로 인스턴스가 탈출하는지 여부를 분석하는 것입니다. 탈출 분석을 통해 탈출하는 인스턴스의 메모리를 스택이 아닌 힙에 할당합니다. 인스턴스가 함수 외부에서도 사용이 된다면 스택 메모리에 할당하는 것은 적절하지 않기 때문입니다.

📍 힙 메모리 할당 확인

아래의 명령어로 .go 파일을 컴파일하면 컴파일 과정에서 힙 메모리의 사용 여부를 확인할 수 있습니다.

go build -gcflags '-m -l'
go build -gcflags '-m'
go build -gcflags '-m=2'

• '-m -l' : 옵티마이징 레벨을 1로 하고, 인라이닝을 없앱니다.
• '-m' : 옵티마이징 레벨을 1로 합니다.
• '-m=2' : 옵티마이징 레벨을 2로 합니다. (보다 상세하게 나옵니다.)

컴파일 옵션은 아래의 명령어로 확인할 수 있습니다.

go tool compile -help

📍 예시

package main
>
func get(p *int) *int {
    example := *p
    return &example
}
>
func main() {
    var a int
    var p *int = &a
    a = 20
    _ = get(p)
}

eon@vamos-eon:~/goprojects/pointer$ go build -gcflags '-m -l'
# main
./pointer.go:5:10: p does not escape
./pointer.go:6:2: moved to heap: example
./pointer.go:16:13: ... argument does not escape
./pointer.go:16:14: "" escapes to heap

위와 같이 get()함수에서 변수 example을 할당했으나, example의 인스턴스를 get()함수 외부로 반환하여 스택이 아닌 힙에 메모리가 할당된 것을 확인할 수 있다.

이번 포스트는 포인터에 대한 내용이었습니다. 감사합니다.👍

이번 포스트에서는 구조체에 대해 다루겠습니다.

📝 구조체란?

Structure 라고 한다.

• 여러 필드를 묶어둔 타입

위의 그림을 보면, 직원 한 명을 특정하기 위해 총 8개의 속성이 사용됐습니다. 구조체를 어떻게 사용하는지 아직은 모르지만, 저 속성들 모두 사용해야 한다면 아래와 같이 사용할 수 있습니다.

var Employee1_Name string = "Eon"
var Employee1_Rank string = "staff"
var Employee1_No uint32 = 200803
var Employee1_Department string = "Development"
var Employee1_Vacation int8 = 15
var Employee1_AnnualIncome uint64 = 50000000
var Employee1_Email string = "vamos_eon@email.com"
var Employee1_InCharge string = "backend"

정말 복잡합니다. 최대한 가독성 좋게 만들어 보려고 해도 표현할 직원이 몇이나 더 생길지도 모르고, 사용할 때마다 사이드 이펙트를 고려해야 합니다. 가령, Employee1의 이름을 다른 사람으로 바꾼다면 그건 전혀 의미가 없는 정보가 됩니다. 따라서 무엇 하나 바꾼다면 그게 다른 속성에 영향을 끼치는지 확인 후에 전부 함께 바꿔야 합니다. 앞에 Employee1_를 항상 써가면서 말입니다.

구조체를 사용하면 위의 그림처럼, 직원마다 다른 정보를 넣어 관리하기 편리해집니다.

📝 구조체

구조체로 표현하면 값을 바꿀 때도, 새로 값을 넣을 때도 편하게 넣을 수 있습니다.

📌 구조체의 선언

type 타입명 struct {
    필드명 타입
     ...
    필드명 타입
}

작성할 구조체의 이름을 정합니다. 구조체의 이름은 변수를 선언할 때 작성하는 타입과 비슷하게 작성할 수 있습니다.

위의 사용법을 바탕으로 직원에 대한 구조체를 작성해보겠습니다.

type Employee struct {
    Name        string
    Rank        string
    No        uint32
    Department    string
    Vacation    int8
    AnnualIncome    uint64
    Email        string
    InCharge    string
}

구조체를 작성했습니다.

📌 구조체 변수의 선언

var 구조체변수명 구조체타입명

이어서, 구조체 변수를 선언하겠습니다.

var employee Employee

이제 구조체 변수 employee은 구조체 Employee가 가지는 필드를 모두 사용할 수 있습니다.

📌 구조체 변수의 초기화

위에서 선언한 구조체 변수 employee에 값을 초기화해서 사용해보겠습니다. 구조체 변수에 값을 대입하기 위해서는 아래의 방법들이 있습니다.

📍 방법 1. 각 필드를 따로 초기화

var employee Employee
employee.Name = "Eon"
employee.Rank = "staff"
employee.No = 200803
employee.Department = "Development"
employee.Vacation = 15
employee.AnnualIncome = 50000000
employee.Email = "vamos_eon@email.com"
employee.InCharge = "backend"
>
fmt.Println(employee)
// {Eon staff 200803 Development 15 50000000 vamos_eon@email.com backend}

구조체 변수 employee에 대하여 속성을 모두 초기화하고 출력했습니다. 주의 : 초기화하지 않으면 해당 필드에 대해서는 zero-value로 초기화됩니다.

📍 방법2. 모든 필드를 한 번에 초기화

var employee Employee
employee = Employee{ 
    "Kim", 
    "Manager", 
    210109, 
    "DEV", 
    20, 
    70000000, 
    "kim@email.com", 
    "back-end", 
}
>
fmt.Println(employee)
// {Kim Manager 210109 DEV 20 70000000 kim@email.com back-end}

필드 순서에 맞추어 값을 초기화할 수도 있습니다. 주의 : 중간에 초기화하지 않는 필드를 작성조차 하지 않으면 타입이 안 맞을 수 있어, 에러가 발생하기 때문에 zero-value로라도 꼭 초기화를 해야 합니다.

📍 방법3. 선택한 필드만 한 번에 초기화

var employee Employee = Employee{Name: "Eon", Email: "vamos_eon@email.com"}
fmt.Println(employee)
>
employee = Employee{Name: "Kim"}
fmt.Println(employee)
// {Eon  0  0 0 vamos_eon@email.com }
// {Kim  0  0 0  }

선택한 필드만 초기화할 수도 있습니다. 주의 : 이미 초기화된 필드가 있는 상태에서 위와 같은 방법으로 대입을 하면, 선택된 필드 외에는 zero-value가 대입됩니다.

📝 구조체를 포함하는 구조체

구조체를 포함하는 구조체는 조금 더 상세한 표현을 가능하게 합니다.

처음에 그린 구조와 조금 달라졌습니다. 처음에는 직원 한 명에 대해서만 정보를 넣으면 됐으니 그 한 명을 특정하고 정보를 입력했다면, 이번에는 부서 전체에 대하여 그 구성원들의 정보를 넣을 겁니다.

저렇게 많은 것들을 넣게 되면 개념을 잡을 때 복잡할 수 있으니, 일단은 아래 그림과 같이 부서를 중심으로 직원1에 대해서만 구조체를 간단히 선언해보겠습니다.

📌 구조체를 포함하는 구조체의 선언

type 구조체명1 struct {
    필드명 타입
    ...
    필드명 구조체명2
    ...
}
>
type 구조체명2 struct {
    필드명 타입
    ...
    필드명 타입
    ...
}

구조체 안에 타입을 구조체로 둠으로써, 구조체 안의 구조체를 선언했습니다.

위의 사용법을 바탕으로 부서에 대한 구조체를 작성해보겠습니다.

type Department struct {
    DepName        string
    Location    string
    Project        string
    Employee1    Employee
}

type Employee struct {
    Name        string
    Rank        string
    No        uint32
    Vacation    int8
    AnnualIncome    uint64
    Email        string
    InCharge    string
}

구조체를 작성했습니다.

📌 구조체를 포함하는 구조체 변수의 선언

var 구조체변수명 구조체타입명

이어서, 구조체 변수를 선언하겠습니다.

var department Department

이제 구조체 변수 department는 구조체 Department가 가지는 필드를 모두 사용할 수 있습니다.

📌 구조체를 포함하는 구조체 변수의 초기화

위에서 선언한 구조체 변수 department에 값을 초기화해서 사용해보겠습니다. 구조체 변수를 초기화하기 위한 방법은 위에서 소개한 구조체 변수의 초기화와 동일합니다. 다만, 구조체 내부의 구조체에 접근하려면 점(.) 을 두 번 사용해서 접근합니다.

📍 방법 1. 각 필드를 따로 초기화

var department Department
>
department.DepName = "Development"
department.Location = "8F"
department.Project = "Hello World!!"
>
department.Employee1.Name = "Eon"
department.Employee1.Rank = "staff"
department.Employee1.No = 200803
department.Employee1.Vacation = 15
department.Employee1.AnnualIncome = 50000000
department.Employee1.Email = "vamos_eon@email.com"
department.Employee1.InCharge = "backend"
>
fmt.Println(department)
// {Development 8F Hello World!! {Eon staff 200803 15 50000000 vamos_eon@email.com backend}}

구조체 변수 department 대하여 속성을 모두 초기화하고 출력했습니다.

주의 : 초기화하지 않으면 해당 필드에 대해서는 zero-value로 초기화됩니다.

📍 방법2. 모든 필드를 한 번에 초기화

var department Department = Department{
    "Development",
    "8F",
    "Hello World!!",
    Employee{
        "Eon",
        "staff",
        200803,
        15,
        50000000,
        "vamos_eon@email.com",
        "backend",
    },
}
>
fmt.Println(department)
// {Development 8F Hello World!! {Eon staff 200803 15 50000000 vamos_eon@email.com backend}}

필드 순서에 맞추어 값을 초기화할 수도 있습니다. 구조체 안의 구조체답게 필드 값을 초기화할 때 구조체 형태로 초기화합니다.

주의 : 중간에 초기화하지 않는 필드를 작성조차 하지 않으면 타입이 안 맞을 수 있어, 에러가 발생하기 때문에 zero-value로라도 꼭 초기화를 해야 합니다.

📍 방법3. 선택한 필드만 한 번에 초기화

var department Department = Department{
    DepName: "Development",
    Employee1: Employee{
        Name:  "Eon",
        Email: "vamos_eon@email.com",
    },
}
>
fmt.Println(department)
// {Development   {Eon  0 0 0 vamos_eon@email.com }}

선택한 필드만 초기화할 수도 있습니다.

var department Department = Department{
    "Development",
    "8F",
    "Hello World!!",
    Employee{
        Name:  "Eon",
        Email: "vamos_eon@email.com",
    },
}
>
fmt.Println(department)
// {Development 8F Hello World!! {Eon  0 0 0 vamos_eon@email.com }}

부분적으로 필드 선택 방식을 사용할 수도 있습니다. 주의 : 이미 초기화된 필드가 있는 상태에서 위와 같은 방법으로 대입을 하면, 선택된 필드 외에는 zero-value가 대입됩니다.

📝 필드명을 사용하지 않고 구조체를 포함하는 구조체

말이 굉장히 길고 복잡합니다. 하지만 다르게 표현할 수 있는 방법을 모르겠습니다. 굳이 표현한다면 '내장 구조체' 정도로 정리할 수 있겠습니다.

embedded struct field 방식이라고 합니다. embedded struct field 방식은 구조체 필드를 선언할 때, 필드명을 작성하지 않고 타입만 선언합니다.

📌 내장 구조체의 선언

type 구조체명1 struct {
    필드명 타입
    ...
    구조체명2
    ...
}
>
type 구조체명2 struct {
    필드명 타입
    ...
}

필드명 없이, 구조체 타입인 구조체명만 적어서 내장 구조체를 선언합니다.

위의 선언 방법을 바탕으로 구조체를 작성해보겠습니다.

type Department struct {
    DepName        string
    Location    string
    Project        string
    Employee
}

type Employee struct {
    Name        string
    Rank        string
    No        uint32
    Vacation    int8
    AnnualIncome    uint64
    Email        string
    InCharge    string
}

내장 구조체 선언을 했습니다. 위 Department구조체 내의 Employee 구조체가 내장 구조체로 선언된 것을 볼 수 있습니다.

📌 내장 구조체를 포함하는 구조체 변수의 초기화

위에서 선언한 내장 구조체를 포함하는 구조체 변수 department에 값을 초기화해서 사용해보겠습니다. 내장 구조체 변수를 초기화하기 위한 방법은 지금까지와는 다릅니다. 초기화할 때 필드명을 적어주었던 게 전부 빠지고 구조체명으로 대체되기 때문입니다. 특이한 점으로는 내장 구조체 필드에 접근할 때, 점(.) 을 하나만 사용해도 됩니다.

📍 방법 1. 각 필드를 따로 초기화

var department Department
>
department.DepName = "Development"
department.Location = "8F"
department.Project = "Hello World!!"
department.Name = "Eon"
department.Rank = "staff"
department.No = 200803
department.Vacation = 15
department.AnnualIncome = 50000000
department.Email = "vamos_eon@email.com"
department.InCharge = "backend"
>
fmt.Println(department)
// {Development 8F Hello World!! {Eon staff 200803 15 50000000 vamos_eon@email.com backend}}

구조체 변수 department에 대하여 속성을 모두 초기화하고 출력했습니다. 필드명이 없기 때문에 내장 구조체의 필드에 접근할 때는 구조체에서 바로 접근할 수 있습니다.

주의 : 초기화하지 않으면 해당 필드에 대해서는 zero-value로 초기화됩니다.

📍 방법2. 모든 필드를 한 번에 초기화

var department Department = Department{
    "Development",
    "8F",
    "Hello World!!",
    Employee{
        "Eon",
        "staff",
        200803,
        15,
        50000000,
        "vamos_eon@email.com",
        "backend",
    },
}
>
fmt.Println(department)
// {Development 8F Hello World!! {Eon staff 200803 15 50000000 vamos_eon@email.com backend}}

이 방법은 위에 소개한 구조체를 포함하는 구조체 변수의 초기화 방법2 와 동일합니다.

주의 : 중간에 초기화하지 않는 필드를 작성조차 하지 않으면 타입이 안 맞을 수 있어, 에러가 발생하기 때문에 zero-value로라도 꼭 초기화를 해야 합니다.

📍 방법3. 선택한 필드만 한 번에 초기화

var department Department = Department{
    DepName: "Development",
    Employee: Employee{
        Name:  "Eon",
        Email: "vamos_eon@email.com",
    },
}
>
fmt.Println(department)
// {Development   {Eon  0 0 0 vamos_eon@email.com }}

선택한 필드만 초기화할 수도 있습니다. 단, 보시는 바와 같이 구조체명을, 필드명 대신 작성해야 합니다.

var department Department = Department{
    "Development",
    "8F",
    "Hello World!!",
    Employee{
        Name:  "Eon",
        Email: "vamos_eon@email.com",
    },
}
>
fmt.Println(department)
// {Development 8F Hello World!! {Eon  0 0 0 vamos_eon@email.com }}

부분적으로 필드 선택 방식을 사용할 수도 있습니다. 주의 : 이미 초기화된 필드가 있는 상태에서 위와 같은 방법으로 대입을 하면, 선택된 필드 외에는 zero-value가 대입됩니다.

📌 같은 필드명을 가지고 있는 내장 구조체의 선언

type 구조체명1 struct {
    필드명1 타입
    ...
    구조체명2
    ...
}
>
type 구조체명2 struct {
    필드명1 타입
    ...
}

위와 같이 서로 다른 구조체에 필드명이 중복되어 있고, 그 두 구조체가 내장 구조체의 관계를 가지고 있습니다. 이 때, 각 구조체의 필드명1에 값을 서로 다르게 부여하고 두 필드명1에 모두 접근할 수 있습니다.

위의 선언 방법을 바탕으로 구조체를 작성해보겠습니다.

type Department struct {
    Name        string
    Location    string
    Project        string
    Employee
}

type Employee struct {
    Name        string
    Rank        string
    No        uint32
    Vacation    int8
    AnnualIncome    uint64
    Email        string
    InCharge    string
}

두 구조체의 Name이라는 필드명이 중복되어 있는 것을 볼 수 있습니다.

📌 같은 필드명을 가지고 있는 내장 구조체 변수의 초기화

같은 필드명을 가지고 있는 내장 구조체 변수의 초기화 방법은 또 조금 다릅니다. 초기화할 때 필드명을 적어주었던 게 전부 빠지고 구조체명으로 대체되기 때문입니다. 특이한 점으로는 내장 구조체 필드에 접근할 때, 점(.) 을 하나만 사용해도 됩니다.

📍 방법 1. 각 필드를 따로 초기화

var department Department
>
department.Name = "Development"
department.Location = "8F"
department.Project = "Hello World!!"
department.Employee.Name = "Eon"
department.Rank = "staff"
department.No = 200803
department.Vacation = 15
department.AnnualIncome = 50000000
department.Email = "vamos_eon@email.com"
department.InCharge = "backend"
>
fmt.Println(department)
// {Development 8F Hello World!! {Eon staff 200803 15 50000000 vamos_eon@email.com backend}}

구조체 변수 department에 대하여 속성을 모두 초기화하고 출력했습니다. 필드명이 없기 때문에 내장 구조체의 필드에 접근할 때는 구조체에서 바로 접근할 수 있습니다.

같은 필드명의 내장 구조체 내의 필드에 접근하려면 구조체명을 사용해서 접근할 수 있습니다. department.Employee.Name = "Eon" 같은 필드명이 아니더라도 구조체명을 사용해서 접근할 수도 있습니다. 주의 : 초기화하지 않으면 해당 필드에 대해서는 zero-value로 초기화됩니다.

📍 방법 2. 모든 필드를 한 번에 초기화

위에서 소개한 방식과 같습니다.

📍 방법3. 선택한 필드만 한 번에 초기화

위에서 소개한 방식과 같습니다.

📝 구조체 배열

구조체도 배열의 형태로 저장할 수 있습니다. 위에서 보여드린 구조체에 대한 그림 중, 아래의 그림을 예시로 사용하겠습니다.

📌 구조체 배열의 선언

type 구조체명1 struct {
    필드명 타입
    ...
    필드명 [배열크기]구조체명2
    ...
}
>
type 구조체명2 struct {
    필드명 타입
    ...
}

위와 같은 방법으로 구조체 배열을 포함하는 구조체를 선언합니다.

위의 선언 방법을 바탕으로 구조체를 작성해보겠습니다.

type Department struct {
    DepName        string
    Location    string
    Project        string
    EmployeeInfo    [1]Employee
}

type Employee struct {
    Name        string
    Rank        string
    No        uint32
    LeaveInfo    Leave
    AnnualIncome    uint64
    Email        string
    InCharge    [1]Tasks
}

type Leave struct {
    AnnualLeave        uint8
    BereavementLeave    uint8
    LongServiceLeave    uint8
     SickLeave        uint8
}

type Tasks struct {
    Name        string
    Duration    uint8
    Progress    uint8
}

📌 구조체 배열 변수의 초기화

var OurComapny [1]Department = [1]Department{}
>
OurComapny[0].DepName = "Development"
OurComapny[0].Location = "8F"
OurComapny[0].Project = "Hello World!!"
OurComapny[0].EmployeeInfo[0].Name = "Eon"
OurComapny[0].EmployeeInfo[0].Rank = "staff"
OurComapny[0].EmployeeInfo[0].Email = "vamos_eon@email.com"
OurComapny[0].EmployeeInfo[0].AnnualIncome = 50000000
OurComapny[0].EmployeeInfo[0].No = 200803
OurComapny[0].EmployeeInfo[0].LeaveInfo.AnnualLeave = 15
OurComapny[0].EmployeeInfo[0].LeaveInfo.BereavementLeave = 5
OurComapny[0].EmployeeInfo[0].LeaveInfo.LongServiceLeave = 0
OurComapny[0].EmployeeInfo[0].LeaveInfo.SickLeave = 30
OurComapny[0].EmployeeInfo[0].InCharge[0].Name = "Golang installation"
OurComapny[0].EmployeeInfo[0].InCharge[0].Duration = "~2022-01-16"
OurComapny[0].EmployeeInfo[0].InCharge[0].Progress = "80%"

위와 같이 초기화해서 접근할 수 있습니다.

slice로 선언하면 훨씬 유동적이고 쉽게 초기화 및 접근이 가능합니다. slice에 대한 내용은 나중에 다루겠습니다.

📝 메모리 할당

📌 구조체의 메모리 할당

구조체의 메모리 할당에 가장 큰 특징은 메모리 패딩입니다. 빈 공간을 추가로 할당하는 것인데, 왜 그런지 알아보겠습니다.

📍 레지스터에 대한 이해

운영체제에 대한 이야기를 조금이라도 들어봤다면 32비트 운영체제와 64비트 운영체제가 있다는 것은 알 수 있습니다.

요즘 나오는 운영체제는 대부분이 64비트 운영체제입니다. 더 많은 양을 처리할 수 있기 때문에 뭔가 특별한 제약이 있는 경우가 아니라면 32비트를 쓸 이유가 없습니다.

이 32비트와 64비트가 의미하는 것은 바로 '한 번에 처리할 수 있는 데이터의 크기' 라고 보시면 됩니다. 정확히는 주소의 길이입니다. 32비트 운영체제는 주소의 단위가 4바이트입니다. 따라서 한 번에 처리할 수 있는 데이터의 크기는 4바이트입니다. 64비트 운영체제는 주소의 단위가 8바이트입니다. 따라서 한 번에 처리할 수 있는 데이터의 크기는 8바이트입니다.

우리가 코딩을 하고 컴파일한 후에 실행하면, 선언한 변수들에 대한 메모리가 할당이 됩니다. 그 변수가 사용될 때, 데이터가 RAM에 먼저 올라가게 되고, CPU가 연산을 하기에 앞서, Register에 해당 데이터를 가지고 온 다음에 CPU가 Register에 올라온 데이터를 가지고 연산을 합니다.

32비트 운영체제에서 8바이트짜리 데이터는 두 번 읽어서 사용합니다. DRAM과 캐시를 이용하는데, 이것은 운영체제에 관련한 공부를 따로 요구합니다. 아무튼 32비트 운영체제에서도 8바이트짜리 데이터를 읽고 사용하는 데에는 문제가 없습니다.

대개 64비트 운영체제를 사용하기 때문에, 운영체제는 메모리 할당을 8바이트의 배수 단위로 하려고 할 것입니다. 이것이 '메모리 정렬' 입니다.

📍 메모리 정렬과 메모리 패딩

64비트 운영체제는 메모리를 8바이트 단위로 할당한다고 했습니다. 한 번에 처리할 수 있는 데이터의 최대 크기가 8바이트이기 때문입니다. bool 변수를 하나 선언하면 1바이트입니다. int16 변수를 하나 선언하면 2바이트입니다. 이 두 변수를 선언하면 총 3바이트입니다.

그런데, 위의 두 변수를 하나의 구조체에서 사용하면 메모리 정렬이 일어납니다. 변수를 따로 선언하는 것은, 메모리의 어디에든 따로 할당되어 있어도 상관없습니다. 하지만 구조체는 구조체 자체가 하나의 변수처럼 되어 있는 구조이므로 연속된 메모리에 할당됩니다. 구조체 안에 bool과 int16을 선언하겠습니다.

type structure1 struct {
    vBool    bool
    vInt16    int16
}

...
fmt.Println(unsafe.Sizeof(structure1{})
// 4

structure1의 크기는 4바이트입니다. 메모리 정렬로 인해 생긴 메모리 패딩 때문입니다.

메모리 정렬은 CPU가 메모리에서 데이터를 가지고 올 때 효율적으로 동작하기 위해 수행합니다. 메모리 정렬은 구조체에 선언된 변수의 순서대로 진행되며, 구조체 내의 변수 중 가장 큰 사이즈가 기준이 됩니다. 위의 경우, vInt16이 structure1 내의 가장 사이즈가 큰 변수이므로 int16의 사이즈인 2바이트가 데이터를 불러올 때의 단위가 됩니다. 그래서 bool 타입의 vBool을 메모리에 할당할 때, 2바이트로 할당하게 되는 것입니다. 그렇게 bool 타입의 실제 사이즈인 1바이트가 아닌 해당 변수에 2바이트가 할당되어 사용하지 않는 1바이트가 생겨나게 됩니다. 이것이 메모리 패딩입니다.

예시를 한 가지 더 보겠습니다. 아래와 같이 구조체를 선언해보겠습니다.

type structure2 struct {
    v1Int32    int32
    vInt16    int16
    v2Int32    int32
    vBool    bool
}

보시는 바와 같이 구조체 내의 가장 큰 변수 사이즈인 int32에 맞추어, 4바이트를 기준으로 메모리 할당이 된 것을 볼 수 있습니다. 4바이트 간격으로 int16은 2바이트를 차지하고, 전체 4바이트 공간 중 나머지 2바이트는 사용하지 않는 메모리 패딩으로 남습니다.

📍 구조체를 만드는 가장 좋은 방법은?

구조체를 만들 때 필드의 사이즈를 내림차순으로 만드는 것이 가장 좋습니다. 자료형들의 사이즈를 보면 모두 2의 거듭제곱으로 표현된다는 것을 알 수 있습니다. 각각 1, 2, 4, 8 바이트입니다. 내림차순으로 만들게 되면 메모리 패딩을 줄이고 구조체의 크기를 줄일 수 있습니다.

type structure2 struct {
    v1Int32    int32
    v2Int32    int32
    vInt16    int16
    vBool    bool
}

📌 구조체 사이즈 확인

위에서 잔뜩 메모리 정렬과 메모리 패딩에 대해서 이야기했는데 정작 메모리가 실제로 어떻게 잡히는지 사이즈 측정을 하지 않았습니다. 여기서는 사이즈를 구해보도록 하겠습니다.

unsafe 패키지 를 이용하면 됩니다. unsafe 패키지는 안전하지 않은 유형들을 포함하는 패키지입니다. 사용할 때는 조심해야 하며 Go 1 호환성 가이드라인으로 보호받지 않습니다.

📍 Sizeof() : func Sizeof(x ArbitraryType) uintptr

ArbitraryType은 실제 unsafe패키지에 포함된 타입이 아닙니다. 문서화를 위한 타입일 뿐입니다.

Sizeof() 함수는 그 타입의 크기를 바이트 단위로 반환합니다. 단, 참조되는 메모리의 크기를 그대로 반환하는 것은 아닙니다. slice와 같은 경우, 메모리의 크기가 아니라 slice 설명자의 크기를 반환한다고 되어 있습니다.

📍 unsafe : 변수와 구조체 사이즈 구하기

여기서, 변수의 크기와 구조체의 크기를 구해보겠습니다.

package main
>
import (
    "fmt"
    "unsafe"
)
>
func main() {
    fmt.Printf("Size of %T : %d\n", int64(0), unsafe.Sizeof(int64(0)))
    fmt.Printf("Size of %T : %d\n", int32(0), unsafe.Sizeof(int32(0)))
    fmt.Printf("Size of %T : %d\n", int16(0), unsafe.Sizeof(int16(0)))
    fmt.Printf("Size of %T : %d\n", int8(0), unsafe.Sizeof(int8(0)))
    fmt.Printf("Size of %T : %d\n", bool(false), unsafe.Sizeof(bool(false)))
}
/* The result of the ouput
Size of int64 : 8
Size of int32 : 4
Size of int16 : 2
Size of int8 : 1
Size of bool : 1
*/

golang의 자료형 사이즈대로 잘 나오는 것을 확인할 수 있습니다.

구조체의 크기도 구해보겠습니다.

package main
>
import (
    "fmt"
    "unsafe"
)
>
type structure1 struct {
    vBool  bool
    vInt16 int16
}
>
func main() {
    var s structure1
    fmt.Printf("Size of %T struct: %d bytes\n", s, unsafe.Sizeof(s))
}
// Size of main.structure1 struct: 4 bytes

위에서 설명드린 바와 같이, bool 타입에 1바이트의 메모리 패딩이 붙어, 총 4바이트가 된 것을 확인할 수 있습니다.

📌 string의 메모리 할당

string의 크기를 구해보겠습니다.

📍 string의 사이즈 구하기

string을 Sizeof() 함수로 크기를 구해보면 string 변수의 값이 말도 안 되게 길어도 항상 16바이트를 반환합니다.

fmt.Printf("Size of %T : %d\n", string("abcdefghijklmnopqrstuvwxyz"), unsafe.Sizeof(string("abcdefghijklmnopqrstuvwxyz")))
// Size of string : 16

unsafe.Sizeof(string(""))은 string의 설명자의 크기를 반환하기 때문입니다. string은 StringHeader, 바이트 데이터로 구성되어 있습니다.

type StringHeader struct {
    Data uintptr
    Len  int
}

StringHeader는 위와 같습니다. Data는 실제 데이터가 있는 위치, Len은 문자열 길이를 저장합니다. 따라서, StringHeader의 크기는 uintptr(8bytes) + int(8bytes)로, 16바이트가 됩니다.

string 타입의 데이터가 실제로 메모리에 할당되는 크기는 아래와 같습니다.

var str string = "Hello"
stringSize := len(str) + int(unsafe.Sizeof(str))
fmt.Println(stringSize)
// 21

string 타입의 실제 메모리 = 문자열 길이 + StringHeader의 크기

📌 string을 포함한 구조체의 크기

unsafe.Sizeof(string(""))은 StringHeader의 크기를 반환한다고 했습니다. 구조체에서는 필드 중 가장 사이즈가 큰 값을 기준으로 메모리를 할당한다고 했습니다. string이 끼어 있는 경우, 메모리 할당이 어떻게 이루어지는지 보겠습니다.

type strInclude struct {
    vStr    string
    vInt64    int64
}
...
fmt.Println(unsafe.Sizeof(strInclude{}))
// 24

이렇게 할당됩니다. 이유는 간단합니다. unsafe.Sizeof(strInclude{})는 StringHeader의 사이즈를 반환하고, StringHeader는 uintptr, int로 이루어져 있으며 이 두 자료형 모두 8바이트입니다.

따라서 아래와 같이 8바이트 단위로 메모리 정렬 및 할당이 이루어집니다.

당연하게도, strInclude 구조체 내에 int64 자료형의 필드가 int32가 되더라도 strInclude의 크기는 24로 나오게 됩니다.

이번 포스팅은 구조체에 대한 내용이었습니다. 감사합니다.👍

이번 포스트는 배열에 관한 내용입니다.

📝 배열이란?

배열은 같은 타입을 가지는 변수들의 묶음입니다. 또, 선언된 변수들은 각각 연속된 메모리 공간에 할당됩니다.

배열은 수학의 행렬과 비슷하다고 볼 수 있습니다. 행과 열의 크기를 정하고, 그 안에 값을 저장합니다.

수학에서의 행렬

1 × 2 행렬

2 × 2 행렬

프로그래밍에서의 배열

1 × 2 의 형태는 1차원 배열

var a [2]int = [2]int{1, 2}

2 × 2 의 형태는 2차원 배열

var a [2][2]int = [2][2]int{{1, 2}, {3, 4}}

📝 배열의 구성

배열은 인덱스와 요소로 구성돼 있습니다. 인덱스 : 배열에 들어가 있는 각 요소들의 순서이며, 0부터 시작함 요소 : 각 인덱스가 가지는 값

배열 a는 int타입의 요소 4개로 이루어졌습니다. 각 요소를 인덱스 순서에 맞게 {1, 2, 3, 4}로 초기화합니다. 각 인덱스의 요소는 a[인덱스] = 요소로 나타낼 수 있습니다.

📝 선언

📌 지금까지의 변수 선언

var a int

위와 같이 int 타입의 변수 a를 선언했습니다. 여러 개의 변수를 선언하기 위해서는 아래와 같이 수행했습니다.

var a, b int

📌 배열의 선언

var a [5]int

위에서 int 타입의 변수 5개를 a라는 배열에 선언했습니다. 배열 a는 5개의 int 타입의 요소를 가집니다.

배열은 초기에 지정한 크기를 변경할 수 없습니다. 위의 예시에서 인덱스가 5개인 배열을 선언했는데, 이 배열의 크기는 4로 줄어들 수도, 6으로 늘어날 수도 없습니다. 때문에, 변수를 배열의 크기를 지정할 때 사용할 수 없고 상수는 사용이 가능합니다.

📌 여러 종류의 배열 선언 방법

배열을 선언하는 방법은 위에서 소개한 방법 외에도 몇 가지 더 있습니다. 위에서 소개한 방법을 포함해서 작성하겠습니다.

📍 var a [5]int // 초기화 없이 선언 & 값을 지정하는방법

각 요소에 개별적으로 값을 지정하는 방법

var a [5]int
a[0] = 1
a[1] = 2 
a[2] = 3 
a[3] = 4 
a[4] = 5 

위에서 소개한 방법입니다. 먼저 배열을 선언함과 동시에 각 요소에 개별적으로 접근하여 값을 지정했습니다.

값을 지정하지 않으면, 초기화를 하지 않았기에 a 안의 모든 요소의 값은 int타입의 zero-value인 0입니다.

📍 var a [5]int = [5]int{1, 2, 3, 4, 5} // 선언 & 초기화하는 방법

초기화와 동시에 배열에 통째로 값을 지정하는 방법

var a [5]int = [5]int{1, 2, 3, 4, 5}

참고 : golang go-static에서는 위와 같이 선언과 초기화를 같은 줄에 작성하는 걸 권장합니다.

var a [5]int = [5]int{1, 2, 3, 4}

인덱스가 5개인 배열에 값을 4개만 지정하는 경우, 초기화하지 않은 인덱스의 값은 zero-value가 됩니다.

fmt.Println(a[4])
// 0

📍 b := [3]bool{true, false, true} // 짧은 선언 & 초기화하는 방법

b := [3]bool{true, false, true}

위와 같이 짧은 선언과 초기화를 동시에 할 수 있습니다.

📍 var c = [5]float64{1: 1.1, 3: 3.3} // 인덱스를 지정하여 값을 초기화하는 방법

특정 인덱스에만 값을 초기화하는 방법

var c = [5]float64{1: 1.1, 3: 3.3}

var 배열이름 = [사이즈]타입{인덱스 : 요소, 인덱스 : 요소, ...}

fmt.Println(c)
// [0 1.1 0 3.3 0]

📍 d := [...]string{"one", "two", "three"} // 요소의 개수로 크기를 지정하는 방법

배열의 크기를 먼저 지정하지 않아도 되는 방법

d := [...]string{"one", "two", "three"}
fmt.Println(len(d))
// 3

len() 은 길이(length)를 반환하는 기본 내장함수입니다. 위에서 len()은 배열 d의 길이를 반환합니다.

📍 var mul [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}} // 다차원 배열 선언하는 방법

1. 한 줄에 선언 및 초기화

var mul [2][3]int = [2][3]int{{1, 2, 3}, {4, 5, 6}}

2. 여러 줄로 선언 및 초기화

var mul [2][3]int = [2][3]int{
    {1, 2, 3}, 
    {4, 5, 6},
}

이렇게 여러 줄로 초기화할 수 있습니다. 단, 새로 개행을 하고 괄호를 닫을 경우, 마지막 원소의 끝에 콤마(,)를 붙여야 합니다.

📌 다차원 배열은 언제 사용할까?

가장 쉬운 예시로, 차원을 표현할 때 사용할 수 있습니다.

📍 이미지 표현

이미지는 2차원입니다. x, y축으로 이미지를 표현할 수 있습니다. 각 픽셀의 위치를 좌표로 하고, 그 위치에 들어가는 값으로 색을 정할 수 있습니다.

📍 3D 물체 표현

3D 물체는 3차원입니다. x, y, z축으로 표현할 수 있습니다. 이미지와 마찬가지로 모든 좌표에 대하여 값을 넣음으로써 물체를 표현할 수 있습니다.

📌 배열의 순회

배열의 각 요소에 순차적으로 접근할 수가 있습니다. 앞서 반복문에 대한 포스트에서도 짧게 소개했습니다.

먼저 아래 배열 순회 예시에서 사용되는 배열 하나를 아래와 같이 선언하겠습니다.

var a [5]int = [5]int{1, 2, 3, 4, 5}

📍 for init; condition; post {...} : C-Like for

a[2] = 10
for i := 0; i < len(a); i++ {
    fmt.Printf("%d ", a[i])
}
// 1 2 10 4 5 

배열[인덱스] 로 원하는 인덱스 요소를 사용할 수 있습니다. 위와 같이 특정 인덱스의 값을 바꿀 수도 있습니다.

📍 for condition {...} : C-Like while

i := 0
for i < len(a) {
    fmt.Printf("%d ", a[i])
}
// 1 2 3 4 5 

📍 for {...} : C-Like for(;;)

i := 0
for {
    if i >= len(a) {
        break
    }
    fmt.Printf("%d ", a[i])
    i++
}
// 1 2 3 4 5 

📍 for - range : 'for loop' for array, slice, string, or map, or reading from a channel

for i, v := range a {
    fmt.Println("index : %d & value : %d", i, v)
}
/* The result of output
index : 0 & value : 0
index : 1 & value : 0
index : 2 & value : 0
index : 3 & value : 0
index : 4 & value : 0
*/

for i, v := range a {...} : i (index), v (value)가 들어갑니다. 이 루프 안에서는 a[i]를 사용하고 v를 사용하지 않아도 됩니다. golang에서는 선언하고 사용하지 않는 변수가 있으면 컴파일 에러를 일으키기 때문에, a[i]로 사용하려면 아래와 같이 v를 선언하지 않으면 됩니다. for i := range a {...}

📝 메모리 할당

📌 배열의 메모리 할당

배열을 선언하면 다른 변수와 마찬가지로 메모리에 공간이 할당됩니다. 아래 그림은 배열이 아닌 변수와 배열의 메모리 할당을 나타냅니다.

변수는 할당되면 그 변수 타입의 크기만큼 메모리 공간이 할당됩니다. 배열도 마찬가지입니다. 다만 배열은 맨 처음 인덱스를 기준으로 하여, 이어지는 인덱스는 전부 연속적인 메모리 공간에 할당됩니다.

위의 그림은 int32타입의 배열이므로, 각 인덱스의 주소값은 int32의 크기만큼의 차이를 둡니다. 0번 인덱스의 주소값이 100이라고 할 때, 1번 인덱스의 주소값은 100 + sizeOf(int32)가 됩니다. (golang에서 sizeOf는 unsafe 패키지 내에 Sizeof() 함수로 사용할 수 있습니다. 다른 포스트에서 설명하겠습니다.) 32bit = 4byte 이므로, 각 인덱스의 주소값은 4바이트 단위로 증가합니다. 주소값 : 메모리 공간의 주소 (할당된 공간의 위치를 나타냄)

📌 다차원 배열의 메모리 할당

golang에서의 다차원 배열은, 메모리 영역 할당이 연속적입니다.

위와 같이 서로 떨어져 있는 메모리 영역에 공간을 할당받는 것이 아니라, 아래와 같이 연속된 메모리 영역에 공간을 할당받습니다.

📝 배열 복사

값의 복사는 쉽게 할 수 있습니다.

변수의 복사

var a, b int = 2, 3
a = b
fmt.Println(a)
// 3

위와 같이 변수에 값을 복사하는 것은 '대입'이라는 개념을 통해서 이해할 수 있습니다. 단, golang은 최강타입 언어라고 했습니다. 타입이나 크기가 다르면 값의 복사를 불허합니다.

var a int = 2
var b int64 = 3
a = b

위 과정은 에러가 발생합니다. 64비트 운영체제에서 사용해도 말입니다. int는 64비트 운영체제에서 int64와 사이즈가 동일합니다. 하지만 타입명이 다릅니다. 그래서 에러가 발생합니다.

배열의 복사

var a [5]int = [5]int{1, 2, 3, 4, 5}
var b [5]int = [5]int{6, 7, 8, 9, 10}
a = b
fmt.Println(a)
// [6 7 8 9 10]

위의 경우엔 정상적으로 복사된 배열을 출력합니다. 배열의 타입과 크기가 모두 동일해서 가능했습니다. 여기서 타입이나 크기를 서로 다르게 지정을 한다면 복사가 불가능합니다.

이번 포스트는 배열에 대한 내용이었습니다. 감사합니다.👍

(어투는 제 회고이니 양해 바랍니다.) 2021년을 마무리하며 올 한 해동안 느낀 점들을 작성하고 회고하는 시간을 가져보겠다.

뭐 대단한 사람도 아니고 기껏해야 주니어 개발자이지만 성장 일기 느낌으로 기록을 남기고 싶어서 작성한다.

개발자로서의 시작

때는 바야흐로 작년 8월.. (시간의 흐름대로 작성, 2021년의 시점이 언제인지는 모른다..!!) 개발자로서의 첫 발을 내딛었을 때, 처음 맡게 된 업무는 이미 개발된 웹페이지에 대한 테스트였다. 이미 개발되었고, 서비스 중인 웹페이지를 테스트하고 디버깅하는 업무는 시작부터 고민이었다.

"어디서부터 시작해야 하지?"

하지만 고민의 시간은 짧았다. 사용자의 입장에서 이것 저것 눌러보고 메뉴얼의 일반적인 순서대로 진행하는 것이 아닌 억지로 순서를 바꿔가며 테스트하기 시작했다.

결과는 역시 '여러 가지 문제점을 발견했다.' 였다.

그러나 대뜸 시작한 마구잡이식 테스트였기에 내가 뭘 눌러서 이렇게 됐는지 재현하는 게 쉽지 않았다. 문제점을 인지하고 곧바로 테스트를 진행하며 동시에, 내가 뭘 눌렀는지 하나씩 정리하기 시작했다.

그렇게 테스트 / 디버깅 업무에서부터 하나 배우고 시작하게 됐다.

개발의 시작, 그런데 Go를 쓴다고?

인사이동으로 팀이 배정이 되고, 본격적으로 개발 업무를 시작하게 됐다. 그리고 곧바로 업무분장을 통해 직무를 부여 받았고, 백엔드를 담당하게 됐다.

Hello, Golang

Golang을 사용하게 됐다. 처음 접근은 처참하리만큼 실패였다고 말할 수 있다.

대개 '신입 사원에게는 기대 안 한다.' 라는 말들을 하지만, 성격상 월급 꼬박꼬박 받으며 일도 잘 못하는 그런 기간은 빨리 줄이고 싶었다.

그래서 코드를 분석하는 기간이 짧았고, 팀장님께서 요구하신 REST-API 개발을 시작했다.

Go를 써본 적도 없는데 말이다.

처음 보는 문법에 헷갈리는 게 한두 가지가 아니었고 새로운 언어를 배울 때, 누가 가르쳐주지 않고 홀로 배우는 것은 처음이었기에 더 어려웠다.

홀로 공부하는 것은 아직까지도 많은 노력이 필요하다.

뭐야? 이거 순서가 왜 이래? 콜론은 왜 붙어..?

var value int
var value int = 0
value := 0

Go를 처음 접할 때, 헷갈린 것들 중 하나가 바로 변수 선언, 초기화다. 뭐, 그래. 좋아! 여기까진 적응하는 데에 어려움은 없었다. 그런데 문제는 이게 왜 이렇게 쓰이는지 찾아보질 않고 계속 코드만 들여다 보고 있었던 거다.

Go에 대한 어떤 기본적인 강의 영상이나 문서나 블로그 글을 찾아보지도 않고 그저 보고 있던 게 내가 평가하는 나의 가장 큰 실수였다.

개발자의 덕목 중 하나가 바로 검색 능력이다. 학교 다닐 때 프로젝트할 때만 해도 잘만 검색해서 개발하곤 했는데, 막상 현업에 발을 내딛고 심지어 새로운 언어를 접하게 되니 머릿속이 백지가 돼 버린...

코드를 쭉 보다가 갑자기 Msg string `json:"message"` 응???

뭐야? 구조체 변수명 뒤에 저런 게 붙어..?

struct tag에 부딪히고야 말았다. 뭐, 어차피 곧바로 개발 시작한 것도 아니었고 기껏해야 Go가 어떤 언어인지 보고 있었으니 이제라도 검색을 해서 공부하기 시작했다.

이제서야 Golang으로 짜여진 코드를 볼 수 있게 됐다. 완벽히 모든 것들을 공부하고 시작한 것은 아니어도, 작성돼 있는 것들은 얼추 어떤 역할을 하는 코드인지 파악할 수 있게 된 것이다.

if err != nil {...} 다른 에러처리 기법은 없나? try catch는..

Golang에는 try catch가 없습니다.. 네? 이걸 몰랐을 때는 코드를 보면서도 참 지저분하다고 생각했다.

API 하나에서 처리되는 에러만 해도 3개 이상.. 그런데 이걸 예쁘게 한 번에 처리할 수도 없고 이렇게 써야 한다니..!!

라고 생각했지만, 이렇게 에러가 튀어나올 때마다 바로바로 처리해주는 게 습관이 되고 나서 보니, 에러처리에 대한 직관성이 잘 확보되는 것 같다고 생각이 바뀌게 되었다.

장단점이 확실하지만 뭐 어쩌겠습니까? 지금 제가 써야 하는 언어인 걸요!

REST-API란 무엇인가

REST-API 개발 업무를 맡게 되고 하루 빨리 API 하나 하나 뚝딱뚝딱 만들어내야겠다는 생각이 머릿속을 지배했다. REST-API에서 Request를 보내는 파트는 go-resty라는 패키지를 사용한다. 코드를 보며 '아 이렇게 보내는 거구나' 라는 직감으로 바로 개발을 진행할 수 있었다.

그런데?

REST-API는 뭘까? 하는 생각이 뒤늦게 들고 말았다. RESTful한 API.. 심오하다 심오해

퇴근길에 유튜브를 켜서 REST-API에 대한 약 50분 정도 되는 길이의 영상을 시청하게 됐다.

REST-API의 역사 그 자체를 알게 되고, 이제 그 목적을 정확히 알고 개발할 수 있겠다는 생각을 하게 되었다.

또, 여기서 느낀 것이.. '개발자들은 서로의 지식을 공유하는 것이 어렵지 않구나.' '검색만 하면 누군가 정리해둔 글들이 정말 많구나.' '글 뿐만 아니라 영상, 강의도 정말 많네?'

새삼스레 느낀 점들이다. 학교에서 개발할 때는 아무 생각없이 그저 '인터넷에 올라와 있으니까.' 찾아서 공부하고 썼던 것들인데, 사회로 나와 보니 이게 당연한 게 아니라는 것을 알게 되었다.

기술은 나눌수록 발전하는 것

다른 직업군에서는 볼 수 없는 문화가 개발자들 사이에는 형성되어 있는 것 같다. 부모님 세대에서만 봐도 '사수가 일을 안 가르쳐주고 자기 밥그릇 챙기기에 급급했다.' 는 얘기를 심심치 않게 들어볼 수 있는데..

정말 자기가 하는 일이 전문화되어 있고, '이 일은 나 아니면 못 해' 가 아니면 일자리조차 보장되지 않던 시절이었으니까.

아직까지도 이런 마인드가 남아 있는 회사들이 정말 많은 것 같다. 주변 다른 직업군 친구들 얘기만 들어보더라도.. 있다. 분명히..

그런데 개발자들은 자신의 기술을 공유한다. stackoverflow, velog, github page, tistory 등등 본인이 시행착오를 겪어 이룬 기술을 다른 사람들과 공유한다.

또! 오픈소스라는 분야는 정말 대단한 것 같다. 엄청난 노력이 들어간 코드를 무료로 제공한다는 점이..!! 오픈소스가 없었다면 기술 블로그와 같은 문화도 자리 잡을 일은 없었을 것 같다.

내가 velog를 시작한 이유이기도 하다. (감사함은 진작에 느꼈고 기여하기 위해 velog를 시작한 것은 꽤나 최근이다.)

비록 알고 있는 범위가 다른 선배 개발자들보다야 훨씬 좁지만, 감사함에 힘입어 시작했다.

포스팅 주기가 그리 짧지 않고 늘어지기도 하지만, 꾸준히 작성해서 사회에 기여하고 싶다.

보안에 대한 고찰

REST-API를 만들다 보니, 보안에 대한 부분을 신경쓰지 않을 수 없었다. 어떻게 해야 공격을 줄일 수 있을까? 어떻게 해야 공격을 안 받을 수 있을까? 피할 수 없다면 어떻게 해야 서버가 뻗지 않을 수 있을까?

아무리 고민해도 모자라지 않은, 하지만 과하면 독이 되는..

보안은 참 어렵다. 어렵다 어려워 너무..

JWT를 쓰면 된다!

그러면 사용자를 특정할 수 있고, API 호출을 할 때 유효성 검사만 하면 되지 않느냐?

아니다!! 어쨌든 토큰이고, 어떤 방법으로든 토큰은 탈취당할 수 있다.

탈취당하면 끝이다!!

만료 기간을 짧게 설정하면 되잖아?

뭐 얼마나 짧게..?? 10분 15분? 은행 웹 페이지처럼??

절대 안 된다. 뭐, 절대라고까진 아니어도 사실 그렇게까지 짧게 설정하면 좋지 않다.

JWT를 쓰지 않았을 때를 가정하고 사용자가 로그인을 한 후에, API 요청을 하게 되면! 서버는 API 요청에 알맞게 동작을 수행하고 응답을 보낸다.

이 과정 사이에 JWT 토큰을 보관하는 DB가 필요하고, 10분 15분이 지나서 토큰이 만료되면 DB에 새로운 토큰을 넣어, 새로 발급해야 한다. 또한 사용자마다 토큰을 다르게 해야 하기 때문에 그 양은 상당하다.

동접자 10만명일 때, (물론 지금 개발하는 서비스가 그렇게까지 거대한 것도 아니지만..) 10만명이 어떤 동작을 수행할 때마다 API 요청을 하고, 거기에 추가로! 추가로, 토큰 시간이 만료되기 전에 새로운 토큰을 발급받는다면??

없어도 됐을 10만 번의 트랜잭션이 10분 15분마다 한 번씩 추가되는 셈이다.

그럼 뭐 어떡해..?

어떡하긴! JWT만 사용하는 방식에서 벗어나면 된다.

이중 보안! JWT와 Basic Authentication을 활용할 수 있다.

근데 Basic Auth도 탈취당하면?

CORS라는 방법이 있다!

CORS

Cross Origin Resource Sharing 정말 극악무도하지 않을 수 없다. 특정한 도메인에서 오는 요청만 허용할 수 있게 하는 보안 옵션인데, 이게 설정하는 게 여간 까다롭고 복잡하다.

하지만 잘만 설정하면 내가 지정한 도메인에서의 요청만 받고, 나머지 요청은 거절하게 된다.

아무튼 나도 CORS 때문에 고생깨나 했다.

CORS까지만 써도 되는가?

NO!! 그렇지 않다. 하지만 어쩌겠는가.. 철통보안을 위해 가져다 쓸 수 있는 모든 보안체계를 투입하게 되면 서버는 버티지 못할 것이다. 적절한 절충안이 필요했고, 일단 당장은 여기까지만 하자는 결론에 이르렀다.

협업툴 Wiki / Jira

Wiki

사내 문서화를 위해 사용하는 Wiki는 이 벨로그마냥 정리하기 편하다. 여러 협업툴들이 있지만 당장 현업에서 사용하고 있는 게 wiki이기에.

주로 Wiki에는 사내 프로젝트에서 쓰인 기술이나 코드 기능에 대한 부분, API 문서 등을 작성한다. 그 외에 오픈되어 있는 기술들에 대해서는 velog에 작성하기도 한다.

뭐 아무튼 사내 기밀 유지를 위해 API 기능들을 velog에 소개하진 않고, 어떻게 API 기능을 작성하는지 정도는 공유할 수 있을 것이다.

Jira

버전 관리, 이슈 관리를 위해 사용하는 Jira는 정말 편리하다. 나의 업무 진척도를 바로 바로 공유할 수 있고, 내 앞에 티켓이 몇 개나 있는지도 확인할 수 있다. 서로 메신저나 직접적인 대화를 하지 않더라도 업무 부여나 문제 제기가 가능하다.

가장 좋은 점은, 내가 할 일이 무엇이있는지 고민할 필요가 없다는 점이다. 내 앞에 있는 티켓을 전부 처리하면 나는 자유다. 물론 이마저도 성격상 일을 다 처리하면 다른 일거리 없는지 찾아보곤 한다.

'월급 루팡' 이란 내 사전에 없다.. 앗, 아직까지 재택근무할 땐 약간 업무 효율이 떨어지는 것 같기도..

코로나가 바꾼 일상

코로나로 인한 재택근무

바로 위에 재택근무에 대한 부분을 언급하며 급 떠올린 재택근무..

재택근무를 번갈아 가며 하고 있는데 재택을 하면 장단점이 너무나 확실하다.

출퇴근 시간이 내 시간!!

출퇴근 시간이 온전히 내 시간이 된다. 버스를 타는 시간도, 지하철을 타는 시간도, 사실 출퇴근하며 유튜브나 구글링으로 공부를 하기도 하고 넷플릭스나 모바일 게임을 즐기며 딱히 지루하지 않은 시간들을 보내고 있었지만.. 잠을 더 오래 잘 수 있고, 퇴근이 빠르고! 좀 더 게을러질 수 있었다.(?)

놀 게 너무 많다!!

집에는 놀 게 너무 많다!! 당장 내 책상을 보면 바로 앞에 데스크탑, 노트북 (노트북은 업무용으로 사용합니다), 닌텐도 스위치, 스마트폰, 태블릿..!! 유혹이 너무나 많다..

심지어 옆으로 고개만 돌리면 침대가 보이니.. 할 말 다 했다.

유혹을 참고 일을 하려니 너무 힘들다 ㅎㅎ.. 그렇다고 온전히 일만 8시간 꽉 채워서 한다고 할 수는 없지만..!! 딴 짓은 최대한 안 하려고 하는 편이다.

최근에는 이를 방지하기 위해 스터디 카페를 간다. 적어도 업무 보는 시간엔 휴게 공간이랑 분리해두는 게 좋은 것 같다.

덕분에 재택임에도 업무 능력 상승!!

그럼에도 나는 회사로 출근하는 게 더 맞는 것 같다....

2021년의 나를 평가하자면?

신입!! 말 그대로 신입 그 자체였다.

좌충우돌 개발자 적응기이며, 꿈만 큰 똥덩어리(?)랄까..

열심히 하고자 하는 의욕은 넘치고 배우고자 하는 마음도 크지만 당장에 실력은 없는.. 그런 상태다.

그럼에도 불구하고 정말 많은 걸 배웠다는 확신은 있는 그런 한 해였다. 정말, 많은 성장을 할 수 있는 한 해였다.

지금 계속해서 포스팅하고 있는 Golang 기초 시리즈는 꽤 오래 지속될 것으로 보인다. 당장 1년 동안 사용한 Golang이지만 아직까지도 제대로 활용하고 있지 못하다는 느낌이 크다.

공부를 완벽히 해두고 시작한 게 아닌 탓일까, 아니면 아직도 공부하는 방법을 모르는 걸까.

아무튼 기초 시리즈를 포스팅하면서 새로 배우는 것들도 많고 다시 한 번 생각하게 되는 그런 시간들을 가지고 있다.

사회 초년생, 신입 개발자

이 두 가지 타이틀을 걸고 열심히, 치열하게 살아낸 2021년이다.

'나, 이제 제법 개발자의 모습을 갖췄을지도?' 라고 착각을 하곤 한다.

내년엔 어떤 일들이 있을까? 내가 만들고 있는 서비스는 무사히 런칭할 수 있을까? 나는 어떤 개발자가 되어 있을까?

당장에 기대되는 것들이다.

내년엔 제대로 Gopher가 돼 보겠다.

새해 다짐

항상 발전하자. 그리고 거기에 안주하지 말자!

이상입니다.👍

이번에 다룰 내용은 반복문입니다.

Golang에서의 반복문은 오로지 for를 사용하는 방법만 존재합니다. 물론 이 for문을 어떻게 사용하느냐에 따라 다른 언어에 존재하는 반복문 형태를 손쉽게 구현할 수 있습니다.

📌 반복문

반복문은 코드의 반복을 위해 존재합니다. 간단한 작업같아도 반복된 작업을 해야 할 때, 우리는 반복문을 사용합니다. 이는 코드의 간결화, 가독성 확보를 위해 꼭 필요합니다. 반복문의 사용은 이중, 삼중으로도 사용이 가능한데 너무 많이 겹쳐두는 것은 좋지 않습니다. 가독성도 좋지 않고, 유지•보수하기 좋지 않습니다. 제 경우엔 삼중을 최대로 두려고 합니다.

그렇다고 겹겹이 쌓인 반복문을 함수로 처리하는 게 좋은가? 그건 또 아닙니다. 콜스택이 쌓이면 퍼포먼스에서 미세하게 차이가 날 수 있으므로 적절한 타협이 필요합니다. 물론 퍼포먼스에 큰 차이는 없지만 극한의 퍼포먼스를 보장해야 하는 상황이라면 직접 테스트하고 사용해야 합니다.

만약, 반복문이 여러 번 반복된다면 해당 역할을 하는 함수를 작성해서 처리하는 방법이 코드의 간소화 및 유지•보수를 위해 좋을 것입니다.

반복문이 있음으로써 할 수 있는 것들은 무궁무진합니다. 가령, 1부터 1000까지의 정수를 출력할 때에도 1000줄을 쓰느냐, 3줄을 쓰느냐는 큰 차이입니다.

📝 반복문의 종류와 사용

위에서 말씀드린 것처럼 Go에서는 for문만을 제공합니다. 하지만, 이 for문으로 표현할 수 있는 반복문의 종류는 여러 가지 있습니다. Effective go에서는 Golang의 반복문을 이와 같이 설명하고 있습니다. Golang에는 do-while이 없습니다.

📍 for init; condition; post {...} : C-Like for

for i := 0; i < 1000; i++ {
    fmt.Printf("%d ", i)
}
/* The result of output
0 1 2 3 ... (중략) 999 
*/

for 선언; 조건; 후처리 작업 {...}

C언어에서 사용하듯이 위와 같이 작성할 수 있습니다. 가장 기본적인 형태이며, 제어하기 가장 쉬운 형태라고 볼 수 있습니다.

📍 for condition {...} : C-Like while

i := 0
for i < 1000 {
    fmt.Printf("%d ", i)
}
/* The result of output
0 1 2 3 ... (중략) 999 
*/

for 조건 {...}

C언어에서 사용하는 while문을 이렇게 표현할 수 있습니다. 위의 for문은 i < 1000이라는 조건을 만족하는 중에만 실행됩니다. {...}안에 i값을 증가시키거나 다른 특정한 조건을 넣어, i값을 1000보다 큰 값으로 만들어 루프(반복문)를(을) 탈출할 수 있습니다. (아래에 소개하는 break를 이용해서 탈출할 수도 있습니다.)

📍 for {...} : C-Like for(;;)

i := 0
for {
    if i >= 1000 {
        break
    }
    fmt.Printf("%d ", i)
    i++
}
/* The result of output
0 1 2 3 ... (중략) 999 
*/

C언어에서 사용하는 무한 루프를 이렇게 표현할 수 있습니다. 아무런 조건이 없어, 그저 무한으로 반복되는 루프입니다. 탈출 조건을 명시하지 않으면 컴퓨터의 리소스를 모두 사용할 때까지 무한히 반복됩니다. 위의 코드에서는 i의 값이 1000 이상일 경우, break를 실행하게 했습니다. break문을 실행하면 루프를 탈출하게 됩니다.

📍 for - range : 'for loop' for array, slice, string, or map, or reading from a channel

var array [4]string
array[0] = "Hi"
array[1] = "this"
array[2] = "is"
array[3] = "array"
for i, v := range array {
    fmt.Printf("index : %d \t value : %s \n", i, v)
}
/* The result of output
index : 0        value : Hi 
index : 1        value : this 
index : 2        value : is 
index : 3        value : array 
*/

for 인덱스, 요소 := range 배열 {...}

(array, slice, string, map, channel은 아직 다루지 않은 내용이므로 추후 포스팅할 때 링크 걸어두도록 하겠습니다.) 간단하게 위에 사용된 array에 대해서만 설명하겠습니다. array는 '배열'이며, 값들을 저장합니다.

1. 변수 array를 string 타입 4개짜리 배열로 선업합니다.
2. 각 인덱스 요소에 string 타입 값을 넣습니다. 이 때, 인덱스는 0부터 시작해서 3까지만 넣을 수 있습니다. (값을 넣지 않은 요소에는 zero-value(기본값)가(이) 들어갑니다.)
3. for를 사용해, 배열의 인덱스와 요소들을 모두 순차적으로 출력합니다.

for-range 문은 아래와 같이 사용할 수 있습니다.

for i, v := range array {...}

• 인덱스, 요소 모두를 사용해야 할 때 사용합니다.
  for i := range array {...}
• 인덱스만 사용할 때 사용합니다.
  for _, v := range array {...}
• 요소만 사용할 때 사용합니다.

📍 for - range : 'for loop' for strings

for i, v := range "yes, array" {
    fmt.Printf("index : %d \t value : %c \n", i, v)
}
/* The result of output
index : 0        value : y 
index : 1        value : e 
index : 2        value : s 
index : 3        value : , 
index : 4        value :   
index : 5        value : a 
index : 6        value : r 
index : 7        value : r 
index : 8        value : a 
index : 9        value : y 
*/

for 인덱스, 요소 := range "문자열" {...}

위와 같이 평범한 strings에 대해서도 사용이 가능합니다. 이 때, v로 받는 값이 각 문자가 되며, 문자 출력을 위해 %c를 사용합니다.

📍 'for loop' with parallel assignment

a := [4]string{"Hi", "this", "is", "array"}
for i, j := 0, len(a)-1; i < j; i, j = i+1, j-1 {
    a[i], a[j] = a[j], a[i]
}
for i, v := range a {
    fmt.Printf("index : %d \t value : %s \n", i, v)
}
/* The result of output
index : 0        value : array 
index : 1        value : is 
index : 2        value : this 
index : 3        value : Hi 
*/

for 변수1, 변수2 := 변수1의 값, 변수2의 값; 조건식; 변수1, 변수2 = 변수1에 대한 계산식, 변수2에 대한 계산식 {...}

C언어에서 위와 같이 배열의 순서를 뒤바꾸기 위해서 우리는 'tmp'라는 변수를 만들어 사용하곤 했습니다. Golang에서는 그럴 필요 없이 '병렬 할당'을 이용하면 됩니다.

병렬 할당

a, b := 1, 100

위의 코드는 좌항 a와 b에, 우항 1과 100을 순차적으로 할당합니다.

📍 'loop' using Label

    var i int = 0
Label1:
    if i >= 1000 {
        goto Label2
    }
    fmt.Printf("%d ", i)
    i++
    goto Label1
Label2:
    fmt.Println("finished")
    /* The result of output
    0 1 2 3 ... (중략) 999 finished
    */

레이블명: 레이블명은 대소문자 관계없이 지정할 수 있다.

Label은 위와 같이 사용할 수 있습니다. 레이블은 특정한 조건에 실행해야 하는 코드를 감싸고 있는 플래그라고 보시면 됩니다. 또, 루프의 기능을 하기 위해 만들어진 것은 아니기 때문에 goto를 사용해 특정 Label로 이동하는 것을 볼 수 있습니다.

📍 'for loop' using Label 2

    var i int = 0
Label1:
    for {
        if i >= 1000 {
            break Label1
        }
        fmt.Printf("%d ", i)
        i++
    }
    fmt.Println("finished")
    /* The result of output
    0 1 2 3 ... (중략) 999 finished
    */

Golang에서는 위와 같이 루프에 Label을 붙이고 해당 Label을 break해서 탈출할 수 있습니다.

📌 반복문의 탈출

반복문을 특정한 조건이 되면 그만두고 싶을 때, 탈출 조건을 명시해야 한다고 했습니다. 탈출 뿐만 아니라, 특정 조건에서의 반복문 점프도 가능합니다.

📝 반복문 탈출의 종류와 사용

반복문을 제어하기 위해 사용할 수 있는 것들은 continue, break, goto가 있습니다.

📍 break : to escape current loop

무한 루프가 아니더라도 반복문을 수행하다가 특정 조건에 해당 반복문을 빠져나와야 할 때 사용합니다.

a := 0
for {
    if a >= 10 {
        break
    }
    a++
}
fmt.Println("value of a :", a)
/* The result of output
value of a : 10
*/

위와 같이 무한 루프에서는 break를 사용해서 '현재'루프를 탈출합니다. 만약 이중 for문을 사용했고 가장 안 쪽 루프에서 break를 사용했다면 가장 안 쪽 루프만 탈출하게 됩니다.

📍 continue : to skip current iteration

반복문을 짜다 보면 특정 조건에서 넘어가게 만들어야 할 때가 있습니다. 그럴 때 continue는 유용하게 쓰입니다.

b := 0
for {
    if b < 10 {
        b++
        continue
    }
    fmt.Println("value of b :", b)
    break
}
/* The result of output
value of b : 10
*/

b는 0부터 시작해, 1씩 증가합니다. 또, if조건문 이후에 나오는 결과 출력하는 부분이 있습니다. 하지만, 0부터 9까지는 continue를 만나게 돼, 출력 파트는 실행되지 않습니다.

📍 goto : to go to specific Label in the code

반복문 소개하며 보여드린 Label 파트와 중복되는 부분입니다만 goto를 다시 소개하겠습니다.

    c := 0
    for {
        if c >= 10 {
            goto Label1
        }
        c++
    }
Label1:
    fmt.Println("value of c :", c)
/* The result of output
value of c : 10
*/

역시 무한 루프를 돌다가 조건이 만족하면 goto Label1로 Label1으로 이동하여 루프를 탈출합니다.

📍 break Label : to escape from the Label loop

이 역시 위에서 한 번 언급이 있었으나, 다시 한 번 소개하겠습니다.

    d := 0
Loop1:
    for {
        if d >= 10 {
            break Loop1
        }
        d++
    }
    fmt.Println("value of d :", d)
/* The result of output
value of d : 10
*/

무한 루프에 레이블을 지정했고, 특정 조건에 break Loop1을 통해 Loop1 레이블에서 탈출할 수 있게 했습니다. 이렇게 루프에 레이블을 지정하면 특정 조건에 다시 해당 레이블로 이동해서 코드를 동작할 수 있다는 장점이 있습니다. 물론 위와 같이 탈출 조건을 명시해서 여러 번 사용할 수도 있습니다.

이번 포스트는 반복문에 대한 내용이었습니다. 감사합니다.👍

이번 포스트는 조건문에 대해 다루겠습니다.

조건문

조건문은 특정한 조건을 만족했을 때 실행하는 문장(코드) 을(를) 말합니다. golang에서 조건문은 if / switch 두 가지가 있습니다.

if문

조건을 만족하는지는 bool (true / false) 값으로 판단합니다. 조건문 if문은 아래와 같이 사용할 수 있습니다.

'if' : 만약에

조건문 '만일 어떠한 조건을 만족한다면~' {
'이 코드를 실행해라'
} 

'else if' : 아니면 이렇다면

아니면 이렇다면 {
'이 코드를 실행해라'
}

'else' : 아니면

아니면 {
'이 코드를 실행해라'
}

Golang에서는 아래와 같이 사용할 수 있습니다.

if condition1 {
    // TODO1
} else if condition2 {
    // TODO2
} else {
    // TODO3
}
// (단, condition1, condition2(은)는 각각 bool 값을 가짐)

Golang에서의 'else if'와 'else'는 항상 if문이 끝나는 라인에 함께 써주어야 합니다.

if만 사용하면 안 될까?

if만 사용하면 안 될까? 안 되는 건 없습니다. 다만 비효율적이고 그렇게 하지 말아야 한다고 배웠을 뿐입니다. 이유를 한 번 파헤쳐 봅시다.

조건 A, B에 대하여 모든 경우의 수에 그에 맞는 특정한 코드를 실행해야 합니다.

먼저 if-else문을 보겠습니다.

if A && B {
    // TODO AB
} else if A {
    // TODO A
} else if B {
    // TODO B
} else {
    // TODO nothing ..
}

A와 B 모두 참인지 확인했고, 모두 참은 아닐 때, A가 참인지를 확인했고, 아니라면 B가 참인지를 확인했고, 그것도 아니라면 TODO nothing .. 파트를 실행합니다.

다음은 if만 사용한 경우를 보겠습니다.

if A && B {
    // TODO AB
}
if A && !B {
    // TODO A
}
if !A && B {
    // TODO B
}
if !A && !B {
    // TODO nothing ..
}

A와 B 모두 참인지 확인했습니다. A가 참이고 B가 거짓일 때를 확인했습니다. A가 거짓이고, B가 참일 경우를 확인했습니다. A와 B 모두 거짓일 때를 확인했습니다.

제가 쓴 문장들을 보시면 if-else에서는, '~했고, ~했고, ~했고'가 쓰였습니다. 연속된 것으로 볼 수가 있습니다. 또한, A에 대한 검증이 끝난 이후에는 A가 참인지 거짓인지는 확인하지 않았습니다.

반면에, if만 사용한 부분에서는, '~했습니다. ~했습니다. ~했습니다.'가 쓰였습니다. 연속적이지 않고, 모든 조건들이 독립되어 있음을 알 수 있습니다. 또한, A에 대한 검증이 끝난 것 같은데도 다시 A에 대하여 검증해야 했습니다. A에 대한 검증을 다시 넣지 않았다면 A가 참이든 거짓이든 상관없이 B에 대한 검증만 하는 조건이 됐을 겁니다.

같은 조건에 대하여 중복된 검증은 좋지 않습니다. 조건이라 함은 조건 연산으로 이루어져 있으며, 연산은 중복해서 수행하면 정확도에 관계없이 당연히 속도가 낮고, 퍼포먼스 저하로 이어집니다. 따라서 모든 프로그램 언어에서 if만 사용하는 것은 권장하지 않습니다.

if문 예제

if 조건문을 사용하기에 앞서, 조건에 따라 다른 값을 반환하는 함수를 정의하고 시작하겠습니다. 입력값은 정수로 하고, 음수나 양수에 상관없이 양수를 반환하는 함수를 작성하겠습니다.

절댓값 반환 예제

func AbsoluteValue(input int64) int64 {
    if input < 0 {
        return -input
    }
    return input
}

if input < 0 : 함수의 입력값 'input'이 0보다 작을 경우, {괄호} 안의 코드를 실행함 return -input : 음수일 경우에 실행되는 코드이므로, 앞에 '- (마이너스)'를 붙여 양수로 만들고 반환함 return input : if 조건문이 조건에 맞지 않아 실행되지 않을 때 (입력값이 양수일 때), 실행됨

이렇게 사용할 수 있습니다. 그럼 if 하나 당 조건 하나만 체크할 수 있는가?

아닙니다. && 연산자로 아래와 같이 여러 조건을 동시에 만족할 경우를 작성할 수 있습니다.

절댓값 반환 예제 + 타입 변환

func AbsoluteValue(input int64) uint32 {
    if input < 0 && -input <= 4294967295 {
        return uint32(-input)
    }
    if input < 0 && -input > 4294967295 {
        return uint32(4294967295)
    }
    if input >= 0 && input <= 4294967295 {
        return uint32(input)
    }
    if input >= 0 && input > 4294967295 {
        return uint32(4294967295)
    }
    return uint32(input)
}

'4294967295'는 uint32의 최댓값입니다. 4294967295에 1을 더해, 4294967296이 되면 오버플로우가 발생해, 값이 0이 됩니다. 4294967295에 2를 더한 결과값은 1이 됩니다.

if input < 0 && -input <= 4294967295 : input이 0보다 작은 음수이며, 이를 절댓값으로 만들었을 때의 결과값이 uint32의 최댓값과 같거나 작을 경우에만 실행함

switch문

switch는 표현식의 값을 case절의 표현식과 일치하는지 체크하고, 일치한다면 해당 case절을 실행시킵니다. golang에서 특이한 점은, break문을 사용하지 않아도 case 한 개만 실행하고 탈출한다는 점입니다. break문은 컴파일 단계에서 컴파일러가 추가해 줍니다.

switch문 예제

값이 일치할 때 실행하는 switch

첫 번째로 볼 예제는 값이 일치할 때 실행하는 switch문입니다.

package main
>
import "fmt"
>
func main() {
    var name string = "vamos"
    switch name {
    case "vamos":
        fmt.Printf("name is %s\n", name)
        fmt.Println("but it is not a name")
    case "eon kim":
        fmt.Printf("name is %s\n", name)
        fmt.Println("yes, it is your name")
    default:
        fmt.Println("other..")
    }
}

• var name string = "vamos" : name 변수를 string 타입으로 선언하고, 그 값으로 "vamos"를 넣었습니다.
• switch name {...} : switch문의 시작함 (여러 가지 작성법 중에 한 가지입니다.)
• case "vamos": : name과 case절의 표현식의 값이 일치하면 해당 case절을 실행함 (이 예제에서는 name과 case절의 "vamos"가 서로 같은 값을 가지고 있어, 이 case절을 실행합니다.)
• case "eon kim": : name의 값이 "eon kim"이 아니므로, 이 case절은 무시함
• default: : 위의 case절 모두 일치하는 게 없으면 실행함 (default절은 없어도 상관없습니다.)

표현식을 사용하는 switch

두 번째로 볼 예제는 표현식을 사용하는 switch문입니다.

package main
>
import "fmt"
>
func main() {
    var x uint8 = 1
    switch fx := x*3 + 2; fx {
    case 14:
        fmt.Println(fx)
        fmt.Println("1st case")
    case 11:
        fmt.Println(fx)
        fmt.Println("2nd case")
    case 8, 5:
        fmt.Println(fx)
        fmt.Println("3rd case")
    default:
        fmt.Println("other..")
    }
}

• switch fx := x*3 + 2; fx {...} : switch문 안에서만 사용할 수 있는 변수 fx를 선언하고, 표현식 x*3 + 2를 지정합니다. 그리고, case절과 일치시킬 값으로 fx를 그대로 사용함 (여기서 fx를 그대로 사용하지 않고 싶다면 fx + 1이든 어떠한 식의 변형을 해서 사용할 수도 있습니다.)
• case 8, 5: : 마찬가지로 fx의 값이 일치할 경우에 실행합니다. 여기서 case절은 두 개의 값의 경우 모두에 대하여 해당 case절을 실행함 ('8 || 5'와 같다고 보시면 됩니다.)

표현식을 사용하는 case

세 번째로 볼 예제는 표현식을 사용하는 case절입니다.

package main
>
import "fmt"
>
func main() {
    var x uint8 = 3
    var y uint8 = 25
    switch y {
    case x*3 + 2:
        fmt.Println(y)
        fmt.Println("1st case")
    case x*5 + 3:
        fmt.Println(y)
        fmt.Println("2nd case")
    case x*7 + 4, x*9 + 5:
        fmt.Println(y)
        fmt.Println("3rd case")
    default:
        fmt.Println("other..")
    }
}

• case x*3 + 2: : 표현식 x*3 + 2 를 case절에 사용했고, y의 값이 case절의 값과 같으면 실행함
• case x*7 + 4, x*9 + 5: : 여기서 y값은 x*7 + 4의 결과와 값이 같으므로, 이 부분의 case절을 실행함

case절에 조건식을 사용하는 switch

네 번째로 볼 예제는 case절에 조건식을 사용하는 switch문입니다.

package main
>
import "fmt"
>
func getGrade(score uint8) (grade string) {
    switch {
    case score > 100:
        grade = "Try again.. "
    case score >= 90:
        grade = "A"
    case score >= 80:
        grade = "B"
    case score >= 70:
        grade = "C"
    case score >= 60:
        grade = "D"
    case score < 60:
        grade = "F"
    }
    return
}
>
func main() {
    fmt.Print("Your score : ")
    var myScore uint8
    fmt.Scanf("%d", &myScore)
    myGrade := getGrade(myScore)
    fmt.Println(myGrade)
}

• fmt.Scanf("%d", &myScore) : 정수를 입력 받아, myScore에 저장함
• myGrade := getGrade(mySocore) : getGrade()함수의 파라미터로 myScore를 사용하고, 반환값을 myGrade에 넣음
• switch {...} : switch문임을 나타내고, case절의 조건에 따라 실행합니다.
• case score > 100: : 입력받아, 파라미터로 넘겨받은 score값이 100이 넘어가면 해당 case절을 실행함

fallthrough를 사용하는 switch

다섯 번째로 볼 예제는 fallthrough를 사용하는 switch문입니다. golang에서는 break문을 작성하지 않으면 컴파일러가 추가하여 자동으로 case절 하나만 실행하고 탈출한다고 했습니다. 연속적으로 case절 여러 개를 실행해야 할 때는 fallthrough를 사용합니다.

package main
>
import "fmt"
>
func main() {
    var test uint8 = 3
    switch test {
    case 1:
        fmt.Println(test)
        fmt.Println("1st case")
    case 2:
        fmt.Println(test)
        fmt.Println("2nd case")
    case 3:
        fmt.Println(test)
        fmt.Println("3rd case")
        fallthrough
    case 4:
        fmt.Println(test)
        fmt.Println("4th case")
        fallthrough
    default:
        fmt.Println("other..")
    }
}

• fallthrough: 해당 case절이 실행되고, 바로 다음 case절도 실행함

Type switch

여섯 번째로 볼 예제는 Type을 case절로 판단하여 실행하는 switch문입니다. Effective go : Type Switch

package main
>
import "fmt"
>
func functionOfSomeType() int {
    return 0
}
>
func main() {
    var t interface{}
    t = functionOfSomeType()
    switch t := t.(type) {
    default:
        fmt.Printf("unexpected type %T\n", t) // %T prints whatever type t has
    case bool:
        fmt.Printf("boolean %t\n", t) // t has type bool
    case int:
        fmt.Printf("integer %d\n", t) // t has type int
    case *bool:
        fmt.Printf("pointer to boolean %t\n", *t) // t has type *bool
    case *int:
        fmt.Printf("pointer to integer %d\n", *t) // t has type *int
    }
}

• t.(type) : t의 type을 값으로 하여 case절을 실행함 (type assertion이라고 하며, 위는 이를 사용하는 방법 중 하나입니다.)

위와 같이 type으로도 case절을 실행할 수 있습니다.

이번 포스트는 조건문에 대한 내용이었습니다. 감사합니다.👍

이번 포스트에서는 함수에 대해서 다루겠습니다.

📌 함수 : function

함수는 수학에서 f(x) 로 표현합니다. 그리고 함수 f(x)는 어떠한 수식을 담고 있습니다. f(x) = x + 5 f(3) = 3 + 5 = 8 이렇게 표현하곤 합니다. 컴퓨터에서의 함수는 언어마다 사용하는 방법만 조금 다를 뿐, 수학에서의 함수와 다를 바 없습니다. 입력값에 대한 출력값, 이게 함수입니다. f(x)라는 함수에 입력값 3를 넣어, 함수의 동작으로 5를 더한 뒤, 출력값 8이 반환되었습니다.

컴퓨터에서의 함수 또한 입력값과 반환값으로 되어 있고, 이를 사용해 프로그램을 구성합니다.

📍 The rule of naming in Golang

Golang에서 변수나 함수의 이름을 작성하는 방법은 정해져 있어, 매우 쉬운 편입니다. (그저 이름을 뭐로 지을지가 고민일뿐..)

현재 패키지 외부에서도 쓰일 수 있게 하려면 대문자로, [Unicode upper case letter (Unicode class "Lu");] 현재 패키지 내부에서만 쓰일 수 있게 하려면 그 외의 문자로 시작하면 됩니다.

이는 사용자 간의 약속이 아닌 Golang 자체적 기능으로 분류된 것입니다. 영대문자가 아닌 문자로 선언된 변수나 함수는 전부 외부 패키지에서 다룰 수 없습니다. go.dev/ref/spec#Exported_identifiers

변수나 함수를 한글로 이름 짓기

Golang은 기본 인코딩이 UTF-8입니다. 따라서, 한글로 된 이름도 선언이 가능합니다.

UTF-8 문자로 패키지 외부에서 사용할 수 있게 하려면 반드시 문자 앞에 영대문자를 붙여주어야 합니다. "한글함수" => "A한글함수" "한글변수" => "A한글변수"

📍 The format of function in Golang

Golang에서의 함수는 다음과 같이 사용할 수 있습니다.

func NameOfFunc(a int, b int) (isTrue bool) {
    isTrue = (a == b)
    return
}

• func : function(함수)의 약자로, 함수를 정의할 때 꼭 포함해야 함
• NameOfFunction : 함수의 이름이며, 영대문자로 시작하기 때문에 외부 패키지에서도 사용이 가능함
• (a int, b int) : 함수 내에서 사용될 매개변수 a와 b를 각각 int로 선언함
• (isTrue bool) : 함수의 반환값을 변수 isTrue로 하며, 해당 변수는 bool 타입임
• { ... } : 함수의 내용을 적는 파트이며, 자유롭게 작성함
• isTrue = (a == b) : 비교 연산자 '=='으로 변수 a와 b가 동일한지 체크함
  • a == b 가 참일 때는 true, 거짓일 때는 false를 반환함
• return : 값을 반환함 -> 반환할 값을 변수 isTrue로 지정했기 때문에 변수명을 적지 않아도 됨

아래는 같은 기능을 하는 함수를 다르게 표현함

func nameOfFunc(a, b int) bool {
    isTrue := (a == b)
    return isTrue
}

• nameOfFunc : 함수 이름이며, Lu class 문자가 아니기 때문에 외부 패키지에서 불러올 수 없음
• (a, b int) : 변수 a와 b 모두 int타입이라, 한 번에 선언함
• bool : 반환값의 타입만 명시하고 반환할 값은 지정하지 않음
• isTrue := (a == b) : isTrue 변수를 (a == b) 결과값에 맞는 타입으로 선언함
• return isTrue : bool 타입 변수인 isTrue를 반환함

• 참고 : Golang에는 삼항 연산자가 없다. return (a == b) ? true : false 를 하고 싶으나, Golang에서는 불가하다.*
• *go.dev/doc/faq#Does_Go_have_a_ternary_form**

📍 The usage of function in Golang

Golang에서 함수를 사용하는 방법은 다음과 같습니다.

프로젝트에서 위와 같이 직접 작성하거나, 외부 패키지를 임포트하여 해당 패키지의 함수를 사용할 수 있습니다.

아래는 main 함수에서 위에 작성한 함수를 사용하는 방법입니다.

package main
>
import "fmt"
>
func nameOfFunc(a, b int) bool {
    isTrue := (a == b)
    return isTrue
}
>
func main() {
    isOk := nameOfFunc(3, 5)
    fmt.Println(isOk)
}

• package main : main 패키지이며, 해당 프로그램의 진입 패키지임
• import "fmt" : 아래 main 함수에서 결과값 출력을 위해 import함
• func main() { ... } : main 함수는 매개변수와 반환값이 없어야 함; 프로그램 실행 시, 가장 먼저 실행되는 함수라서 어떠한 매개변수도 전달받지 않으며, main 함수의 내용이 순차적으로 실행되고 main 함수가 모두 실행되면 프로그램이 종료됨
• isOk := nameOfFunc(3, 5) : isOk라는 변수를 선언하며 값으로는 nameOfFunc(3, 5)의 반환값을 넣음
• nameOfFunc(3, 5) : nameOfFunc() 함수에 매개변수 3과 5를 전달하며, 이는 각각 위의 nameOfFunc() 함수의 변수 a와 b로 사용됨

이렇게 여러 가지 기능을 함수로 구현하고, 그 기능들을 복합적으로 활용하여 프로그램이 만들어집니다.

📍 The recursive function in Golang

recursive function은 재귀함수라고 합니다. 함수 자기 자신이 자기 자신을 다시 호출하는 방식입니다. 이 방식은 call stack이 많이 쌓일 수 있어서 그리 선호되는 방식은 아닙니다.

위 그림과 같이 main()에서 recursiveAddFunc()를 호출하고, 그 안에서 다시 recursiveAddFunc()을 호출하고, 그 안에서 ...

이렇게 반복되다가 탈출 조건을 만나고, 값을 return할 때,

한 번에 해당 값이 main()으로 반환되는 것이 아니라 콜스택 가장 위에 있는 함수에서 이전 함수로 반환하고, 그리고 또 이전 함수로 반환하고, 그리고 또 이전 ...

결국 최종적으로 얻고 싶었던 값조차 재귀함수가 호출된 횟수만큼 return을 거쳐야 하기 때문에 비효율적입니다. 가급적 반복적인 기능 수행이 필요한 경우에는 반복문을 통해서 수행하고, 재귀함수는 꼭 필요한 때에만 사용하도록 하는 게 좋습니다.

Golang에서 재귀함수는 다음과 같이 구현할 수 있습니다.

package main
>
import "fmt"
>
func recursiveAddFunc(a, b int) int {
    a += b
    if a < 100 {
        fmt.Println("Before recursive call, a is :", a)
        a = recursiveAddFunc(a, b)
        fmt.Println("After recursive call, a is :", a)
    }
    return a
}
>
func main() {
    fmt.Println(recursiveAddFunc(5, 3))
}

• a += b : a에 b를 더한 값을 a에 대입함
• if a < 100 { ... } : a가 100보다 작을 때, 조건문 내의 내용을 수행함; 이 코드의 재귀함수 탈출 조건으로 사용되었으며, a가 100보다 커지면 if 조건문을 넘어가서 return a 를 수행함 (추후 다른 포스트에서 다룰 내용임)
• a = recursiveAddFunc(a, b) : 재귀함수 호출을 하고, 반환값을 a에 대입함
• func main() { fmt.Println(recursiveAddFunc(5, 3)) } : recursiveAddFunc(5, 3)의 반환값을 출력함

• • 위의 코드 실행으로, 재귀함수 동작을 이해하기 좋습니다. **

📍 예제 : Calculator 계산기

아래는 Golang으로 만든 간단한 사칙연산 계산기 프로그램입니다. 아직 조건문에 대한 내용을 다루지 않아 함수로만 구현하였고, 한 번에 모든 연산에 대한 결과를 출력하는 프로그램입니다.

package main
>
import "fmt"
>
func addFunc(a, b int) int {
    return a + b
}
func subFunc(a, b int) int {
    return a - b
}
func mulFunc(a, b int) int {
    return a * b
}
func divFunc(a, b int) int {
    return a / b
}
func modFunc(a, b int) int {
    return a % b
}
func main() {
    var x, y int
    fmt.Println("write two values to calculate..")
    fmt.Println("format : 'value1 value2' then 'press Enter'")
    fmt.Scanf("%d %d", &x, &y)
    fmt.Println("result of addFunc(x, y) is :", addFunc(x, y))
    fmt.Println("result of subFunc(x, y) is :", subFunc(x, y))
    fmt.Println("result of mulFunc(x, y) is :", mulFunc(x, y))
    fmt.Println("result of divFunc(x, y) is :", divFunc(x, y))
    fmt.Println("result of modFunc(x, y) is :", modFunc(x, y))
}

** 실행 후, 연산을 수행할 값 두 개를 입력하면 결과가 출력됩니다. **

이번 포스트는 함수에 대한 내용이었습니다. Go도 익명함수가 있습니다. 다만 나중에 다루도록 하겠습니다. 감사합니다.👍

이번 포스트는 Golang의 가장 기본적인 표준 라이브러리인 fmt 패키지를 다루겠습니다.

📌 fmt package   📍 변수   📍 변수의 출력   📍 변수의 입력   📍 문자열 반환

📌 연산자   📍 사칙 연산   📍 비트 연산   📍 시프트 연산

📌 fmt package

fmt는 Formatted I/O(Input / Output)를 구현한 패키지입니다. C언어의 표준 입출력 라이브러리인 stdio.h의 역할이라고 보시면 됩니다. fmt 패키지를 import함으로써 입출력을 가능하게 합니다. 처음 Golang 설치를 확인하기 위해 Hello World!!를 출력했었습니다.

package main // 해당 프로젝트의 시작점을 알리며, 항상 main으로 존재해야 함

import "fmt" // fmt 패키지를 임포트하여 사용할 수 있는 상태로 만듦

func main() { // 해당 패키지의 가장 처음에 실행되는 함수이며, 항상 main으로 존재해야 함
    fmt.Println("Hello World!!") // fmt 패키지의 Println 함수를 사용해, Hello World!!를 출력하고 개행함
}

이와 같이 fmt 패키지는 입력과 출력을 가능하게 하며 모든 실행의 결과물을 출력할 수 있게 됩니다. 컴퓨터의 연산과 계산 결과 등을 출력할 수 있습니다. 1 + 1의 결과 2를 결과물로 볼 수 있게 되는 것입니다. 딱히 하나도 놀라울 것이 없지만 fmt 패키지가 없다면 우리는 우리의 코드가 제대로 작성된 것인지 파악하기가 굉장히 어려울 것입니다.

📍 변수

변수는 변하는 수를 의미합니다. 상황에 따라서 값을 변경함으로써 프로그램의 동작을 구현하고 제어합니다. 변수는 메모리에 저장됩니다. 그리고 변수를 통해, 값이 담긴 주소을 알 수 있고, 그 주소에 저장된 값을 불러올 수 있습니다.

fmt docs : 포맷 지정자 (%d, %f, %s ...)

출력 값의 자릿수를 지정할 수 있습니다. 자릿수를 넘어가면 값 그대로를 출력합니다. %5d : 정수형 값을 5자리로 출력합니다. 5자리보다 작은 값인 경우, 공백으로 채웁니다. %05d : 정수형 값을 5자리로 출력합니다. 5자리보다 작은 값인 경우, 0으로 5자리를 맞춥니다. 등 여러 가지 포맷 지정 방법이 있습니다. 아래에서 설명할 때 등장하는 포맷 지정자는 다음과 같습니다. : %d, %s, %c, %08b

📍 변수의 출력

모든 변수는 값을 가지며, 그 값은 출력할 수 있습니다. 변수의 타입마다 출력할 수 있는 방식이 정해져 있고, 그 방식은 한 가지로 국한되지 않습니다. 본인이 원하는 대로 출력하기 위해서는 아래에 설명하는 출력 방식을 모두 사용할 수 있어야 합니다.

기본 출력 함수 func Print

func Print(a ...interface{}) (n int, err error)
// Print formats using the default formats for its operands and writes to standard output. 
// Spaces are added between operands when neither is a string. 
// It returns the number of bytes written and any write error encountered.

Printf() 함수는 출력 시에 변수의 기본 타입에 맞추어 출력합니다. 공백을 출력하고 싶다면 string 타입에 맞추어 " "로 표현해야 합니다. 인자를 함수에 넣을 때, 공백을 넣더라도 string 타입으로 넣지 않으면 아무 의미 없습니다.

package main

import "fmt"

func main() {
    var x int8 = 5
    var y int8 = 3
    fmt.Print("x is ", x, "\n", "y", "is", y, "\n")
}
// x is 5
// yis3

공백 포함 출력 함수 func Println

func Println(a ...interface{}) (n int, err error)
// Println formats using the default formats for its operands and writes to standard output.
// Spaces are always added between operands and a newline is appended.
// It returns the number of bytes written and any write error encountered.

Println() 함수는 Print() 함수와 다르게 각 인자 사이에 공백 string을 추가하며, 줄 끝에 개행을 덧붙입니다. 아래의 Printf() 함수와 더불어 가장 많이 사용하는 함수입니다.

package main

import "fmt"

func main() {
    var x int8 = 5
    var y int8 = 3
    fmt.Println("x is ", x, "\n", "y", "is", y)
}
// x is  5 
//  y is 3
// **" y is 3" : y앞에 공백 하나가 포함돼 있는 것이 맞습니다.

포맷 지정 출력 함수 func Printf

func Printf(format string, a ...interface{}) (n int, err error)
// Printf formats according to a format specifier and writes to standard output.
// It returns the number of bytes written and any write error encountered.

변수의 출력을 특정한 형식으로 지정하여 출력할 수 있습니다. 표준 입출력 fmt 패키지에서는 Printf() 함수만이 가능합니다. fmt.Printf package docs

Printf 함수는 string 타입으로 format을 지정하고 표준 출력을 수행합니다. 함수 동작이 끝나면 byte 수와 에러를 반환합니다. Hello World!!를 출력하고 그에 대한 결과를 보겠습니다.

package main

import "fmt"

func main() {
    fmt.Printf("%s\n", "Hello World!!")
    // 포맷 지정자를 string으로 정하고 개행문자를 포함했습니다.
    // %s에 들어갈 값으로 "Hello World!!"를 넣습니다.

    fmt.Printf("Hello World!!\n")
    // 출력할 포맷을 제외하고 문자열 출력만 하도록 간소화했습니다.
    // Printf는 기본 string 타입을 받기 때문에 string 타입은 포맷 지정 없이도 사용이 가능합니다.

    var s string = "hi\n"
    fmt.Printf(s)
    // hi를 출력하고 개행을 합니다.
    // 단, 변수를 포맷 지정 없이 Printf로 출력하는 것은 권장되지 않습니다. (go-staticcheck)
    // 에러는 발생하지 않으며 정상 출력됩니다. 다만 가능할 뿐, 이런 사용 방식은 지양합니다.

    xByte, err := fmt.Printf("Hello World!!\n")
    fmt.Printf("The value of xByte : %d\nError : %v\n", xByte, err)
    // The value of xByte : 14
    // Error : <nil>
    // string은 글자 하나가 8bit, 1byte로 저장되기 때문에 "Hello World!!"에 대한 Byte 수는 13이 됩니다.
    // \n 개행 문자도 1byte입니다.
}

📍 변수의 입력

모든 프로그램의 동작은 변수의 제어를 통해 이루어집니다. 변수를 제어하기 위해서는 값을 부여하고 연산을 해야 합니다. 그리고 유동적으로 프로그램을 동작시키기 위해, 적절한 곳에서 변수에 값을 '입력'해야 하기도 합니다.

기본 입력 함수 func Scan

func Scan(a ...interface{}) (n int, err error)
// Scan scans text read from standard input, storing successive space-separated values into successive arguments. 
// Newlines count as space. 
// It returns the number of items successfully scanned. 
// If that is less than the number of arguments, err will report why.

Scan()함수는 값을 입력 받아, 변수에 저장합니다. 변수 간의 구분은 입력 시의 공백이나 개행으로 이루어집니다.

package main // Hello World!!를 입력 및 출력합니다.

import "fmt"

func main() {
    var x string
    var y string
    fmt.Scan(&x, &y) // string 두 개의 값을 입력 받아, 각각 x와 y에 저장합니다.
    // Hello World!! 
    // 또는
    // Hello
    // World!!
    // z, _ := fmt.Scan(&x, &y) // 인자의 개수를 z에 초기화합니다.
    fmt.Println(x, "and", y)
    // Hello and World!!
    // fmt.Println(z)
}

개행 종료 입력 함수 func Scanln

func Scanln(a ...interface{}) (n int, err error)
// Scanln is similar to Scan, but stops scanning at a newline and after the final item there must be a newline or EOF.

Scanln()함수는 값을 입력 받을 때, 공백으로만 구분합니다. 성공적으로 입력된 인자의 개수를 반환하며, 에러가 있을 시 에러를 같이 반환합니다. 개행을 하거나 EOF이 오면 종료됩니다.

package main // Hello World!!를 입력 및 출력합니다.

import "fmt"

func main() {
    var x string
    var y string
    var z string
    fmt.Scanln(&x, &y, &z) // string 세 개의 값을 입력 받아, 각각 x, y, z에 저장합니다.
    // Hello and World!!
    // Hello and `New line 또는 Ctrl + D`
    fmt.Println(x, y, z)
    // Hello and World!!
    // Hello and
}

포맷 지정 입력 함수 func Scanf

func Scanf(format string, a ...interface{}) (n int, err error)
// Scanf scans text read from standard input, storing successive space-separated values into successive arguments as determined by the format. 
// It returns the number of items successfully scanned. 
// If that is less than the number of arguments, err will report why. 
// Newlines in the input must match newlines in the format. 
// The one exception: the verb %c always scans the next rune in the input, even if it is a space (or tab etc.) or newline.

Scanf()함수는 값을 입력 받을 때, 형식에 맞는 인자를 받아서 값을 저장합니다. 성공적으로 입력된 인자의 개수를 반환하며, 에러가 있을 시 에러를 같이 반환합니다. 입력 값에 개행을 사용하려면 포맷에도 개행 문자를 알맞는 자리에 명시해야 합니다. 그렇지 않은 경우, 개행을 하거나 EOF이 오면 종료됩니다. 한 가지 예외 : %c (rune 타입)은 언제나 모든 rune을 입력 값으로 받기 때문에, %c로 값을 전달 받을 때, space나 \t, \n 등이 오더라도 모두 rune 타입 문자로 취급됩니다.

package main // Hello World!!를 입력 및 출력합니다.

import "fmt"

func main() {
    var x int8
    var y int8
    var z rune
    fmt.Scanf("%d%c\n%d", &x, &z, &y) 
    // 정수 x 입력, rune 타입 'space 공백' 입력,  \n 포맷에 맞추어 개행, 정수 y입력
    // 5 
    // 3
    fmt.Printf("%c", z) // 입력 마무리로 현위치, rune 타입 z 출력으로 space 공백 출력
    //  
    fmt.Println(x + y) // x + y 값 출력
    //  8    
}
// 5
// 3
//  8
// **(결과로 한 칸 뒤에 8이 출력되는 게 맞습니다.)

📍 문자열 반환

문자열 반환 함수 func Sprint, Sprintf, Sprintln

func Sprint(a ...interface{}) string
// Sprint formats using the default formats for its operands and returns the resulting string.
// Spaces are added between operands when neither is a string.

func Sprintln(a ...interface{}) string
// Sprintln formats using the default formats for its operands and returns the resulting string. 
// Spaces are always added between operands and a newline is appended.

func Sprintf(format string, a ...interface{}) string
// Sprintf formats according to a format specifier and returns the resulting string.

Sprint()함수는 Print() 함수가 출력하는 결과를 string 타입으로 반환합니다. Sprintln()함수는 Println() 함수를, Sprintf()함수는 Printf()함수로 출력되는 결과를 string 타입으로 반환합니다.

package main

import "fmt"

func main() {
    const name, age = "Kim", 22
    s := fmt.Sprint(name, " is ", age, " years old.\n")
    fmt.Println(s)
    // Kim is age 22 years old.
}

📌 연산자

Golang에서 지원하는 연산자는 아래와 같습니다.

📍 산술 연산자

%연산자 (modular arithmetic)

%연산은 modular arithmetic이라고 하며, 나머지 연산이라고도 합니다. 결과 값은 나눗셈의 나머지입니다. 5 % 3 연산의 결과는 5을 3로 나눈 나머지 2가 결과 값이 됩니다.

package main

import "fmt"

func main() {
    var a int8 = 5 // 변수 a를 int8, 8비트 정수로 선언하고 5(으)로 초기화합니다.
    var b int8 = 3 // 변수 b를 int8, 8비트 정수로 선언하고 3(으)로 초기화합니다.
    fmt.Printf("%d\n", a % b) // a % b 연산을 한 결과를 출력합니다.
} // 2

%연산자를 다른 산술 연산자로 바꾸어 출력할 수 있습니다.

📍 비트 연산자

비트 연산자 & (AND)

비트 연산자는 비트 단위의 연산에 사용합니다.

이렇게 첫 번째 자리만 모두 1이어서 결과 값으로 1이 출력됩니다.

코드로 작성하면 아래와 같습니다.

package main

import "fmt"

func main() {
    var a int8 = 5 // 변수 a를 int8, 8비트 정수로 선언하고 5(으)로 초기화합니다.
    var b int8 = 3 // 변수 b를 int8, 8비트 정수로 선언하고 3(으)로 초기화합니다.
    fmt.Printf("%08b\n", a & b) // a & b 연산을 한 결과를 출력합니다.
} // 00000001

비트 연산자 | (OR)

비트 연산자는 비트 단위의 연산에 사용합니다.

위와 같이 A와 B 둘 중 하나가 1인 경우에는 A | B의 결과 값이 1이 되는 것을 볼 수 있습니다. 마찬가지로 십진수 5와 3을 통해 연산을 진행합니다. 5 | 3 의 연산은 아래와 같이 진행됩니다.       0 0 0 0 0 1 0 1       | 0 0 0 0 0 0 1 1 ㅡㅡㅡㅡㅡㅡㅡㅡㅡ       0 0 0 0 0 1 1 1

이렇게 둘 중 하나가 1이어서 결과 값으로 111이 출력됩니다.

코드로 작성하면 아래와 같습니다.

package main

import "fmt"

func main() {
    var a int8 = 5 // 변수 a를 int8, 8비트 정수로 선언하고 5(으)로 초기화합니다.
    var b int8 = 3 // 변수 b를 int8, 8비트 정수로 선언하고 3(으)로 초기화합니다.
    fmt.Printf("%08b\n", a | b) // a | b 연산을 한 결과를 출력합니다.
} // 00000111

비트 연산자 ^ (XOR)

비트 연산자는 비트 단위의 연산에 사용합니다.

위와 같이 A와 B 둘 중 하나만 1인 경우에만 A ^ B의 결과 값이 1이 되는 것을 볼 수 있습니다. 마찬가지로 십진수 5와 3을 통해 연산을 진행합니다. 5 ^ 3 의 연산은 아래와 같이 진행됩니다.       0 0 0 0 0 1 0 1      ^ 0 0 0 0 0 0 1 1 ㅡㅡㅡㅡㅡㅡㅡㅡㅡ       0 0 0 0 0 1 1 0

이렇게 둘 중 하나가 1이어서 결과 값으로 110이 출력됩니다.

코드로 작성하면 아래와 같습니다.

package main

import "fmt"

func main() {
    var a int8 = 5 // 변수 a를 int8, 8비트 정수로 선언하고 5(으)로 초기화합니다.
    var b int8 = 3 // 변수 b를 int8, 8비트 정수로 선언하고 3(으)로 초기화합니다.
    fmt.Printf("%08b\n", a ^ b) // a ^ b 연산을 한 결과를 출력합니다.
} // 00000110

Golang에서는 비트 단위 연산에 NOT 연산이 없습니다. 그렇기 때문에 비트 반전이 필요한 경우, XOR -> ^ 비트 연산자를 사용합니다.

비트 연산자 &^ (비트 클리어)

비트 연산자는 비트 단위의 연산에 사용합니다.

위와 같이 A가 1이고 B가 0인 경우에만 A &^ B의 결과 값이 1이 되는 것을 볼 수 있습니다. 마찬가지로 십진수 5와 3을 통해 연산을 진행합니다. 5 &^ 3 의 연산은 아래와 같이 진행됩니다.       0 0 0 0 0 1 0 1   &&^ 0 0 0 0 0 0 1 1 ㅡㅡㅡㅡㅡㅡㅡㅡㅡ       0 0 0 0 0 1 0 0

이렇게 둘 중 하나가 1이어서 결과 값으로 100이 출력됩니다. 비트 클리어 연산은 &와 ^가 결합된 형태입니다. A가 1이면서, & 그리고 ^둘 중 하나만 1인 경우 즉, B가 0인 경우를 의미합니다.

코드로 작성하면 아래와 같습니다.

package main

import "fmt"

func main() {
    var a int8 = 5 // 변수 a를 int8, 8비트 정수로 선언하고 5(으)로 초기화합니다.
    var b int8 = 3 // 변수 b를 int8, 8비트 정수로 선언하고 3(으)로 초기화합니다.
    fmt.Printf("%08b\n", a &^ b) // a &^ b 연산을 한 결과를 출력합니다.
} // 00000100

📍 시프트 연산자

시프트 연산자 << (왼쪽 시프트)

시프트 연산자는 비트 단위의 연산에 사용합니다.

마찬가지로 십진수 5와 3을 통해 연산을 진행합니다. 5 << 3 의 연산은 아래와 같이 진행됩니다.       0 0 0 0 0 1 0 1   << 0 0 0 0 0 0 1 1 ㅡㅡㅡㅡㅡㅡㅡㅡㅡ       0 0 1 0 1 0 0 0

시프트 연산은 위와 같이 비트 자릿수로 하는 연산이 아닙니다. 바로 위에 작성한 계산법은 아무 의미가 없습니다. 5 << 3은 이진수 5의 비트 자릿수를 3만큼 왼쪽으로 옮기는 연산입니다. 직접 해보면 아래와 같습니다.

0 0 0 0 0 1 0 1 0 0 1 0 1 0 0 0

그리고 이 값을 십진수로 표현하면 40이 됩니다.

코드로 작성하면 아래와 같습니다.

package main

import "fmt"

func main() {
    var a int8 = 5 // 변수 a를 int8, 8비트 정수로 선언하고 5(으)로 초기화합니다.
    var b int8 = 3 // 변수 b를 int8, 8비트 정수로 선언하고 3(으)로 초기화합니다.
    fmt.Printf("%08b\n", a << b) // a << b 연산을 한 결과를 출력합니다.
} // 00101000

시프트 연산자 >> (오른쪽 시프트)

시프트 연산자는 비트 단위의 연산에 사용합니다.

마찬가지로 십진수 5와 3을 통해 연산을 진행합니다. 5 >> 3 의 연산은 아래와 같이 진행됩니다.       0 0 0 0 0 1 0 1   >> 0 0 0 0 0 0 1 1 ㅡㅡㅡㅡㅡㅡㅡㅡㅡ       0 0 0 0 0 0 0 0

시프트 연산은 위와 같이 비트 자릿수로 하는 연산이 아닙니다. 바로 위에 작성한 계산법은 아무 의미가 없습니다. 5 >> 3은 이진수 5의 비트 자릿수를 3만큼 오른쪽으로 옮기는 연산입니다. 직접 해보면 아래와 같습니다.

5 >> 0 : 0 0 0 0 0 1 0 1 5 >> 1 : 0 0 0 0 0 0 1 0 5 >> 2 : 0 0 0 0 0 0 0 1 5 >> 3 : 0 0 0 0 0 0 0 0

그리고 이 값을 십진수로 표현하면 0이 됩니다.

코드로 작성하면 아래와 같습니다.

package main

import "fmt"

func main() {
    var a int8 = 5 // 변수 a를 int8, 8비트 정수로 선언하고 5(으)로 초기화합니다.
    var b int8 = 3 // 변수 b를 int8, 8비트 정수로 선언하고 3(으)로 초기화합니다.
    fmt.Printf("%08b\n", a >> b) // a >> b 연산을 한 결과를 출력합니다.
} // 00000000

아래 링크는 Golang의 연산자에 대한 스펙 문서입니다. golang Spec # Arithmetic_operators

이번 포스트는 Golang의 가장 기본이 되는 "fmt" 패키지에 대한 내용이었습니다. 감사합니다.👍

이번 포스트는 Golang 변수와 자료형에 대한 내용입니다. 순서는 아래와 같이 진행됩니다.

1. Golang은 강타입 언어이다.
   • 약타입 언어란
   • 강타입 언어란
2. Golang의 변수
   • 자료형의 종류와 그 범위
     • rune의 사용처
     • int와 uint에 대하여
     • true와 false에 대하여
   • 변수의 초기 값
     • 변수의 선언
   • 변수의 형변환

Golang은 강타입 언어이다.

Golang은 강타입 중에도 강타입 언어입니다. 약타입이냐, 강타입이냐에 따라 연산을 할 수 있는 방법이 확장될 수도, 제한이 될 수도 있습니다. 먼저 약타입부터 보겠습니다.

약타입 언어란

프로그래밍 언어에는 타입이 존재합니다. 그 타입에 따라 표현할 수 있는 값의 종류나 범위가 달라집니다. 약타입 언어는 정수와 실수 간의 계산을 허용하기도 합니다. 기초 교육 과정의 수학처럼 말입니다. 1 + 0.5 = 1.5 라는 것을 우리는 알고 있습니다. 약타입 언어는 위와 같이 정수와 실수 간의 연산을 허용하기도 합니다. 연산에 있어, 타입이 절대적이지 않게 됩니다. 또한, "1" + 1 = 2가 언어에 따라 2가 아닌 "11"이나 "2"의 결과가 되기도 합니다. 이러한 허용을 하게 되면, 해당 언어의 타입에 따른 연산 결과를 정확하게 예측하지 않으면 실수로 이어지고, 이는 곧 에러나 버그로 이어질 수 있습니다. 물론 이를 자유자재로 사용한다면 쓰기 편하다는 장점은 확실합니다. 하지만 높은 자유도가 오히려 독이 될 수도 있다는 것입니다.

강타입 언어란

강타입 언어는 위의 약타입 언어와는 확연히 다르게, 타입이 다른 변수 간의 연산을 허용하지 않습니다. 물론 강타입 언어 중에서도 숫자에 한해서는 연산을 허용하기도 합니다. 정수 + 실수 연산을 허용하는 c언어처럼 말입니다. 강타입 언어의 장점은 타입을 정확하게 인지하고 사용한다는 점입니다. 사용자의 실수로 서로 다른 타입 간의 연산을 하더라도 컴파일 과정을 거치며 에러를 발생시키기 때문에 의도치 않은 변수 간의 연산으로 애를 먹지 않아도 됩니다. 단점으로는 타입에 병적으로 매달려야 한다는 점입니다. Golang은 강타입 중에도 강타입 언어라고 말씀드렸습니다. Golang은 서로 다른 타입 간의 연산을 일절 허용하지 않습니다. 따라서, 사용자가 서로 다른 타입 간의 연산을 하기 위해서는 정확하게 인지한 상태로 형변환을 거쳐 연산을 진행합니다. 불편할 수도 있으나, 타입의 확실한 지정으로 에러 발생을 줄일 수 있다는 장점이 있습니다.

Golang의 변수

저번 포스트에서 Golang으로 Hello World!!를 출력했습니다. 출력하며 기본 틀에 대해서 설명을 같이 작성했습니다. 기본이 되는 틀을 알았으니 본격적으로 프로그래밍을 하기에 앞서, 변수 제어를 위해 변수와 자료형에 대해 알아보도록 합니다.

자료형의 종류와 그 범위

Golang의 기본 타입은 아래와 같습니다. (signed = 부호가 있는) (unsigned = 부호가 없는) (alias type = 별칭 타입; 별명 타입)

float가 보장하는 소수점

아래의 이미지는 float32에 대한 설명입니다. float32는 소수점 이하 7자리까지 보장됩니다. float64는 소수점 이하 15자리까지 보장됩니다.

rune의 사용처

int32의 alias type인 rune은 utf-8의 문자를 표현할 수 있습니다. 물론 int32로도 utf-8 문자 표현이 가능합니다.

var runeInitialized rune = '💕'
fmt.Printf("%c\n", runeInitialized)
// 💕

int와 uint에 대하여

위의 표를 보시면 int와 uint는 32 bit 자료형이 될 수도, 64 bit 자료형이 될 수도 있다고 쓰여있습니다. C언어를 예로 들자면 int는 항상 4 byte의 크기를 가집니다. 즉, 32 bit의 크기를 가집니다. C언어는 실행되는 OS의 레지스터가 32 bit인지 64 bit인지를 따지지 않고 int에 32 bit를 할당합니다. Golang은 OS의 레지스터에 따라 int의 사이즈가 달라집니다. 32 bit OS에서는 int == int32 64 bit OS에서는 int == int64 uint 또한 마찬가지입니다. 32 bit와 64 bit는 표현할 수 있는 값의 범위차가 상당히 큽니다. 그래서 항상 OS의 환경이 다를 수 있음을 염두에 두고 프로그래밍을 해야 합니다. alias 타입과 int, uint는 사용에 유의해야 합니다.

true와 false에 대하여

C언어에서 stdbool.h 표준 라이브러리를 사용하면 bool type의 value인 true, false를 사용할 수 있습니다. C언어에서 true는 1, false는 0의 값을 가집니다.

Golang에서는 이 두 가지의 참과 거짓을 나타내는 true, false의 값이 각각 1과 0의 값을 가지지 않습니다. Golang에서 true와 false는 boolean value일 뿐입니다.

if true == 1 {
    fmt.Println("value of true is 1")
} // error would be occurred

변수의 초기 값

모든 변수는 선언과 동시에 기본 값으로 초기화됩니다. 선언하면서 변수에 값을 대입할 수도 있지만 값을 주지 않으면 default 값을 가집니다. 아래는 각 자료형에 대한 초기 값에 대한 표입니다.

변수의 선언

변수가 어떤 값을 가지게 하고 싶다면 먼저 변수를 선언해야 합니다. 변수의 선언 방법은 아래와 같습니다.

var 변수명 타입명 (= 값, optional) (변수 선언하며 초기화)

var nameOfVariable variableType = value 

타입을 지정하며 선언 후 초기화한다.

var nameOfVariable variableType // let value of nameOfVariable as it's default value 
nameOfVariable = value

타입을 지정없이 선언하며 초기화 : 값에 따라 타입이 자동으로 설정된다. (단, default 값에 유의해야 함. 의도치 않은 결과가 나올 수 있음.)

nameOfVariable := value

var 변수명 타입명 (= 값, optional) (여러 개의 변수 동시 선언 및 초기화)

var c, python, java = true, false, "no!"

변수의 형변환

변수의 형변환은 심심치 않게 필요한 경우들이 생깁니다. 가령 개발을 하다가 A에서 B로 데이터의 이동이 필요한데, B에서는 string 타입이 필요한데 A에서는 해당 데이터를 int 형태로 가공해서 사용한 케이스가 있을 수 있습니다. 그렇게 되면 A에서 string으로 변환해서 B에 전달을 하거나, A가 int 형태로 B에 전달해서 B가 string으로 가공해서 사용하는 방법이 있습니다. 둘 중 어느 케이스든 형변환은 무조건적으로 필요하게 됩니다.

Golang에서의 형변환은 아래와 같은 방법으로 이루어집니다.

TypeThatWannaBe(ValueThatWillBeConverted)
// e.g.: 
var ValueThatWillBeConverted int8
var TypeUint64Variable uint64
... // now ValueThatWillBeConverted has value..
TypeUint64Variable = uint64(ValueThatWillBeConverted)

Numeric Type <---> string 은 strconv 패키지를 import하여 수행할 수 있다. Golang strconv docs

이번 포스트에서는 Golang의 변수와 자료형에 대한 내용이었습니다. 프로그램을 제어하기 위해서는 변수의 활용이 필수적입니다. 최대한 자세하게 다룬다고 다룬 것인데 충분할지는 모르겠습니다. 기회가 된다면 나중에 보충하거나 새로 다시 포스팅하도록 하겠습니다. 감사합니다.👍

이번 포스트는 Golang 개발환경 세팅입니다.

환경은 ubuntu 18.04 LTS입니다. 순서는 다음과 같이 진행하겠습니다.

• ubuntu 18.04 LTS에 Golang 설치하기
• Golang 환경변수 GOPATH 설정하기
• Golang 환경변수 확인
• Golang 개발 환경 설정하기
• Golang Hello World!! 출력하기

Golang installation document

위의 링크에 접속하시면 환경마다의 설치 과정이 소개되어 있습니다. 저는 ubuntu 환경이므로 linux 환경의 순서로 소개하겠습니다.

현재 가장 최신 릴리즈 버전은 1.17.3입니다. (현재 2021-11-19, 최신 릴리즈 2021-11-04) 위의 링크에 Download Go for Linux 버튼을 클릭하시면 바로 다운로드가 진행됩니다. Windows 환경에 Linux 환경의 VM을 사용하는 분이라면 해당 링크를 복사해서 wget으로 다운로드 받으시면 됩니다.

wget https://golang.org/dl/go1.17.3.linux-amd64.tar.gz

이후엔 가이드에 나온 것처럼 기존 버전이 있다면 제거를 먼저 진행하고, 다운로드 받은 gzip 압축 파일의 압축 해제를 합니다.

# rm -rf /usr/local/go && tar -C /usr/local -xzf go1.17.3.linux-amd64.tar.gz

root가 아니라면 아래와 같이 sudo를 붙여서 진행하시면 됩니다.

$ sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.17.3.linux-amd64.tar.gz

위와 같이 압축 해제된 go 디렉터리가 새로 생긴 것을 확인했습니다.

Golang 환경변수 Gopath 설정하기

설치가 완료되었으면 환경변수인 GOPATH를 설정함으로써 golang을 사용할 수 있게 해주어야 합니다.

아래의 환경변수 세팅을 ~/.profile에 추가합니다.

export PATH=$PATH:/usr/local/go/bin

추가가 완료되었으면 변경된 환경변수를 적용하기 위해 아래의 명령어를 실행합니다. .profile은 재부팅하면 적용이 되지만 현재 쉘 환경에 바로 적용시키기 위함입니다.

source ~/.profile

Golang 환경변수 확인

환경변수 설정이 끝났으면 아래와 같이 go 명령어가 잘 실행되는지 확인합니다.

go version

아래와 같이 go 환경변수를 모두 확인할 수도 있습니다.

go env

위와 같이 모두 문제 없이 잘 설치된 것을 알 수 있습니다.

Golang 개발 환경 설정하기

VScode 상에서 개발 환경 설정은 go extension을 설치하는 것으로 모두 끝납니다. 아래의 extension을 설치하고, 우측 하단에 gopkgs, gopls 등 설치되지 않은 게 있다며 알림이 올라오는데, install All 한 번만 클릭하시면 자동으로 기본적인 tool들을 설치합니다.

Golang Hello World!! 출력하기

먼저, 아래와 같이 디렉터리 경로를 만들고 hello.go 파일을 생성합니다.

mkdir -p ~/goprojects/hello
touch ~/goprojects/hello/hello.go

이제 VScode에서 hello.go 파일을 수정하여 Hello World!!를 출력하겠습니다.

package main

import "fmt"

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

• package main : hello.go 파일은 main 패키지임을 알립니다.
• main 패키지는 진입점*이며, main 패키지 파일 내에는 리턴이 없는 main 함수가 필요합니다.
• import "fmt" : golang standard library 중 fmt 표준 라이브러리를 포함합니다.
• func main() {...} : main 함수를 작성합니다. 패키지를 초기화한 후에 가장 먼저 실행되는 함수입니다.
• fmt.Println("Hello World!!") : fmt는 formatted I/O으로, C언어의 stdio와 같은 표준 입출력 라이브러리입니다. Println은 각각의 피연산자 사이에 공백을 추가하고, 가장 마지막에 줄바꿈을 포함합니다. fmt.Print는 공백을 추가하지 않으며, 줄바꿈도 하지 않습니다.

이제 위의 코드를 실행하겠습니다. 실행하는 방법은 두 가지를 소개하겠습니다.

go run hello.go
go build hello.go && ./hello

• go run hello.go : main 패키지 파일을 컴파일 후에 바이너리 파일을 남기지 않고 메모리 위에서 바로 실행합니다.
• go build hello.go : main 패키지 파일을 import 시킨 모든 라이브러리, 연결된 패키지와 함께 컴파일하며 바이너리 파일을 생성합니다.
• ./hello : 빌드된 hello 바이너리 파일을 실행합니다.

위와 같이 Hello World!!가 출력되면 완료입니다.

이상으로 Golang 개발 환경 설정 포스팅을 마치겠습니다. 감사합니다.👍

이번에 포스팅할 시리즈는 Golang입니다. 제가 많이 사용하는 언어이고 아직 많이 부족하지만 뛰어난 퍼포먼스와 쉬운 사용으로 인해 굉장히 마음에 드는 언어입니다. 아직 열심히 공부 중이며, 이미 알고 있는 내용들을 정리해보려 합니다. 나아가, Go에 대한 다른 여러 기능들을 포스팅할 수 있게 되었으면 좋겠습니다.

The summary of Go.

Google이 만든 언어이고 만들어진 계기는 'C++의 복잡성이 싫어서'라고 합니다. 웃긴 것은 C언어를 만든 켄 톰슨이 Go를 탄생시킨 3인(켄 톰슨, 로버트 그리즈머, 롭 파이크)의 대표자 중 한 명이라는 것입니다. 추가로, Golang의 패키지에 포함할 내용을 정하는 것은 아직까지 3인 만장일치제를 따른다고 합니다.

Golang 코드 실행은 아래의 사이트에서 쉽게 해보실 수 있습니다. https://play.golang.org/ https://replit.com/languages/go

The performance of Go.

Golang은 컴파일 언어이지만 그 속도가 매우 빨라, 빌드하는 시간이 짧은 쾌적한 언어이다. goroutine이라는 비동기 방식은 멀티 스레드 방식이며, 따로 관리할 필요 없이 그저 실행할 코드 앞에 'go'를 붙여주면 사용할 수 있다. goroutine은 Golang 자체의 스케줄러에 의해 관리되는 경량 스레드인 관계로, 수천 개의 goroutine을 실행시켜도 성능에 지장이 없다. Go를 빌드할 때에는 배포 환경에 따라 환경변수 지정을 해주면 문제가 없다.

Some famous platforms that are using Go.

Go의 뛰어난 퍼포먼스는 몇몇 커다란 플랫폼의 개발진을 매료시키기에 충분했습니다. 우리가 사용하는, 알고 있는 생각보다 많은 플랫폼들은 Go로 만들어졌거나 중요한 파트에 Go가 쓰였습니다.

Twitch

라이브 스트리밍 플랫폼인 twitch는 퍼포먼스가 중요한 시스템에 Go를 사용했습니다. 바로, 스트리머가 스트리밍함으로 들어오는 RTMP 스트림을 다수의 HLS 스트림으로 변환하는 시스템입니다. twitch는 HLS를 사용함으로써 시청자가 화질을 조절할 수가 있습니다. HLS는 HTTP Live Streaming으로, 스트리밍을 위한 통신 프로토콜입니다. 네트워크 상태에 따라 화질을 조절할 수 있는 Adaptive HTTP Streaming을 사용할 수 있습니다. HLS는 아래와 같이 동작합니다.

1. 퍼블리셔가 스트림 데이터를 생성하고, 서버에 전송합니다.
2. 서버의 미디어 인코더가 스트림 데이터를 인코딩합니다.
3. 스트림 세그멘터가 인코딩된 미디어를 ts포맷으로 변환 및 분할합니다.
4. 이때, ts파일은 하나의 스트림 파일을 1080p, 720p, 480p, 360p 처럼 설정한 해상도마다 중복 존재합니다. 이 ts파일은 클라이언트의 요청이나 네트워크 상태에 따라 ts index 정보가 담긴 m3u8이라는 플레이리스트와 함께 제공됩니다. m3u8에 담긴 정보로 인해 클라이언트는 스트림 화질이 변경되더라도 바로 이어서 시청할 수 있게 됩니다.

Twitch Engineering: An Introduction and Overview 발췌 바로 위의 2, 3의 과정이 Go가 사용된 파트입니다. 순수 Go만 사용된 것은 아니고 C/C++과 조합해서 사용했다고 합니다. C/C++ 은 백엔드에서 High-performance를 위해 여전히 많이 사용되고 있는 언어입니다. 그러한 특징이 있는 언어들과 함께 쓰였다는 것은 Go도 상당한 퍼포먼스를 지녔다는 걸 간접적으로 증명합니다. (물론 C/C++에 비해 성능이 떨어지는 것은 사실입니다.)

Twitch는 사용자에게 최고의 스트리밍 환경을 제공하기 위해 지리적으로 다른 POP에 HLS를 배포합니다. 이 부분 역시 대부분 Go로 만들어졌습니다. GLB 세팅도 마찬가지입니다.

• POP : Point of presence -> 네트워크 접속 지점으로, ISP를 의미한다고 보시면 되겠습니다.
• GLB / GSLB : Global (Server) Load Balancer : 글로벌 로드 밸런싱이며, 네트워크 상태를 판단하여 가장 적합한 서버에 우선순위를 높여 배포하도록 할 수 있습니다.

Twitch의 채팅 기능 역시 Go로 만들어졌습니다. twitch는 Go를 채택한 이유에서 확장성이 뛰어나고 실시간 분산 시스템을 구축하기에 적합했다고 설명하고 있습니다.

추가로, Twitch는 Web API, 라우팅, 캐싱, 데이터 스토리지에 Go를 사용했다고 설명합니다.

PayPal

해외 유명 결제 시스템인 PayPal은 Go를 기반 언어로 채택했습니다. PayPal에는 Golang 개발자가 100명이 넘어갑니다.

Go의 라이브러리, 도구, 동시성, 단순성, 확장성, 가비지 콜렉팅 등을 활용하고, 플랫폼 규모에 맞는 애플리케이션 생성 및 실행의 복잡성을 단순화할 수 있었다. 라고 설명합니다.

PayPal의 지불 처리 플랫폼의 핵심은 PayPal이 C++로 개발한 독점 NoSQL 데이터베이스입니다. PayPal은 Golang으로 NoSQL 데이터베이스를 성공적으로 이식하면서 Go의 사용 범위를 확대했습니다. 또한 PayPal은 Go로 만들어진 인프라를 구축해, 서비스 빌드 및 테스트까지 가능한 테스트 팜을 보유하고 있습니다.

PayPal Taps Go to Modernize and Scale 발췌

Uber

한국에 최근에 들어온 우버에 Go가 사용됩니다.

Uber는 지리 데이터를 기반으로 한 운송 서비스 플랫폼입니다. 우버에 있는 지오펜스 조회 서비스가 Go로 대체되었습니다.

지오펜스(geofence)는 geo + fence로, 지리적 경계를 의미합니다. 사람이 정의한 지리적 경계로, 아래의 이미지와 같은 형태를 띱니다.

이 기술은 우버의 핵심 기술이자 우버가 제공하는 모든 서비스 중에 가장 QPS(초당 쿼리 수)가 높은 서비스입니다. 많은 양의 쿼리의 처리를 이전까지는 Node.js로 수행했습니다. 하지만 Node.js의 싱글 스레드 방식은 이 많은 양의 쿼리를 감당하기엔 부담이 되었고, 백그라운드 리프레싱은 CPU 사용을 장시간 멈추어, 쿼리 응답 시간을 늦추게 되는 결과를 초래했습니다.

Go의 goroutine은 멀티 CPU core에서 따로 동작하며 이러한 쿼리 응답 시간 급증에 대한 문제를 해결합니다.

무중단 백그라운드 로딩으로, geological 데이터를 바로 가져올 수 있습니다. How We Built Uber Engineering’s Highest Query per Second Service Using Go 발췌

ETC

Golang solutions Microsoft, Google, Facebook, NETFLIX, RIOT Games, Twitter, trivago 등이 Go를 사용합니다. 자세하게 더 알고 싶으신 분은 위의 링크로 이동하시면 잘 설명된 자료들이 있습니다.

이번 시리즈를 시작하면서, 첫 포스트로 Go에 대해 알아보는 글을 작성했습니다. 다음 포스트부터는 Golang 기초를 포스팅하도록 하겠습니다. 감사합니다.👍

이번 포스트에서는 Janus Gateway Demo Service 구동하는 순서에 대해 알아보겠습니다. 먼저, Janus Gateway는 http를 사용한 long poll 연결 방식과 websocket 연결 방식을 지원합니다. 말고도 rabbitmq, mqtt 등을 사용할 수도 있지만 보편적으로 사용되는 방식인 http와 websocket 방식을 사용하겠습니다. 또, 이 두 가지 방법이 demo에서 바로 제공되고 있는 방식이라 바로 구현하기가 편합니다.

진행 순서는 다음과 같습니다. - docker : docker-compose.yml 살펴보기 - demo service 접속하기 - http / websocket 사용하기 - local 세팅 사용자를 위한 Browser flag 설정

우리가 올려야 할 서비스는 두 개입니다. 하나는 janus-gateway, 다른 하나는 web-server입니다. web-server 구동하는 방법은 이전에 docker 설치하며 테스트하는 내용을 올린 포스트에서 확인하실 수 있습니다. web-server가 무엇인지 간략한 소개가 필요한 분만 위의 포스트를 읽어보시면 될 것 같습니다. 서비스 두 개 모두 docker가 아닌 로컬 환경에서 구동하는 분은 다음 태그로 이동하시면 됩니다.

docker-compose.yml 살펴보기 (docker로 서비스 구동하는 분만 해당)

# docker-compose.yml for janus gateway

version: '3.8'
services:
  nimbus:
    user: root
    image: "<image_name:TAG>"
    volumes:
      - ./config/:/opt/janus/etc/janus/
      - ./log/:/var/log/
    restart: always
    ports:
      - 7088:7088
      - 8088:8088
      - 8188:8188
      - 10000-10030:10000-10030/udp

위와 같이 compose를 구성하면 됩니다. 포트 구성에 대해 간략히 설명드리겠습니다. 각 port 구성은 아래에 나와 있는 jcfg 파일에서 수정할 수 있습니다.

• 7088 : janus http admin request port : janus.transport.http.jcfg (set 'admin_http' to true)
• 8088 : janus http general request port : janus.transport.http.jcfg (default)
• 8188 : janus websocket general request port : janus.transport.websocket.jcfg (default)
• 10000-10030 : only rtp packet udp port : janus.jcfg (should modify)

# docker-compose.yml for web server

version: "3.8"
services:
   web_server:
      user: "root"
      image: httpd:alpine
      restart: always
      ports:
         - 80:80
      volumes:
         - ./janus:/usr/local/apache2/htdocs

위와 같이 compose를 구성하면 됩니다. janus 디렉터리를 마운트했습니다. 이 디렉터리는 janus-gateway의 html 디렉터리의 이름을 변경한 겁니다.

git clone https://github.com/meetecho/janus-gateway.git

janus-gateway를 클론해서 가져오시면 demo 페이지에 대한 소스가 html 디렉터리 안에 있습니다.

demo service 접속하기

janus-gateway와 web-server를 구동합니다. 그리고 demo 페이지를 열어서 demo service에 접속합니다. 주소는 본인이 설치한 환경에 따라 다릅니다. localhost가 될 수도 있고, 저처럼 192 대역폭일 수 있습니다. web-server가 사용하는 ip 대역을 찾아야 합니다. virtual-box의 경우, 127.0.0.1 즉, localhost로 포트포워딩을 통해 지정할 수 있습니다. vmware는 저처럼 192 대역폭으로 잡힐 텐데 vm에 접속해, ifconfig 명령어로 확인할 수 있습니다.

Video Room

우리는 Video Room service를 이용할 겁니다. 바로 화상회의를 할 수 있게 하는 기능입니다.

들어오면 이렇게 보입니다. Start 버튼을 누르고, 본인의 display name을 쓰고 방에 참여를 할 수 있습니다.

방에 참여를 하면 아래와 같이 화상회의가 시작됩니다. client를 하나 더 늘리고 싶으면 탭 하나 더 열고 접속하시면 됩니다. 그러면 아래와 같이 나옵니다.

Admin/Monitor

위에서 한 것처럼 두 개의 클라이언트를 연결해두고 아래와 같이 Admin/Monitor 메뉴를 선택합니다.

아래와 같이 Admin API secret을 입력하라는 창이 나옵니다. janus.jcfg 안에 "admin_secret"가 API secret을 의미합니다. default = "janusoverlord" 수정하신 분은 수정한 secret 값을 입력하시면 됩니다.

접속한 janus demo의 Admin/Monitor 페이지에서는 우리가 빌드한 janus-gateway를 볼 수 있습니다.

1. 서버 정보 확인 가능

2. 동적으로 몇 가지 설정 변경 가능

3. 각종 plugin에 대하여 request 가능

4. 사용 중인 session, handle에 대한 모니터링 가능

5. 각종 플러그인에 대하여 request 가능

6. 사용 중인 session, handle에 대한 모니터링 가능

Session/Handle 구분하기

{
    "session_id": 1680235067534419,
    "session_last_activity": 21099289581,
    "session_timeout": 60,
    "session_transport": "janus.transport.http",
    "handle_id": 7341683173592579,
    "opaque_id": "videoroomtest-owwI8GGU0D2Z",
    "loop-running": true,
    "created": 20004476526,
    "current_time": 21114145471,
    "plugin": "janus.plugin.videoroom",
    "plugin_specific": {
        "type": "publisher",
        "room": 1234,
        "id": 2088026101620201,
        "private_id": 1858719391,
        "display": "eon1",
        "viewers": 1,
        "media": {
            "audio": true,
            "audio_codec": "opus",
            "video": true,
            "video_codec": "vp8",
            "data": false
        },
        "bitrate": 128000,
        "audio-level-dBov": 0,
        "talking": false,
        "hangingup": 0,
        "destroyed": 0
    },
    "flags": {
        "got-offer": true,
        "got-answer": true,
        "negotiated": true,
        "processing-offer": false,
        "starting": true,
        "ice-restart": false,
        "ready": true,
        "stopped": false,
        "alert": false,
        "trickle": true,
        "all-trickles": true,
        "resend-trickles": false,
        "trickle-synced": false,
        "data-channels": false,
        "has-audio": true,
        "has-video": true,
        "new-datachan-sdp": false,
        "rfc4588-rtx": true,
        "cleaning": false,
        "e2ee": false
    },
    "agent-created": 20012000422,
    "ice-mode": "full",
    "ice-role": "controlled",
    "sdps": {
        "profile": "UDP/TLS/RTP/SAVPF",
        "local": "LOCAL-SDP",
        "remote": "REMOTE-SDP"
    },
    "queued-packets": 0,
    "streams": [
        {
            "id": 1,
            "ready": -1,
            "ssrc": {
                "audio": 1011294199,
                "video": 2619788864,
                "video-rtx": 1820056821,
                "audio-peer": 1760309472,
                "video-peer": 456717877,
                "video-peer-rtx": 1757326114
            },
            "direction": {
                "audio-send": false,
                "audio-recv": true,
                "video-send": false,
                "video-recv": true
            },
            "codecs": {
                "audio-pt": 111,
                "audio-codec": "opus",
                "video-pt": 96,
                "video-rtx-pt": 97,
                "video-codec": "vp8"
            },
            "extensions": {
                "urn:ietf:params:rtp-hdrext:sdes:mid": 4,
                "urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id": 5,
                "urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id": 6,
                "http://www.ietf.org/id/draft-holmer-rmcat-transport-wide-cc-extensions-01": 3,
                "urn:ietf:params:rtp-hdrext:ssrc-audio-level": 1,
                "urn:3gpp:video-orientation": 13
            },
            "bwe": {
                "twcc": true,
                "twcc-ext-id": 3
            },
            "nack-queue-ms": 200,
            "rtcp_stats": {
                "audio": {
                    "base": 48000,
                    "rtt": 0,
                    "lost": 0,
                    "lost-by-remote": 0,
                    "jitter-local": 0,
                    "jitter-remote": 0,
                    "in-link-quality": 100,
                    "in-media-link-quality": 100,
                    "out-link-quality": 0,
                    "out-media-link-quality": 0
                },
                "video": {
                    "base": 90000,
                    "rtt": 0,
                    "lost": 0,
                    "lost-by-remote": 0,
                    "jitter-local": 6,
                    "jitter-remote": 0,
                    "in-link-quality": 100,
                    "in-media-link-quality": 100,
                    "out-link-quality": 0,
                    "out-media-link-quality": 0
                }
            },
            "components": [
                {
                    "DEPENDS-ON-USER-SETTING"
                    ],
                    "remote-candidates": [
                        "DEPENDS-ON-USER-SETTING"
                    ],
                    "selected-pair": "192.168.56.1:61131 [prflx,udp] <-> 192.168.56.1:57209 [host,udp]",
                    "dtls": {
                        "fingerprint": "SECRET",
                        "remote-fingerprint": "SECRET",
                        "remote-fingerprint-hash": "sha-256",
                        "dtls-role": "active",
                        "dtls-state": "connected",
                        "retransmissions": 0,
                        "valid": true,
                        "srtp-profile": "SRTP_AES128_CM_SHA1_80",
                        "ready": true,
                        "handshake-started": 20012351711,
                        "connected": 20012360099,
                        "sctp-association": false
                    },
                    "in_stats": {
                        "audio_packets": 55089,
                        "audio_bytes": 1875509,
                        "audio_bytes_lastsec": 1377,
                        "do_audio_nacks": false,
                        "video_packets": 30906,
                        "video_bytes": 9538501,
                        "video_bytes_lastsec": 9140,
                        "do_video_nacks": true,
                        "video_nacks": 0,
                        "video_retransmissions": 0,
                        "data_packets": 2,
                        "data_bytes": 1226
                    },
                    "out_stats": {
                        "audio_packets": 0,
                        "audio_bytes": 0,
                        "audio_bytes_lastsec": 0,
                        "audio_nacks": 0,
                        "video_packets": 0,
                        "video_bytes": 0,
                        "video_bytes_lastsec": 0,
                        "video_nacks": 0,
                        "data_packets": 2,
                        "data_bytes": 789
                    }
                }
            ]
        }
    ]
}

위의 정보에서 display는 publisher (session_id 1680235067534419)의 display 정보입니다. 동일한 session 내에 또 다른 handle 정보를 보시면 display는 없고 feed_display가 있는 걸 확인할 수 있습니다. subscriber의 display 정보입니다. 다른 session에서 보면 두 display가 서로 다르게 나오는 걸 확인할 수 있습니다.

가장 아래를 보시면 in_stats, out_stats가 있습니다. 트래픽 정보라고 보시면 됩니다. in_stats : janus-gateway로 들어오는 정보 out_stats : janus-gateway에서 나가는 정보 현재, 이 session/handle은 publisher가 자신의 영상을 janus를 통해 subscriber에게 보내는 중입니다. 이 handle에서는 보내는 것만 있을 뿐, rtp 패킷을 받지 않습니다. 동일 session의 다른 handle에서는 반대입니다.

http / websocket 사용하기

Janus demo 페이지 소스를 봅니다. 그중 videoroomtest.js를 열어봅니다. 최상단 주석 부분은 간단한 설명이 있으니 읽어 보시기 바랍니다. 최상단 주석이 끝나는 부분에 우리가 볼 http / websocket 연결 방식을 정할 수 있는 부분이 나옵니다.

// This will tell the library to try connecting to each of the servers
// in the presented order. The first working server will be used for
// the whole session.
//
var server = null;
if(window.location.protocol === 'http:')
    server = "http://" + window.location.hostname + ":8088/janus";
else
    server = "https://" + window.location.hostname + ":8089/janus";

주소 창에 프로토콜이 http이면 8088포트에 연결합니다. 주소 창에 프로토콜이 https이면 8089포트에 연결합니다. (우리는 https를 건드린 적 없고, https도 false로 두었으니 사용이 불가합니다.)

지금 기본적으로 http 연결 방식이 채택되어 있습니다. 이대로 사용하시면 http long poll을 사용하는 것이고, 여기서 websocket 방식으로 변경 가능합니다.

if(window.location.protocol === 'http:')
    server = "ws://" + window.location.hostname + ":8188/janus";
else
    server = "wss://" + window.location.hostname + ":8989/janus";

이런 식으로 http 연결이 있을 때, websocket으로 연결하도록 합니다. wss는 마찬가지로 false로 설정했기 때문에 사용을 하지 않습니다.

위와 같이 두 가지 연결 방식 모두 테스트할 수 있으며, 위의 Admin/Monitor 기능을 사용해서 연결 방식을 확인할 수 있습니다.

local 세팅 사용자를 위한 Browser flag 설정

localhost로 접속하시는 분들은 별다른 문제를 겪지 않으실 겁니다. local 장비에 vm을 이용하거나 web-server를 다른 툴을 이용해서 구동하는 경우, web-server의 ip 구성이 localhost가 아닐 수 있습니다. browser는 https가 설정되지 않은 http 환경에서 media device에 접근을 막습니다. 화상회의를 위한 필수 device인 cam, mic가 대상이 됩니다.

대표적으로 chrome, firefox에서의 flag 설정하는 방법을 다뤄보겠습니다. 보안 문제가 발생할 수 있기 때문에 테스트가 끝나면 다시 원상 복구하는 걸 권장합니다.

chrome browser media device permission flag setting

chrome://flags/#unsafely-treat-insecure-origin-as-secure browser 주소 창에 위와 같이 적습니다. 그러면 아래와 같이 지정한 flag에 대해 설정할 수 있게 됩니다.

허용할 ip 목록을 적고, Enabled로 값을 변경하면 Relaunch 버튼이 생기는데, 이 버튼을 누르고 브라우저를 재실행하면 device 접근이 허용됩니다.

firefox browser media device permission flag setting

aout:config browser 주소 창에 위와 같이 적습니다. 그러면 아래와 같이 경고 페이지가 나오고 그대로 진행합니다.

설정할 flag는 다음의 검색어로 한 번에 찾을 수 있습니다.

• insecure.enabled

아래의 flag를 모두 true로 변경합니다.

• media.devices.insecure.enabled
• media.getusermedia.insecure.enabled

이제 chrome과 firefox에서 local 주소가 어떻든 media device에 접근할 수 있게 됐습니다.

이렇게 janus-gateway를 다루고 보는 방법을 알아봤습니다. 이것으로 janus demo service 구동하는 시리즈를 마치겠습니다. 감사합니다.👍

이전 포스트는 Janus Gateway 설치 과정과 Docker로 실행하고 싶으신 분들을 위해 Dockerfile을 포함해서 올렸습니다. 이번 포스트는 Janus Gateway config 세팅을 해보려고 합니다. Docker를 사용하지 않을 분은 config나 설정 값 모두 로컬 Janus나 웹 서버에 적용하시면 됩니다.

Janus 실행 먼저 보도록 하겠습니다.

Janus Gateway의 실행

이전 포스트의 Dockerfile 마지막 부분이 실행하는 파트입니다.

/opt/janus/bin/janus --v
/opt/janus/bin/janus

janus binary를 --v 옵션과 함께 실행하면 version을 출력합니다. 그리고 옵션 없이 실행하면 janus가 실행됩니다.

이렇게 하면 Janus가 실행됩니다. 실행은 시켰으나, 제대로 동작되고 있는지 알려면 config 세팅을 끝마친 후에 실행해야 합니다. 지금 실행한 것은 default값으로만 설정되어 있어, 사용이 어렵습니다.

Janus configs

Janus config를 보겠습니다. Dockerfile의 순서대로 진행하셨다면 아래의 경로에 config 파일이 있습니다.

/opt/janus/etc/janus

Videoroom plugin을 사용한 화상회의 세팅을 위해 우리가 봐야 할 것은 아래 리스트입니다.

janus.jcfg
janus.plugin.videoroom.jcfg
janus.transport.http.jcfg
janus.transport.websocket.jcfg

위에서부터 아래의 설정을 위한 config 파일들입니다.

• Janus 전반적인 general config
• videoroom을 위한 config
• http 관련 설정을 위한 config
• websocket 관련 설정을 위한 config

janus.jcfg

** # Janus 메인 설정입니다. **

# General configuration: folders where the configuration and the plugins
# can be found, how output should be logged, whether Janus should run as
# a daemon or in foreground, default interface to use, debug/logging level
# and, if needed, shared apisecret and/or token authentication mechanism
# between application(s) and Janus.
general: {

# folder path는 default 세팅을 따르겠습니다.

    configs_folder = "/opt/janus/etc/janus"            # Configuration files folder
    plugins_folder = "/opt/janus/lib/janus/plugins"            # Plugins folder
    transports_folder = "/opt/janus/lib/janus/transports"    # Transports folder
    events_folder = "/opt/janus/lib/janus/events"            # Event handlers folder
    loggers_folder = "/opt/janus/lib/janus/loggers"            # External loggers folder

** # logging 관련 세팅입니다. # log_to_file : log를 file로 남기기 위해, logfile의 경로를 지정합니다. # debug_level : level 5로 설정하여, Verbose mode로 설정합니다. # debug.h File Reference # debug_timestamps : timestamp를 같이 출력하여, 로그를 보기 쉽게 합니다. # 로그 세팅은 본인이 편한대로 옵션을 지정하시면 됩니다. **

        # The next settings configure logging
    #log_to_stdout = false                    # Whether the Janus output should be written
                                            # to stdout or not (default=true)
    log_to_file = "/var/log/janus.log"        # Whether to use a log file or not
    debug_level = 5                            # Debug/logging level, valid values are 0-7
    debug_timestamps = true                # Whether to show a timestamp for each log line
    #debug_colors = false                    # Whether colors should be disabled in the log
    #debug_locks = true                        # Whether to enable debugging of locks (very verbose!)
    #log_prefix = "[janus] "                # In case you want log lines to be prefixed by some
                                            # custom text, you can use the 'log_prefix' property.
                                            # It supports terminal colors, meaning something like
                                            # "[\x1b[32mjanus\x1b[0m] " would show a green "janus"
                                            # string in square brackets (assuming debug_colors=true).

** # demonize는 실행할 때 옵션으로 설정할 수 있으니, default로 두겠습니다. **

        # This is what you configure if you want to launch Janus as a daemon
    #daemonize = true                        # Whether Janus should run as a daemon
                                            # or not (default=run in foreground)
    #pid_file = "/path/to/janus.pid"        # PID file to create when Janus has been
                                            # started, and to destroy at shutdown

** # authenticate는 default로 사용하겠습니다. (설정해서 사용하는 것은 따로 포스팅하도록 하겠습니다.) # api_secret : 모든 API request에 해당 string을 인증 수단의 하나로써 포함시켜야 합니다. # token_auth : token 기반의 인증을 활성화합니다. 모든 request에 유효한 token을 포함해야 합니다. 이는 비밀번호 관리하듯이 관리할 수 있어 보안 수준이 아주 높진 않습니다. # token_auth_secret : HMAC-SHA1 서명 token을 인증 수단으로 사용합니다. HMAC은 단방향 해시 암호화 알고리즘으로, 해독이 불가합니다. 따라서, 굉장히 높은 보안 수준을 자랑합니다. 물론 이 또한 token의 형태이므로, 탈취 자체에는 취약합니다. # admin_secret : Admin API를 사용하기 위한 암호를 설정합니다. Admin API를 이용한 모니터링을 활용하기 위해서 필요합니다. **

        # There are different ways you can authenticate the Janus and Admin APIs
    #api_secret = "janusrocks"        # String that all Janus requests must contain
                                    # to be accepted/authorized by the Janus core.
                                    # Useful if you're wrapping all Janus API requests
                                    # in your servers (that is, not in the browser,
                                    # where you do the things your way) and you
                                    # don't want other application to mess with
                                    # this Janus instance.
    #token_auth = true                # Enable a token based authentication
                                    # mechanism to force users to always provide
                                    # a valid token in all requests. Useful if
                                    # you want to authenticate requests from web
                                    # users.
    #token_auth_secret = "janus"    # Use HMAC-SHA1 signed tokens (with token_auth). Note that
                                    # without this, the Admin API MUST
                                    # be enabled, as tokens are added and removed
                                    # through messages sent there.
    admin_secret = "janusoverlord"    # String that all Janus requests must contain
                                    # to be accepted/authorized by the admin/monitor.
                                    # only needed if you enabled the admin API
                                    # in any of the available transports.

** # 일반 설정 파트입니다. # interface : SDP에 사용될 인터페이스를 정의합니다. Docker로 올릴 경우, Docker network interface가 설정되어, 로컬 네트워크 인터페이스로 설정하더라도 자동으로 변경됩니다. 이를 원치 않을 경우, Docker network를 수정해야 합니다. 이 포스트에서는 다루지 않도록 합니다. # session_timeout : 아무 요청이 없을 때 세션이 자동 만료되는 시간을 설정합니다. 기본값이 60이며, 초 단위입니다. timeout을 짧게 잡게 되면 세션을 유지하기 위해 많은 횟수의 keepalive 요청이 필요합니다. 이는 퍼포먼스 저하로 이어질 수 있습니다. 따라서 timeout은 너무 부족하지 않게 설정하는 것이 좋습니다. 이 포스트에서는 default 값을 사용하겠습니다. # candidates_timeout : ICE trickle 하는 과정에 대한 timeout입니다. 비동기 프로세스로 진행되기 때문에 큰 차이는 없겠지만 Janus가 candidates 정보를 가지고 있는 시간을 설정하는 것이므로, 너무 길면 퍼포먼스에 영향을 줄 수 있습니다. 이 포스트에서는 default 값을 사용하겠습니다. # reclaim_session_timeout : 통신이 끝난 세션이 회수될 때까지의 시간을 설정합니다. timeout을 길게 잡으면 Janus가 세션 정보를 유지하고 있어야 합니다. 이 역시 퍼포먼스 저하로 이어질 수 있습니다. default는 0이며, 통신이 끝난 세션은 바로 회수됩니다. 이 포스트에서는 default 값을 사용하겠습니다. # 나머지 설명이 없는 부분은 default 세팅을 사용하시면 됩니다. 세팅을 하고 싶으신 분은 주석의 설명을 읽고 설정하시기 바랍니다. **

        # Generic settings
    #interface = "1.2.3.4"            # Interface to use (will be used in SDP)
    #server_name = "MyJanusInstance"# Public name of this Janus instance
                                    # as it will appear in an info request
    #session_timeout = 60            # How long (in seconds) we should wait before
                                    # deciding a Janus session has timed out. A
                                    # session times out when no request is received
                                    # for session_timeout seconds (default=60s).
                                    # Setting this to 0 will disable the timeout
                                    # mechanism, which is NOT suggested as it may
                                    # risk having orphaned sessions (sessions not
                                    # controlled by any transport and never freed).
                                    # To avoid timeouts, keep-alives can be used.
    #candidates_timeout = 45        # How long (in seconds) we should keep hold of
                                    # pending (trickle) candidates before discarding
                                    # them (default=45s). Notice that setting this
                                    # to 0 will NOT disable the timeout, but will
                                    # be considered an invalid value and ignored.
    #reclaim_session_timeout = 0    # How long (in seconds) we should wait for a
                                    # janus session to be reclaimed after the transport
                                    # is gone. After the transport is gone, a session
                                    # times out when no request is received for
                                    # reclaim_session_timeout seconds (default=0s).
                                    # Setting this to 0 will disable the timeout
                                    # mechanism, and sessions will be destroyed immediately
                                    # if the transport is gone.
    #recordings_tmp_ext = "tmp"        # The extension for recordings, in Janus, is
                                    # .mjr, a custom format we devised ourselves.
                                    # By default, we save to .mjr directly. If you'd
                                    # rather the recording filename have a temporary
                                    # extension while it's being saved, and only
                                    # have the .mjr extension when the recording
                                    # is over (e.g., to automatically trigger some
                                    # external scripts), then uncomment and set the
                                    # recordings_tmp_ext property to the extension
                                    # to add to the base (e.g., tmp --> .mjr.tmp).
    #event_loops = 8                # By default, Janus handles each have their own
                                    # event loop and related thread for all the media
                                    # routing and management. If for some reason you'd
                                    # rather limit the number of loop/threads, and
                                    # you want handles to share those, you can do that
                                    # configuring the event_loops property: this will
                                    # spawn the specified amount of threads at startup,
                                    # run a separate event loop on each of them, and
                                    # add new handles to one of them when attaching.
                                    # Notice that, while cutting the number of threads
                                    # and possibly reducing context switching, this
                                    # might have an impact on the media delivery,
                                    # especially if the available loops can't take
                                    # care of all the handles and their media in time.
                                    # As such, if you want to use this you should
                                    # provision the correct value according to the
                                    # available resources (e.g., CPUs available).
    #opaqueid_in_api = true            # Opaque IDs set by applications are typically
                                    # only passed to event handlers for correlation
                                    # purposes, but not sent back to the user or
                                    # application in the related Janus API responses
                                    # or events; in case you need them to be in the
                                    # Janus API too, set this property to 'true'.
    #hide_dependencies = true        # By default, a call to the "info" endpoint of
                                    # either the Janus or Admin API now also returns
                                    # the versions of the main dependencies (e.g.,
                                    # libnice, libsrtp, which crypto library is in
                                    # use and so on). Should you want that info not
                                    # to be disclose, set 'hide_dependencies' to true.
        # The following is ONLY useful when debugging RTP/RTCP packets,
        # e.g., to look at unencrypted live traffic with a browser. By
        # default it is obviously disabled, as WebRTC mandates encryption.
    #no_webrtc_encryption = true
        # Janus provides ways via its API to specify custom paths to save
        # files to (e.g., recordings, pcap captures and the like). In order
        # to avoid people can mess with folders they're not supposed to,
        # you can configure an array of folders that Janus should prevent
        # creating files in. If the 'protected_folder' property below is
        # commented, no folder is protected.
        # Notice that at the moment this only covers attempts to start
        # an .mjr recording and pcap/text2pcap packet captures.
    protected_folders = [
        "/bin",
        "/boot",
        "/dev",
        "/etc",
        "/initrd",
        "/lib",
        "/lib32",
        "/lib64",
        "/proc",
        "/sbin",
        "/sys",
        "/usr",
        "/var",
            # We add what are usually the folders Janus is installed to
            # as well: we don't just put "/opt/janus" because that would
            # include folders like "/opt/janus/share" that is where
            # recordings might be saved to by some plugins
        "/opt/janus/bin",
        "/opt/janus/etc",
        "/opt/janus/include",
        "/opt/janus/lib",
        "/opt/janus/lib32",
        "/opt/janus/lib64",
        "/opt/janus/sbin"
    ]
}

** # 인증서 파트입니다. # 인증서를 사용해서 DTLS를 사용하고 싶으신 분은 설정을 진행하시면 됩니다. # Janus는 기본적으로 DTLS를 지원합니다. 인증서가 없더라도 self-signed cert를 통해 DTLS를 사용할 수 있습니다. # 이 포스트에서는 default 세팅을 사용하겠습니다. **

# Certificate and key to use for DTLS (and passphrase if needed). If missing,
# Janus will autogenerate a self-signed certificate to use. Notice that
# self-signed certificates are fine for the purpose of WebRTC DTLS
# connectivity, for the time being, at least until Identity Providers
# are standardized and implemented in browsers. If for some reason you
# want to enforce the DTLS stack in Janus to enforce valid certificates
# from peers, though, you can do that setting 'dtls_accept_selfsigned' to
# 'false' below: DO NOT TOUCH THAT IF YOU DO NOT KNOW WHAT YOU'RE DOING!
# You can also configure the DTLS ciphers to offer: the default if not
# set is "DEFAULT:!NULL:!aNULL:!SHA256:!SHA384:!aECDH:!AESGCM+AES256:!aPSK"
# Finally, by default NIST P-256 certificates are generated (see #1997),
# but RSA generation is still supported if you set 'rsa_private_key' to 'true'.
certificates: {
    #cert_pem = "/path/to/certificate.pem"
    #cert_key = "/path/to/key.pem"
    #cert_pwd = "secretpassphrase"
    #dtls_accept_selfsigned = false
    #dtls_ciphers = "your-desired-openssl-ciphers"
    #rsa_private_key = false
}

** # 미디어 관련 세팅입니다. # ipv6 : ipv6를 지원할 것인지에 대한 세팅입니다. 아직까지 ipv6가 꼭 필요한 경우는 거의 없다고 봐도 무방합니다. 또한, 이 포스트에서는 demo 서비스까지만 다룰 것이므로, ipv6는 지원하지 않도록 false로 세팅합니다. # rtp_port_range : RTP와 RTCP를 위해 사용될 포트 범위를 지정합니다. 포트를 많이 사용할수록 Janus 리소스가 많이 사용됩니다. demo 서비스에서 개인이 테스트할 정도만 필요하니, 30개 포트만 사용하겠습니다. video, audio 모두 RTP 통신을 하므로 Peer 2개가 연결됐을 때, 총 4개의 RTP 포트가 사용됩니다. Peer 3개가 연결됐을 때는 각 3개씩 총 9개의 RTP 포트가 사용됩니다. # 나머지 세팅은 default 값을 사용하겠습니다. **

# Media-related stuff: you can configure whether if you want
# to enable IPv6 support, the minimum size of the NACK queue (in ms,
# defaults to 200ms) for retransmissions no matter the RTT, the range of
# ports to use for RTP and RTCP (by default, no range is envisaged), the
# starting MTU for DTLS (1200 by default, it adapts automatically),
# how much time, in seconds, should pass with no media (audio or
# video) being received before Janus notifies you about this (default=1s,
# 0 disables these events entirely), how many lost packets should trigger
# a 'slowlink' event to users (default=4), and how often, in milliseconds,
# to send the Transport Wide Congestion Control feedback information back
# to senders, if negotiated (default=200ms). Finally, if you're using BoringSSL
# you can customize the frequency of retransmissions: OpenSSL has a fixed
# value of 1 second (the default), while BoringSSL can override that. Notice
# that lower values (e.g., 100ms) will typically get you faster connection
# times, but may not work in case the RTT of the user is high: as such,
# you should pick a reasonable trade-off (usually 2*max expected RTT).
media: {
    ipv6 = false
    #min_nack_queue = 500
    rtp_port_range = "10000-10030"
    #dtls_mtu = 1200
    #no_media_timer = 1
    #slowlink_threshold = 4
    #twcc_period = 100
    #dtls_timeout = 500
    # If you need DSCP packet marking and prioritization, you can configure
    # the 'dscp' property to a specific values, and Janus will try to
    # set it on all outgoing packets using libnice. Normally, the specs
    # suggest to use different values depending on whether audio, video
    # or data are used, but since all PeerConnections in Janus are bundled,
    # we can only use one. You can refer to this document for more info:
    # https://tools.ietf.org/html/draft-ietf-tsvwg-rtcweb-qos-18#page-6
    # That said, DON'T TOUCH THIS IF YOU DON'T KNOW WHAT IT MEANS!
    #dscp = 46
}

** # NAT 관련 세팅입니다. 로컬에서만 테스트할 때는 설정이 필요없습니다. NAT를 통하는 경우에는 설정을 해야 합니다. # stun_server : stun 서버를 지정합니다. default stun 서버가 사용 가능한 상태이므로, 주석만 해제하여 사용하도록 하겠습니다. # stun_port : public으로 열어둔 stun 서버의 포트는 대부분 3478입니다. IANA에 지정돼 있는 well-known port로, 표준입니다. 마찬가지로 주석을 해제하여 사용하도록 하겠습니다. # nice_debug : libnice를 설치했다면 사용이 가능합니다. true로 설정할 경우, debug 모드가 활성화되어 candidate 관련 로그가 debug level로 출력됩니다. default 값이 주석이 해제된 상태로 false 설정되어 있습니다. default 값을 사용하도록 하겠습니다. # nat_1_1_mapping : NAT 맵핑을 설정합니다. 머신의 public IP address를 맵핑 값으로 설정합니다. # 해당 파트 다음으로 오는 설정들은 모두 default 값을 사용합니다. **

# NAT-related stuff: specifically, you can configure the STUN/TURN
# servers to use to gather candidates if the gateway is behind a NAT,
# and srflx/relay candidates are needed. In case STUN is not enough and
# this is needed (it shouldn't), you can also configure Janus to use a
# TURN server# please notice that this does NOT refer to TURN usage in
# browsers, but in the gathering of relay candidates by Janus itself,
# e.g., if you want to limit the ports used by a Janus instance on a
# private machine. Furthermore, you can choose whether Janus should be
# configured to do full-trickle (Janus also trickles its candidates to
# users) rather than the default half-trickle (Janus supports trickle
# candidates from users, but sends its own within the SDP), and whether
# it should work in ICE-Lite mode (by default it doesn't). Finally,
# you can also enable ICE-TCP support (beware that this may lead to problems
# if you do not enable ICE Lite as well), choose which interfaces should
# be used for gathering candidates, and enable or disable the
# internal libnice debugging, if needed.
nat: {
    stun_server = "stun.voip.eutelia.it"
    stun_port = 3478
    nice_debug = false
    #full_trickle = true
    #ice_lite = true
    #ice_tcp = true
    # By default Janus tries to resolve mDNS (.local) candidates: even
    # though this is now done asynchronously and shouldn't keep the API
    # busy, even in case mDNS resolution takes a long time to timeout,
    # you can choose to drop all .local candidates instead, which is
    # helpful in case you know clients will never be in the same private
    # network as the one the Janus instance is running from. Notice that
    # this will cause ICE to fail if mDNS is the only way to connect!
    #ignore_mdns = true
    # In case you're deploying Janus on a server which is configured with
    # a 1:1 NAT (e.g., Amazon EC2), you might want to also specify the public
    # address of the machine using the setting below. This will result in
    # all host candidates (which normally have a private IP address) to
    # be rewritten with the public address provided in the settings. As
    # such, use the option with caution and only if you know what you're doing.
    # Make sure you keep ICE Lite disabled, though, as it's not strictly
    # speaking a publicly reachable server, and a NAT is still involved.
    # If you'd rather keep the private IP address in place, rather than
    # replacing it (and so have both of them as advertised candidates),
    # then set the 'keep_private_host' property to true.
    # Multiple public IP addresses can be specified as a comma separated list
    # if the Janus is deployed in a DMZ between two 1-1 NAT for internal and
    # external users.
    nat_1_1_mapping = "1.2.3.4"  # The machine's public IP address
    #keep_private_host = true
    # You can configure a TURN server in two different ways: specifying a
    # statically configured TURN server, and thus provide the address of the
    # TURN server, the transport (udp/tcp/tls) to use, and a set of valid
    # credentials to authenticate...
    #turn_server = "myturnserver.com"
    #turn_port = 3478
    #turn_type = "udp"
    #turn_user = "myuser"
    #turn_pwd = "mypassword"
    # ... or you can make use of the TURN REST API to get info on one or more
    # TURN services dynamically. This makes use of the proposed standard of
    # such an API (https://tools.ietf.org/html/draft-uberti-behave-turn-rest-00)
    # which is currently available in both rfc5766-turn-server and coturn.
    # You enable this by specifying the address of your TURN REST API backend,
    # the HTTP method to use (GET or POST) and, if required, the API key Janus
    # must provide. Notice that the 'opaque_id' provided via Janus API will be
    # used as the username for a specific PeerConnection by default; if that one
    # is missing, the 'session_id' will be used as the username instead.
    #turn_rest_api = "http://yourbackend.com/path/to/api"
    #turn_rest_api_key = "anyapikeyyoumayhaveset"
    #turn_rest_api_method = "GET"
    # You can also choose which interfaces should be explicitly used by the
    # gateway for the purpose of ICE candidates gathering, thus excluding
    # others that may be available. To do so, use the 'ice_enforce_list'
    # setting and pass it a comma-separated list of interfaces or IP addresses
    # to enforce. This is especially useful if the server hosting the gateway
    # has several interfaces, and you only want a subset to be used. Any of
    # the following examples are valid:
    #     ice_enforce_list = "eth0"
    #     ice_enforce_list = "eth0,eth1"
    #     ice_enforce_list = "eth0,192.168."
    #     ice_enforce_list = "eth0,192.168.0.1"
    # By default, no interface is enforced, meaning Janus will try to use them all.
    #ice_enforce_list = "eth0"
    # In case you don't want to specify specific interfaces to use, but would
    # rather tell Janus to use all the available interfaces except some that
    # you don't want to involve, you can also choose which interfaces or IP
    # addresses should be excluded and ignored by the gateway for the purpose
    # of ICE candidates gathering. To do so, use the 'ice_ignore_list' setting
    # and pass it a comma-separated list of interfaces or IP addresses to
    # ignore. This is especially useful if the server hosting the gateway
    # has several interfaces you already know will not be used or will simply
    # always slow down ICE (e.g., virtual interfaces created by VMware).
    # Partial strings are supported, which means that any of the following
    # examples are valid:
    #     ice_ignore_list = "vmnet8,192.168.0.1,10.0.0.1"
    #     ice_ignore_list = "vmnet,192.168."
    # Just beware that the ICE ignore list is not used if an enforce list
    # has been configured. By default, Janus ignores all interfaces whose
    # name starts with 'vmnet', to skip VMware interfaces:
    ice_ignore_list = "vmnet"
    # In case you want to allow Janus to start even if the configured STUN or TURN
    # server is unreachable, you can set 'ignore_unreachable_ice_server' to true.
    # WARNING: We do not recommend to ignore reachability problems, particularly
    # if you run Janus in the cloud. Before enabling this flag, make sure your
    # system is correctly configured and Janus starts after the network layer of
    # your machine is ready. Note that Linux distributions offer such directives.
    # You could use the following directive in systemd: 'After=network-online.target'
    # https://www.freedesktop.org/software/systemd/man/systemd.unit.html#Before=
    #ignore_unreachable_ice_server = true
}
# You can choose which of the available plugins should be
# enabled or not. Use the 'disable' directive to prevent Janus from
# loading one or more plugins: use a comma separated list of plugin file
# names to identify the plugins to disable. By default all available
# plugins are enabled and loaded at startup.
plugins: {
    #disable = "libjanus_voicemail.so,libjanus_recordplay.so"
}
# You can choose which of the available transports should be enabled or
# not. Use the 'disable' directive to prevent Janus from loading one
# or more transport: use a comma separated list of transport file names
# to identify the transports to disable. By default all available
# transports are enabled and loaded at startup.
transports: {
    #disable = "libjanus_rabbitmq.so"
}
# As a core feature, Janus can log either on the standard output, or to
# a local file. Should you need more advanced logging functionality, you
# can make use of one of the custom loggers, or write one yourself. Use the
# 'disable' directive to prevent Janus from loading one or more loggers:
# use a comma separated list of logger file names to identify the loggers
# to disable. By default all available loggers are enabled and loaded at startup.
loggers: {
    #disable = "libjanus_jsonlog.so"
}
# Event handlers allow you to receive live events from Janus happening
# in core and/or plugins. Since this can require some more resources,
# the feature is disabled by default. Setting broadcast to yes will
# enable them. You can then choose which of the available event handlers
# should be loaded or not. Use the 'disable' directive to prevent Janus
# from loading one or more event handlers: use a comma separated list of
# file names to identify the event handlers to disable. By default, if
# broadcast is set to yes all available event handlers are enabled and
# loaded at startup. Finally, you can choose how often media statistics
# (packets sent/received, losses, etc.) should be sent: by default it's
# once per second (audio and video statistics sent separately), but may
# considered too verbose, or you may want to limit the number of events,
# especially if you have many PeerConnections active. To change this,
# just set 'stats_period' to the number of seconds that should pass in
# between statistics for each handle. Setting it to 0 disables them (but
# not other media-related events).
events: {
    #broadcast = true
    #disable = "libjanus_sampleevh.so"
    #stats_period = 5
}

janus.plugin.videoroom.jcfg

이 파트에서는 두 개의 방을 생성해두고 사용하는 sample을 보여줍니다. 방을 구성하는 속성들을 설정해보고 테스트할 수 있습니다. 이 방들은 사전에 Janus에서 이와 같이 config 설정으로 만들어야만 하는 것은 아닙니다. Janus에 REST-API로 방 생성 요청을 할 수 있고, 원하는 옵션을 선택해서 방을 생성할 수 있습니다. 따로 설정을 바꾸어 테스트하는 것은 포스트에 포함하지 않겠습니다.

# room-<unique room ID>: {
# description = This is my awesome room
# is_private = true|false (whether this room should be in the public list, default=true)
# secret = <optional password needed for manipulating (e.g. destroying) the room>
# pin = <optional password needed for joining the room>
# require_pvtid = true|false (whether subscriptions are required to provide a valid private_id 
#            to associate with a publisher, default=false)
# publishers = <max number of concurrent senders> (e.g., 6 for a video
#              conference or 1 for a webinar)
# bitrate = <max video bitrate for senders> (e.g., 128000)
# bitrate_cap = true|false (whether the above cap should act as a hard limit to
#            dynamic bitrate changes by publishers; default=false, publishers can go beyond that)
# fir_freq = <send a FIR to publishers every fir_freq seconds> (0=disable)
# audiocodec = opus|g722|pcmu|pcma|isac32|isac16 (audio codec(s) to force on publishers, default=opus
#            can be a comma separated list in order of preference, e.g., opus,pcmu)
# videocodec = vp8|vp9|h264|av1|h265 (video codec(s) to force on publishers, default=vp8
#            can be a comma separated list in order of preference, e.g., vp9,vp8,h264)
# vp9_profile = VP9-specific profile to prefer (e.g., "2" for "profile-id=2")
# h264_profile = H.264-specific profile to prefer (e.g., "42e01f" for "profile-level-id=42e01f")
# opus_fec = true|false (whether inband FEC must be negotiated; only works for Opus, default=false)
# video_svc = true|false (whether SVC support must be enabled; only works for VP9, default=false)
# audiolevel_ext = true|false (whether the ssrc-audio-level RTP extension must
#        be negotiated/used or not for new publishers, default=true)
# audiolevel_event = true|false (whether to emit event to other users or not, default=false)
# audio_active_packets = 100 (number of packets with audio level, default=100, 2 seconds)
# audio_level_average = 25 (average value of audio level, 127=muted, 0='too loud', default=25)
# videoorient_ext = true|false (whether the video-orientation RTP extension must
#        be negotiated/used or not for new publishers, default=true)
# playoutdelay_ext = true|false (whether the playout-delay RTP extension must
#        be negotiated/used or not for new publishers, default=true)
# transport_wide_cc_ext = true|false (whether the transport wide CC RTP extension must be
#        negotiated/used or not for new publishers, default=true)
# record = true|false (whether this room should be recorded, default=false)
# rec_dir = <folder where recordings should be stored, when enabled>
# lock_record = true|false (whether recording can only be started/stopped if the secret
#            is provided, or using the global enable_recording request, default=false)
# notify_joining = true|false (optional, whether to notify all participants when a new
#               participant joins the room. The Videoroom plugin by design only notifies
#               new feeds (publishers), and enabling this may result extra notification
#               traffic. This flag is particularly useful when enabled with require_pvtid
#               for admin to manage listening only participants. default=false)
# require_e2ee = true|false (whether all participants are required to publish and subscribe
#             using end-to-end media encryption, e.g., via Insertable Streams; default=false)
#}
general: {
    #admin_key = "supersecret"        # If set, rooms can be created via API only
                                    # if this key is provided in the request
    #lock_rtp_forward = true        # Whether the admin_key above should be
                                    # enforced for RTP forwarding requests too
    #events = false                    # Whether events should be sent to event
                                    # handlers (default=true)
    # By default, integers are used as a unique ID for both rooms and participants.
    # In case you want to use strings instead (e.g., a UUID), set string_ids to true.
    #string_ids = true
}
room-1234: {
    description = "Demo Room"
    secret = "adminpwd"
    publishers = 6
    bitrate = 128000
    fir_freq = 10
    #audiocodec = "opus"
    #videocodec = "vp8"
    record = false
    #rec_dir = "/path/to/recordings-folder"
}
# This other demo room here is only there in case you want to play with
# the VP9 SVC support. Notice that you'll need a Chrome launched with
# the flag that enables that support, or otherwise you'll be using just
# plain VP9 (which is good if you want to test how this indeed affect
# what receivers will get, whether they're encoding SVC or not).
room-5678: {
    description = "VP9-SVC Demo Room"
    secret = "adminpwd"
    publishers = 6
    bitrate = 512000
    fir_freq = 10
    videocodec = "vp9"
    video_svc = true
}

janus.transport.http.jcfg

** # Janus에 http request를 보낼 때의 설정입니다. # admin_http : Janus Admin / Monitor API를 위해 true로 설정합니다. Janus에 생성된 세션과 핸들 정보를 모두 볼 수 있습니다. # 나머지 설정은 default로 두겠습니다. cors, 인증서 파트는 Janus 앞에 Web Server를 두어 설정할 수도 있습니다. **

# Web server stuff: whether any should be enabled, which ports they
# should use, whether security should be handled directly or demanded to
# an external application (e.g., web frontend) and what should be the
# base path for the Janus API protocol. Notice that by default
# all the web servers will try and bind on both IPv4 and IPv6: if you
# want to only bind to IPv4 addresses (e.g., because your system does not
# support IPv6), you should set the web server 'ip' property to '0.0.0.0'.
general: {
    #events = true                    # Whether to notify event handlers about transport events (default=true)
    json = "indented"                # Whether the JSON messages should be indented (default),
                                    # plain (no indentation) or compact (no indentation and no spaces)
    base_path = "/janus"            # Base path to bind to in the web server (plain HTTP only)
    http = true                        # Whether to enable the plain HTTP interface
    port = 8088                        # Web server HTTP port
    #interface = "eth0"                # Whether we should bind this server to a specific interface only
    #ip = "192.168.0.1"                # Whether we should bind this server to a specific IP address (v4 or v6) only
    https = false                    # Whether to enable HTTPS (default=false)
    #secure_port = 8089                # Web server HTTPS port, if enabled
    #secure_interface = "eth0"        # Whether we should bind this server to a specific interface only
    #secure_ip = "192.168.0.1"        # Whether we should bind this server to a specific IP address (v4 or v6) only
    #acl = "127.,192.168.0."        # Only allow requests coming from this comma separated list of addresses
}
# Janus can also expose an admin/monitor endpoint, to allow you to check
# which sessions are up, which handles they're managing, their current
# status and so on. This provides a useful aid when debugging potential
# issues in Janus. The configuration is pretty much the same as the one
# already presented above for the webserver stuff, as the API is very
# similar: choose the base bath for the admin/monitor endpoint (/admin
# by default), ports, etc. Besides, you can specify
# a secret that must be provided in all requests as a crude form of
# authorization mechanism, and partial or full source IPs if you want to
# limit access basing on IP addresses. For security reasons, this
# endpoint is disabled by default, enable it by setting admin_http=true.
admin: {
    admin_base_path = "/admin"            # Base path to bind to in the admin/monitor web server (plain HTTP only)
    admin_http = true                    # Whether to enable the plain HTTP interface
    admin_port = 7088                    # Admin/monitor web server HTTP port
    #admin_interface = "eth0"            # Whether we should bind this server to a specific interface only
    #admin_ip = "192.168.0.1"            # Whether we should bind this server to a specific IP address (v4 or v6) only
    admin_https = false                    # Whether to enable HTTPS (default=false)
    #admin_secure_port = 7889            # Admin/monitor web server HTTPS port, if enabled
    #admin_secure_interface = "eth0"    # Whether we should bind this server to a specific interface only
    #admin_secure_ip = "192.168.0.1        # Whether we should bind this server to a specific IP address (v4 or v6) only
    #admin_acl = "127.,192.168.0."        # Only allow requests coming from this comma separated list of addresses
}
# The HTTP servers created in Janus support CORS out of the box, but by
# default they return a wildcard (*) in the 'Access-Control-Allow-Origin'
# header. This works fine in most situations, except when we have to
# respond to a credential request (withCredentials=true in the XHR). If
# you need that, uncomment and set the 'allow_origin' below to specify
# what must be returned in 'Access-Control-Allow-Origin'. More details:
# https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS
cors: {
    #allow_origin = "http://foo.example"
}
# Certificate and key to use for HTTPS, if enabled (and passphrase if needed).
# You can also disable insecure protocols and ciphers by configuring the
# 'ciphers' property accordingly (no limitation by default).
certificates: {
    #cert_pem = "/path/to/cert.pem"
    #cert_key = "/path/to/key.pem"
    #cert_pwd = "secretpassphrase"
    #ciphers = "PFS:-VERS-TLS1.0:-VERS-TLS1.1:-3DES-CBC:-ARCFOUR-128"
}

janus.transport.websockets.jcfg

** # 웹 소켓 관련 설정입니다. # Admin 관련 API는 http를 통해서만 request하겠습니다. # 모두 default 값으로 설정하겠습니다. **

# WebSockets stuff: whether they should be enabled, which ports they
# should use, and so on.
general: {
    #events = true                    # Whether to notify event handlers about transport events (default=true)
    json = "indented"                # Whether the JSON messages should be indented (default),
                                    # plain (no indentation) or compact (no indentation and no spaces)
    #pingpong_trigger = 30            # After how many seconds of idle, a PING should be sent
    #pingpong_timeout = 10            # After how many seconds of not getting a PONG, a timeout should be detected
    ws = true                        # Whether to enable the WebSockets API
    ws_port = 8188                    # WebSockets server port
    #ws_interface = "eth0"            # Whether we should bind this server to a specific interface only
    #ws_ip = "192.168.0.1"            # Whether we should bind this server to a specific IP address only
    wss = false                        # Whether to enable secure WebSockets
    wss_port = 8989                # WebSockets server secure port, if enabled
    #wss_interface = "eth0"            # Whether we should bind this server to a specific interface only
    #wss_ip = "192.168.0.1"            # Whether we should bind this server to a specific IP address only
    #ws_logging = "err,warn"        # libwebsockets debugging level as a comma separated list of things
                                    # to debug, supported values: err, warn, notice, info, debug, parser,
                                    # header, ext, client, latency, user, count (plus 'none' and 'all')
    #ws_acl = "127.,192.168.0."        # Only allow requests coming from this comma separated list of addresses
}
# If you want to expose the Admin API via WebSockets as well, you need to
# specify a different server instance, as you cannot mix Janus API and
# Admin API messaging. Notice that by default the Admin API support via
# WebSockets is disabled.
admin: {
    admin_ws = false                    # Whether to enable the Admin API WebSockets API
    admin_ws_port = 7188                # Admin API WebSockets server port, if enabled
    #admin_ws_interface = "eth0"        # Whether we should bind this server to a specific interface only
    #admin_ws_ip = "192.168.0.1"        # Whether we should bind this server to a specific IP address only
    admin_wss = false                    # Whether to enable the Admin API secure WebSockets
    admin_wss_port = 7989                # Admin API WebSockets server secure port, if enabled
    #admin_wss_interface = "eth0"        # Whether we should bind this server to a specific interface only
    #admin_wss_ip = "192.168.0.1"        # Whether we should bind this server to a specific IP address only
    #admin_ws_acl = "127.,192.168.0."    # Only allow requests coming from this comma separated list of addresses
}
# Certificate and key to use for any secure WebSocket server, if enabled (and passphrase if needed).
# You can also disable insecure protocols and ciphers by configuring the
# 'ciphers' property accordingly (no limitation by default).
# Examples of recommended cipher strings at https://cheatsheetseries.owasp.org/cheatsheets/TLS_Cipher_String_Cheat_Sheet.html
certificates: {
    #cert_pem = "/etc/letsencrypt/live/nimbus-cert/fullchain.pem"
    #cert_key = "/etc/letsencrypt/live/nimbus-cert/privkey.pem"
    #cert_pwd = "nimbus0425"
    #ciphers = "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256"
}

이로써 Janus Gateway Video room config 설정이 끝났습니다. 다음 포스팅에서는 Janus Gateway Server와 Janus demo page의 연동을 다루겠습니다. 감사합니다.👍

오늘은 WebRTC에 대해 알아보겠습니다.

최근에 코로나 팬데믹으로 재택 근무가 자리 잡고, 학교는 비대면 수업을 진행하게 됐습니다. 그로 인해, 화상회의가 비대면 만남의 매개체가 돼 주고 있습니다. 화상회의는 어떻게 만들어졌는지, 어떤 기술인지 알아보겠습니다.

이후의 포스팅은 Janus Gateway를 구동 및 demo 페이지 연동을 통한 나만의 화상회의 구현 과정이 되겠습니다.

What is WebRTC

WebRTC (Web Real-Time Communication)은 브라우저 상에서 영상이나 오디오같은 미디어를 스트림하고 데이터 교환까지 할 수 있게 하는 기술입니다. 어쭙잖은 설명으로 원래의 정의나 기술에 대해 잘 전달하지 못하게 될 수 있으니 공식 문서 URL을 첨부하겠습니다. MDN Web DOCs :: WebRTC_API 문서에서 설명하고 있듯이 WebRTC는 브라우저 상에서 이용되는 기술입니다. 브라우저에서 사용할 수 있으니 별도의 Application 설치가 필요 없고, 동시에 PC의 저장 공간을 차지하지 않는다는 장점이 있습니다. 그리고, WebRTC는 Peer-to-peer 방식을 사용하여 완전한 P2P를 지원합니다. 때문에 중간에 서버를 거치는 것이 아닌 이용자 간의 통신이 가능합니다.

NAT를 나가서 외부 통신을 하는 경우엔 다른 서버의 도움을 받아야 합니다. (gif image from wowza blog :: what is webrtc) 위의 gif 이미지를 보면 WebRTC Cloud Server와 2개의 End-point가 서로 통신하는 모습을 볼 수 있습니다. 위의 WebRTC Server가 아닌, STUN / TURN 서버를 통해 시그널링을 하며 P2P로 연결할 수도 있습니다. WebRTC Server를 통해 상대에 대한 정보(SDP, offer, answer)를 주고 받고 P2P 통신을 할 수 있게 됩니다. (WebRTC에 대한 좀 더 개념적인 설명은 따로 포스팅해서 연결하겠습니다.) WebRTC - samples 위의 샘플을 통해 WebRTC 예제를 실행, 테스트 및 학습할 수 있습니다.

위의 모든 것들을 좀 더 쉽게 개발하고 이용할 수 있게 해주는 것이 오픈소스 WebRTC Server입니다. 그리고 우리는 Janus Gateway를 사용하도록 하겠습니다.

Janus Gateway

Janus Gateway는 위에서 짧게 설명한 WebRTC를 사용할 수 있게 구현한 WebRTC Server입니다. 기본적인 WebRTC 기능을 포함하며, Meetecho 팀이 구현한 여러 종류의 플러그인이 제공됩니다. 브라우저에서는 제공된 플러그인의 여러 기능(echo tests, conference bridges, media recorders, SIP gateways 등)을 사용할 수 있습니다. 또한 Janus는 ICE, DTLS, SRTP 모두를 제공합니다. 따로 구성할 필요가 없습니다. Janus Docs Janus-Gateway Github Janus는 ICE Server 역할을 포함합니다. ICE Server 역할을 한다는 것은 P2P 연결의 중간자 역할을 한다는 것입니다. 어? 분명 완전한 P2P라고 하지 않았나? Janus를 사용하지 않고 WebRTC를 구현할 때, NAT 외부의 사용자와 연결할 경우엔 꼭 STUN이나 TURN에 요청해, 상대방의 SDP 정보를 받은 후에 P2P 연결이 가능합니다. Janus를 거치지 않을 경우, TURN 서버가 ICE Server의 역할을 할 수 있습니다. 하지만 우리는 Janus를 사용한 케이스만 보기로 합니다. Janus가 ICE Server의 역할을 하며, 브라우저는 ICE Server를 통해 P2P 연결을 구성합니다. ICE : Interactive Connectivity Establishment (상호 연결을 돕는 프레임워크) 그리하여 Janus가 P2P 연결의 중간자 역할을 담당합니다.

Janus installation

Janus 설치는 Github 링크를 참조바랍니다. Janus Github repo 페이지를 보시면 설명이 아주 친절하게 되어 있습니다. 정말 설치 과정 하나는 따로 설명하지 않아도 될 정도입니다.

Dependencies

To install it, you'll need to satisfy the following dependencies:

Jansson

• Janus는 C언어로 개발된 서버입니다. C언어에서 JSON타입을 인코딩/디코딩하기 위해 사용되는 라이브러리입니다.

libconfig

• config 세팅을 위한 라이브러리로, Janus config file 구성을 위해 필수입니다.

libnice (at least v0.1.16 suggested, v0.1.18 recommended)

• ICE(Interactive Connectivity Setup) 표준(RFC 5245 & RFC 8445)을 구현하는 라이브러리입니다.

OpenSSL (at least v1.0.1e)

• TLS 및 SSL 사용을 위한 라이브러리입니다.

libsrtp (at least v2.x suggested)

• SRTP(Secure Real-time Transport Protocol)를 위한 라이브러리입니다. README.md에도 쓰여 있듯이 2.2.0 버전을 사용하시기 바랍니다. 2.3.0 버전 사용 시, 에러가 발생할 수 있으며, 이는 --enable-openssl 이나 --enable-nss flag를 설정함으로써 해결할 수 있다고 나와 있지만 에러가 발생한 버전이니 추천하지 않는 모양입니다. (설치 과정에도 2.2.0 버전을 사용하게끔 안내되어 있습니다.)

usrsctp (only needed if you are interested in Data Channels)

• 데이터 채널을 사용할 때에만 필요합니다.

libmicrohttpd (at least v0.9.59; only needed if you are interested in REST support for the Janus API)

• Janus API를 REST 방식으로 사용하려면 필요합니다.

libwebsockets (only needed if you are interested in WebSockets support for the Janus API)

• Janus는 Websocket 방식과 http를 사용한 long poll 방식으로 사용이 가능합니다. libwebsockets는 Websocket 방식을 사용할 때 필요합니다.

cmake (only needed if you are interested in WebSockets and/or BoringSSL support, as they make use of it)

• Websocket 방식을 사용하려면 필요합니다.

rabbitmq-c (only needed if you are interested in RabbitMQ support for the Janus API or events)

• Messaging에 queue방식을 사용할 때 필요합니다.

paho.mqtt.c (only needed if you are interested in MQTT support for the Janus API or events)

• C언어 기반의 MQTT 클라이언트이며, IOT를 위한 라이브러리입니다.

nanomsg (only needed if you are interested in Nanomsg support for the Janus API)

• 몇 가지 일반적인 통신 패턴을 제공하는 소켓 라이브러리입니다. 네트워킹 계층을 빠르게, 확장 가능하게, 사용하기 쉽게 만드는 것을 목표로 합니다.

libcurl (only needed if you are interested in the TURN REST API support)

• 멀티프로토콜 파일 전송 라이브러리로, 클라이언트 사이드의 URL 전송 라이브러리입니다.

이하 라이브러리는 본인이 사용할 플러그인에 따라 설치하면 됩니다. A couple of plugins depend on a few more libraries:

Sofia-SIP (only needed for the SIP plugin) libopus (only needed for the AudioBridge plugin) libogg (needed for the VoiceMail plugin and/or post-processor, and optionally AudioBridge and Streaming plugins) libcurl (only needed if you are interested in RTSP support in the Streaming plugin or in the sample Event Handler plugin) Lua (only needed for the Lua plugin)

아래 라이브러리 / 도구는 필요합니다. Additionally, you'll need the following libraries and tools:

GLib zlib pkg-config gengetopt

이상, 설치에 앞서 dependencies를 확인했습니다. 이하, 설치를 진행하도록 하겠습니다.

설치 과정은 Janus Gateway Github 페이지에 나온 순서대로 진행하시면 됩니다. 그럼 제가 설명할 것은 없습니다. Janus 서버 빌드하는 과정에 많은 dependencies가 요구되어, 로컬 pc의 환경에 설치하는 게 부담이 될 수 있습니다. 그런 분들은 아래 Dockerfile을 참조하셔서 Image를 빌드한 후에 사용하시면 됩니다.

Dockerfile

FROM ubuntu:bionic
RUN echo ' \n\
APT::Periodic::Update-Package-Lists "0";\n\
APT::Periodic::Unattended-Upgrade "1";\n'\
> /etc/apt/apt.conf.d/20auto-upgrades
RUN set -x \
    && apt-get update && apt-get install -y build-essential snapd aptitude git wget golang \
    python3 python3-pip python3-setuptools python3-wheel ninja-build \
    libgstreamer1.0-dev libgirepository1.0-dev libunwind-dev apt-utils libsrtp-dev \
    gdb \
    && aptitude install -y libmicrohttpd-dev libjansson-dev libnice-dev \
    libssl-dev libsofia-sip-ua-dev libglib2.0-dev libopus-dev libogg-dev \
    libconfig-dev libavutil-dev libavcodec-dev libavformat-dev libnanomsg-dev \
    libcurl4-openssl-dev liblua5.3-dev pkg-config gengetopt libtool automake curl jq httpie vim screen doxygen graphviz
RUN set -x \
    && wget https://cmake.org/files/v3.16/cmake-3.16.2.tar.gz \
    && tar -xvzf cmake-3.16.2.tar.gz \
    && cd cmake-3.16.2 \
    && ./bootstrap --prefix=/usr/local \
    && make && make install
RUN set -x \
    && python3 -m pip install meson \
    && python3 -m pip install ninja
RUN  set -x \
    && cd  \
    && wget https://github.com/cisco/libsrtp/archive/v2.2.0.tar.gz \
    && tar xfv v2.2.0.tar.gz  \
    && cd libsrtp-2.2.0/ \
    && ./configure --prefix=/usr --enable-openssl \
    && make shared_library && make install
RUN  set -x \
    && git clone https://boringssl.googlesource.com/boringssl \
    && cd boringssl \
    && sed -i s/" -Werror"//g CMakeLists.txt \
    && mkdir -p build \
    && cd build \
    && cmake -DCMAKE_CXX_FLAGS="-lrt" .. \
    && make \
    && cd .. \
    && mkdir -p /opt/boringssl \
    && cp -R include /opt/boringssl/ \
    && mkdir -p /opt/boringssl/lib \
    && cp build/ssl/libssl.a /opt/boringssl/lib/ \
    && cp build/crypto/libcrypto.a /opt/boringssl/lib/
RUN  set -x \
    && git clone https://github.com/sctplab/usrsctp \
    && cd usrsctp \
    && ./bootstrap \
    && ./configure --prefix=/usr --disable-programs --disable-inet --disable-inet6 \ 
    && make && make install
RUN  set -x \
    && git clone https://github.com/warmcat/libwebsockets.git \
    && cd libwebsockets \
    && mkdir build \
    && cd build \
    && cmake -DLWS_MAX_SMP=1 -DLWS_WITHOUT_EXTENSIONS=0 -DCMAKE_INSTALL_PREFIX:PATH=/usr -DCMAKE_C_FLAGS="-fpic" .. \
    && make && make install
RUN set -x \
    && git clone https://github.com/eclipse/paho.mqtt.c.git \
    && cd paho.mqtt.c \
    && make && make install
RUN set -x \
    && git clone https://github.com/alanxz/rabbitmq-c \
    && cd rabbitmq-c \
    && git submodule init \
    && git submodule update \
    && mkdir build && cd build \
    && cmake -DCMAKE_INSTALL_PREFIX=/usr .. \
    && make && make install
RUN set -x \
    && git clone https://gitlab.freedesktop.org/libnice/libnice \
    && cd libnice \
    && meson --prefix=/usr build && ninja -C build && ninja -C build install
RUN export JANUS_WITH_POSTPROCESSING
RUN  set -x \
    && git clone https://github.com/meetecho/janus-gateway.git \
    && cd janus-gateway \
    && sh autogen.sh \
    && ./configure --prefix=/opt/janus \
    && make \
    && make install \
    && make configs
RUN  set -x \
    && rm -rf /libwebsockets \
    && rm -rf /janus-gateway \
    && rm -rf /boringssl
RUN adduser --disabled-password --gecos '' janus
USER janus
RUN /opt/janus/bin/janus --v
CMD ["/opt/janus/bin/janus"]

``` 위의 순서로 진행하시면 되고, 아래 몇 개의 디렉터리를 제거한 이유는 단순히 image 크기를 줄이기 위함입니다. 맨 위의 update 관련한 내용은 OS 버전 업그레이드를 자동으로 수행하는 걸 방지합니다. apt 패키지 설치하는 파트에서 시간이 꽤 많이 소요되며, 메모리를 많이 사용하게 됩니다. 빌드할 때 가급적 다른 프로세스를 추가 동작하지 않는 게 좋습니다. 한 번 빌드를 하면 각 스텝 별로 caching되기 떄문에 다시 빌드할 때에 큰 부담이 없습니다. apt 패키지만 설치하는 image를 만들고 그 image를 사용해서 새로운 Dockerfile을 작성하셔도 됩니다.

이상으로 WebRTC가 무엇인지, WebRTC Server인 Janus Gateway 설치 과정을 포스팅했습니다. 이 다음은 Janus Gateway demo 페이지를 로컬 환경에 띄우고 직접 빌드한 Janus Gateway 서버를 연동하는 포스트를 준비하겠습니다. 감사합니다.👍

이번엔 Docker image 빌드에 관한 포스팅입니다. 이전 포스트에서 Docker image를 pull해서 사용하는 방법까지 알아봤습니다. 이번 포스트에서는 직접 image를 만들어서 사용하려고 합니다.

• Docker Repo : image push 및 Version Control
  • Docker Repo : Create Repository
  • Docker Repo : push image
  • Docker Repo : Version Control
• Docker image build :
  • Dockerfile 작성 : C언어를 시작하는 환경 구성하기
  • Build image using Dockerfile

Docker Repo : image push 및 Version Control

이전 포스트에서 Docker image를 pull해서 사용했습니다. 다른 누군가, 다른 단체가 빌드해서 public repository 저장소에 push해서 올린 image를 pull해서 다운로드 받은 것입니다. 이처럼 Docker image를 다른 사람이 사용할 수 있게 하려면 image를 Docker hub에 올려야 합니다. 검색을 통해 image를 찾고, 사용할 수 있게 됩니다.

Docker Repo : Create Repository

그럼 일단 계정이 있어야 합니다. 그건 이전 포스트에서 Docker hub 가입도 마쳤으니 이번엔 개인 repository를 생성합니다. 여기 Repositories로 들어가서 Create Repository를 누르면 repo를 생성할 수 있습니다. 생성할 때, public이나 private로 생성할 수 있습니다. Docker hub subscribe를 하지 않은 상태라면 private repository는 계정당 1개만 생성할 수 있습니다. public repo는 모두에게 오픈되어 있으며, 아무나 사용이 가능합니다. private repo는 나를 제외한 모두에게 열람 권한이 없습니다. image 여러 개를 나만 쓰고 싶은데 private repo를 1개만 생성 가능해서 불편하다고 느끼신다면 아래에서 소개할 image 빌드를 통해 어느 정도 불편함을 해소할 수 있습니다. (사실 해소라기 보다 다른 불편함으로 대체되는 것입니다..)

저는 repository 이름을 c-project라고 지었습니다. 제 계정이 eon이라고 한다면 제 repository path는 eon/c-project 입니다. repo path라고 말씀드렸지만 사실은 이 자체가 image의 이름입니다.

아직 image 빌드를 하지 않은 상태라 repository에 올릴 image가 없습니다. 그래도 일단 repository를 만들었으니 push하는 방법을 알아보겠습니다.

Docker Repo : push image

docker push <Image_Name>:<TAG>

image는 기본적으로 image 이름과 태그로 구성되어 있습니다.
TAG는 버전을 기입하는 용도로 쓰입니다.
TAG는 image를 빌드할 때 붙일 수 있으며, 빌드 이후에도 수정이 가능합니다.

위에서 언급한 제 repository path인 eon/c-project 가 image 이름이라고 했습니다.
그래서 push를 할 때는 아래와 같이 됩니다. 
>```
  docker push eon/c-project:<TAG>

첫 이미지가 될 테니 TAG는 0.0.1로 하겠습니다.

  docker push eon/c-project:0.0.1

이렇게 명령어를 실행하면 제가 생성한 repository에 빌드한 이미지가 올라옵니다.

Docker Repo : Version Control

Docker image에 TAG를 부여함으로써 image의 버전을 표기했습니다. TAG를 붙여서 push를 함으로써, push되는 모든 image에는 버전이 붙게 됩니다. 그리고 그 버전들은 각각 별개의 image가 됩니다. TAG에 따라 발생할 문제가 다 다를 테니, 문제가 있는 버전은 repo에서 제거함으로써 안전한 사용을 위한 관리도 할 수 있습니다.

Docker image build

Docker image를 빌드하려면 Dockerfile을 작성해야 합니다. Dockerfile의 작성법은 단순하면서도 복잡합니다. 단순히 OS를 처음 설치하고, 내가 원하는 서비스를 설치하는 과정을 그대로 텍스트로 작성하면 되는 것입니다.

Dockerfile 작성 : C언어를 시작하는 환경 구성하기

Dockerfile

The base image (OS) is ubuntu bionic..

FROM ubuntu:bionic

RUN set -x is as same as to run these commands after ''..

RUN set -x \

Update apt package list as latest..

&& apt-get update \

Install gcc and gdb.. gcc for compile c language, gdb for debugger..

&& apt-get install -y gcc gdb

RUN set -x
&& mkdir -p ~/cproject/helloworldDir

In dockerfile, '#'is for comment.. so if the line including '#' right below, it would be ignored by dockerfile syntax..

To resolve this problem, separate the lines like below..

RUN echo "#include <stdio.h>" > ~/cproject/helloworldDir/helloworld.c RUN echo '
int main(void){\n
printf("helloworld!\n");\n
return 0;\n
}' >> ~/cproject/helloworldDir/helloworld.c RUN set -x
&& cat ~/cproject/helloworldDir/helloworld.c RUN set -x
&& gcc -o ~/cproject/helloworldDir/helloworld ~/cproject/helloworldDir/helloworld.c

You may choose one below..

#CMD ["/root/cproject/helloworldDir/helloworld"] CMD ["/bin/bash"]

Dockerfile 작성 시, 위의 내용의 경우, 개행하는 방법을 알아두어야 합니다.
개행할 때는 "\"로 하고, 이어지는 명령어 작성은 "&&"로 이어갈 수 있습니다.
FROM, RUN , CMD와 같은 명령어 블럭은 각각 한 **step**을 의미합니다.
(step을 구성할 수 있는 명령어는 [Dockerfile reference docs](https://docs.docker.com/engine/reference/builder/)에 소개돼 있습니다.)
Dockerfile을 빌드하다가 error를 만나서 빌드가 중단되는 경우가 종종 있습니다.
때문에 **step을 적절하게 나눠주는 것**이 중요합니다.
**이미 앞에서 성공한 step은 Docker가 caching하기 때문에, 성공한 step을 다시 빌드하지는 않습니다.
단, 성공한 step 1과 step 2 사이에 step을 하나 추가하게 되면 추가한 step부터 다시 빌드를 합니다.**
Dockerfile 빌드에 시간이 꽤나 소요되기 때문에 효율적으로 step을 나누는 것이 좋습니다.
추가로, step은 image layer로 등록돼서 push할 때 조각 조각으로 나눠서 push하게 됩니다.
step 하나가 굉장히 길어지게 되면 해당 image layer만 엄청 커져서 push할 때 시간이 오래 걸릴 수도 있고 리소스를 많이 사용하게 돼, 다른 실행 중인 프로세스에 좋지 않은 영향을 줄 수 있습니다.
추가 +) 위와 같이 소스 코드를 echo를 활용해서 작성하는 방법은 당연히 좋지 않은 방법입니다. 그냥 이런 것도 가능하다는 걸 보여드리기 위함입니다. ubuntu 위에 C언어 환경이 구성된 container를 만들기 위함이라면 apt 패키지 설치까지와 최하단 CMD만 남겨두시면 됩니다.

이렇게 환경을 구성하고, 설치하고 즉시 실행까지 가능합니다.
위의 주석처리된 CMD 파트를 실행하면 컴파일된 바이너리 파일이 실행됩니다.
출력 결과는 당연하게도 "helloworld!"입니다.

위의 내용을 Dockerfile이라는 파일명으로 저장하시면 됩니다.
물론 다른 이름으로 저장하셔도 상관없으나, vscode 등의 IDE를 사용할 때에 파일명을 Dockerfile로 사용하시면 가독성이나 syntax 체크가 훨씬 편할 수 있습니다. (IDE가 제공하는 font 색상 등으로 line이나 주석 구분이 쉬워짐)
***
#### Build image using Dockerfile
Dockerfile 빌드를 해보겠습니다.
아래와 같이 명령어 입력 후 실행합니다.
>```
  docker build -t ${IMAGE_NAME:TAG} -f ./Dockerfile .

-t : 태그 옵션입니다. -f : 빌드할 Dockerfile의 path를 지정합니다. (Default is 'PATH/Dockerfile') -. : PATH | URL 입력하는 부분입니다. build 후에 이미지를 전송합니다.

마지막에 '.'은 다른 PATH를 참조하지 않을 때 사용합니다. Docker hub repository를 참조할 경우, '.'을 default로 사용합니다. 외에 -t나 -f 옵션은 말 그대로 옵션입니다. 하지만 image를 쉽게 재사용이나 버전 관리를 하기 위해 -t 옵션을 사용해서 태그를 붙입니다. -f 옵션은 Dockerfile이 있는 디렉터리에서 빌드할 경우엔 필요없는 옵션입니다.

저는 태그를 지정해서 image를 빌드했습니다. eon/c-project:0.0.1

이제, 포스트 초반에 설명한 push를 할 수 있습니다.

  docker push eon/c-project:0.0.1

``` 이제 eon/c-project repository에 0.0.1 태그가 달린 eon/c-project:0.0.1 image가 push됐습니다.

image의 사용은 꼭 pull을 하고 써야 하는가? 아닙니다. 위와 같이 로컬에서 빌드하고 바로 사용할 수 있습니다. 때문에 repo path나 TAG 등은 무시하고 빌드해도 image의 사용에는 문제가 없습니다.

이번 포스트에서는 Dockerfile로 image를 빌드하는 방법과 image를 repo에 push하는 방법을 소개했습니다. 위에 예시로 만든 image는 ubuntu bionic 기반, gcc와 gdb도 설치하니 해당 image로 container를 생성해서 구동시키면 그 안에서 c언어 컴파일과 실행 및 디버깅이 가능합니다.

이것으로 오늘 포스팅을 마치겠습니다. 감사합니다.👍