chap. 01

Go 개발환경

• Scale up vs. Scale out
  1.1 GO 도구 설치
  1.2 GO 작업 공간
• GO PATH 환경 변수
• 작업 공간의 기본 디렉터리
  : $HOME/go

cf.) 셸이란?

'셸(Shell)'은 사용자의 명령어를 해석하고 운영체제가 알아들을 수 있게 지시해주는 것으로, 사용자와 커널을 이어주는 것이다.

'커널(kernel)'은 이와 같은 내용을 받아 하드웨어에 직접적으로 명령을 내려준다.

셸 : 사용자가 글자를 입력하여 컴퓨터에 명령할 수 있도록 하는 프로그램

터미널/콘솔 : 셸을 실행하기 위해 글자 입력을 받아 컴퓨터에 전달하거나 컴퓨터의 출력을 글자 화면에 쓰는 프로그램

1.3 go 명령어

• go run go 파일...|go 패키지

• 작은 프로그램 테스트
• Go를 스크립트 언어처럼 사용 시

• go build go 파일...|go 패키지

• 바이너리(실행파일) 생성

• go build hello.go
  go build -o hello_world.exe
  hello.go

1.3.2 서드 파티 Go 도구 설치

• go는 다른 언어와 달리 자신의 코드 저장소를 공유하여 패키지를 직접 다운받고 설치 가능

• 예)
  go install github.com/rakyll/hey@latest

1.3.3 코드 포매팅

• 효율적인 코드 작성을 위함

• go fmt

• 들여쓰기 공백 수정
• 구조체 항목 정렬
• 연산자 주변 적절한 공백 사용 체크

• goimports

• import 문 정리
  • 알파벳 순 정렬
  • 사용되지 않은 import 삭제
  • import 추측(추론): 100% 정확하지 않음
• enhanced go fmt
• go install 명령으로 설치 필요 (p.28 참조)

• 세미콜론 삽입 규칙

• go fmt는 이 규칙에 의해 잘못 삽입된 중괄호({})는 수정 못함
• Go 컴파일러가 자동으로 문장 끝에 세미콜론을 붙여줌
• 규칙
  • 식별자
  • 기본 리터럴
  • 다음 토큰 중 하나: break, continue, fallthrough, return, ++, ‘--’, }, )

1.4 린팅, 베팅

• Effective Go

• https://go.dev/doc/effective_go

• Go 위키의 코드 리뷰 규칙

• linter

• 1978년 시작
• 코드가 스타일 가이드를 잘 지켰는지 확인
• 알맞은 변수 이름 지정
• ...
• 100% 정확도 아님

1.5 개발 도구 소개

1.5.1 비주얼 스튜디오 코드

• Go 개발을 위한 VS Code 구성

• https://docs.microsoft.com/ko-kr/azure/developer/go/configure-visual-studio-code

1.5.3 Go Playground

1.6 Makefiles 텍스트 파일

• make 프로그램 필요

---

chap. 02

기본 데이터 타입과 선언

2.1 내장 타입

• https://go101.org/article/basic-types-and-value-literals.html

  1) 불리언
  2) 숫자

  • 정수: 주로 int 사용, 경우에 따라 byte
  • 실수
  • 복소수
    3) 문자열
    4) 별칭: byte(uint8), rune(int32)

2.1.1 제로 값

• 선언되었으나 값이 할당되지 않은 변수에 기본 값 제로(0) 할당

2.1.2 리터럴

• 코드에 작성하는 값 그 자체

• 정수 리터럴

• 10진수, 8진수, 16진수, 2진수 ⇒ 접두사 이용 (없음, 0o, 0x, 0b)
• 밑줄(underscore): 정수 리터럴 사이에

• 부동 소수점 리터럴

• 점(.)
• e(E) 지수 표현
• 밑줄 가능

• 룬 리터럴

• 작은 따옴표
• 단일 유니코드 문자, 8비트 8진 숫자, 8비트 16진수 숫자, 16비트 16진수 숫자, 32비트 유니코드
• 이스케이프 시퀀스: ‘\n’, ‘\t’, …

• 문자 리터럴

• 두 가지 방법
• 1) 해석된 문자열 리터럴: 큰 따옴표 사용
  • 이스케이프 룬이 처리가 됨
• 2) 로(raw) 문자열: 역따옴표(백틱) 사용

• 다른 타입으로 선언된 두 정수는 연산 불가능

• 하지만, 부동소수점 변수에 정수 리터럴 사용 가능
  정수 변수에 부동소수점 리터럴 사용 가능
• 왜냐, 리터럴 자체에는 데이터 타입이 없으므로

• Go 언어는 실용적 언어 => 리터럴에는 타입이 정해져 있지 않다

2.1.3 불리언

• true, false

2.1.4 숫자 타입

• 정수 타입

• 특수한 경우 아니면 int 사용

• 특수 정수 타입들

• byte: uint8 보다 선호
• int: 플랫폼에 따라서 int32, int64
• uint: 플랫폼에 따라서 uint32, uint64
• rune: int32지만 용도가 다르다
• uintptr: 포인터

• 정수 연산자

• 산술연산자의 결과는 정수
• 복합대입연산자도 지원
• 비교연산자
• 비트연산자
• 시프트연산자
• 논리연산자

• 부동소수 타입

• float32, float64(기본 타입)
• %(나머지 연산)에 대해서는 정의되어 있지 않음
• 부동소수 변수끼리 ==, != 비교는 가능하나 사용하지 말자

• 복소수 타입

2.1.5 문자열과 룬 맛보기

• 문자열

• 제로 값: 비어있는 문자열
• 비교연산자 가능
• 연결연산자(+)
• 불변(immutable)
• 큰 따옴표

• 룬

• 단일 코드 포인트
• 작은 따옴표
• int32의 별칭

2.1.6 명시적 타입 변환
cf.) Explicit vs. Implicit
명시적 vs. 암시적(암묵적)
⇒ Manual vs. Automatic

• 자동 타입 변환

• 편리하나
• 변환 규칙이 복잡, 예기치 못한 결과 초래 가능

• Go는 자동 타입 변환 불허

• 의도의 명확성 및 가독성 중시 때문
• 명시적으로 타입 변환해야 함
  -> 모든 타입 변환 규칙을 외울 필요 없음

• 다른 Go 타입을 불리언으로 취급할 수 없다.

• 조건식은 반드시 비교식으로 작성

2.2 var vs. :=

• 변수 선언 스타일에 따른 의도가 존재

• var 키워드
  [SYNTAX]
  var 변수 타입 = 값(표현식)

• 값의 타입이 예상가능하면 타입 생략 가능
• 값을 생략하면 타입의 제로 값이 대입
• 같은 타입의 여러 변수 또는 다른 타입의 여러 변수 동시 선언 가능
• 여러 변수의 제로 값 동시 선언 가능

• 다양한 변수를 한 번에 선언

• 선언리스트를 괄호로 묶어서

• := 짧은 선언

• var 키워드(X)
• 타입(X)
• 함수 밖에서는 사용 불가 = package 레벨에서 사용 불가

2.3 const 사용

• 상수: 상수 변수
• 한 번 대입한 값을 변경할 수 없다
• 컴파일 시 값이 결정되어야 한다, 즉 변수를 대입할 수 없다.
• 리터럴에 이름을 부여하는 방법

2.4 타입 지정 상수와 타입 미지정 상수

• 타입 미지정 상수는 리터럴과 같은 취급
• 타입 미지정 상수는 리터럴과 같은 취급
• 타입 지정 상수는 해당 타입 변수에만 할당해야 함

2.5 사용하지 않는 변수

• 지역 변수는 반드시 사용되어야 함
• 사용되지 않는 상수는 허용

2.6 변수와 상수 이름 짓기

• Go는 유니코드 문자를 식별자로 허용

• 권장하지 않음

• Go는 관용적으로 스네이크 표기법 사용하지 않음

• 낙타 표기법, 파스칼 표기법 사용

• 상수: 모든 문자를 대문자, 각 단어는 밑줄로 구분

• Go는 이러한 일반 상수 이름 규칙을 따르지 않는다
• 패키지에 포함된 요소를 외부에 노출시킬지(expose) 여부를 식별자의 첫글자가 대소문자 여부로 결정

• 함수 내에서는 짧은 변수 이름 선호

• 변수의 의미보다 간결성을 선호하는 Go

• 짧은 이름

• 코드 간결
• 코드의 복잡도 판별 기준

• 패키지 블록 내

• 설명적인 변수, 상수 이름 사용하자

---

chap. 03

복합 타입

3.1 배열(array)

• 같은 타입의 여러 데이터를 담음
• 시퀀스 타입 (순서 중요)
• Go에서는 선호하지 않음(특별한 경우에만 사용)
• 선언 시 크기를 지정해야 함
• 크기를 변경할 수 없다
• 배열 간 비교 가능(==, !=)
• 배열 인덱스는 범위를 벗어나서는 안되고 음수도 불가

• 선언 방법
  1) 제로 값으로 선언: 배열의 크기와 배열 내 요소 타입 지정
  2) 배열 초깃값 지정: 배열 리터럴 사용
  3) 희소 배열: 대부분의 요소가 0인 배열
  4) 배열 크기 지정하지 않고: 배열 리터럴 필요
  5) 다차원 배열: []의 개수가 차원 수

• 배열 요소 접근

• [] 사용

• 배열 길이

• len() 함수

• Go에서 배열을 잘 사용하지 않는 이유

• 배열의 크기가 배열의 타입을 결정하는데 사용되기 때문
• 즉, 타입이 같은 배열이라도 크기가 다르면 다른 타입
• 크기(길이)가 다르면 타입 변환도 불가능

3.2 슬라이스

• 일련의 값(시퀀스)을 저장하는 자료 구조

• 순서 중요

• 슬라이스의 크기는 타입의 일부가 아니다 (배열과의 큰 차이점)

• 슬라이스 간 비교는 불가 (배열과 다른 점)

• 단, nil과는 비교 가능(==, !=)

• 슬라이스 선언 (슬라이스 크기를 지정하지 않음)
  1) 슬라이스 초깃값 지정: 슬라이스 리터럴
  2) 희소 슬라이스
  3) 다차원 슬라이스
  4) 제로 슬라이스: 슬라이스 리터럴 없이 선언만 하는 것

  • 슬라이스의 제로 값은 nil
  • nil : 값의 부재(absence of value) 상태
  • nil은 타입이 없음
    5) 비어있는 슬라이스: 슬라이스 리터럴에 초깃값이 없는 것
    6) make() 함수 사용하여 생성: 수용량 지정 가능

• 슬라이스의 길이

• len() 함수 사용

3.2.2 append

• 슬라이스에 새로운 요소 추가
• append의 결과를 할당하지 않으면 컴파일 에러

3.2.3 수용력(capacity)

• 예약된(미리 준비된) 연속적인(consecutive) 메모리 공간의 크기
• 길이와 수용력
• 수용력 >= 길이
• 요소가 추가되면 길이는 커지고 결국 수용력과 같아짐
• 길이과 수용력이 같은 상태에서 요소가 추가되면 Go 런타임이 더 큰 수용력을 가지는 새로운 슬라이스를 할당, 원본 슬라이스의 값들은 새 슬라이스에 복사됨, 추가된 값은 새 슬라이스에 append되고 이 새 슬라이스가 반환된다.
• 수용력이 1024 보다 작으면 2배 증가, 그렇지 않으면 25%씩 확장
• cap() vs. len()

3.2.4 make()

• 슬라이스에 저장될 요소 개수를 미리 알 수 있다면 make()를 사용해 효율적인 슬라이스 작업을 도모할 수 있다
• make로 생성한 슬라이스에 append를 사용할 땐 주의할 것

3.2.5 슬라이스 선언

• var data []int => nil

• var data = []int{} => nil(X)

• 슬라이스를 아래 방식 중 어떤 걸로 생성할 지 정리해 봅시다.(p.75)

• 제로 슬라이스
• 슬라이스 리터럴
• make()

3.2.6 슬라이싱의 슬라이싱

• 슬라이스 연산자(:)

• 슬라이스로부터 슬라이스 생성

• 슬라이스 연산자를 사용하면 복사본을 만들지 않고 메모리를 공유함

• 슬라이싱과 append를 함께 사용하면 혼란이 가중됨

• 하위 슬라이스의 수용력
  = 원본 슬라이스의 수용력 - 하위 슬라이스 시작 오프셋

• 하위 슬라이스와 append를 아무 생각 없이 사용하면 혼란이 가중된다.

• 의도치 않은 값 변경이 발생
• 완전한 슬라이스 표현식(full slice expression)으로 해결

• 완전한 슬라이스 표현식
  • 하위 슬라이스에 얼마나 많은 메모리를 공유할 것인지를 지정
  • 슬라이스 연산때 콜론을 한 번 더 사용하여 세번째 인자에 원본 슬라이스에서 하위 슬라이스의 마지막 요소의 위치 지정
  • 슬라이스 연산의 세 번째 인자의 값을 두 번째 인자의 값과 같도록 설정

3.2.7 배열을 슬라이스로 변환

• 배열에 슬라이스 연산 적용
• 메모리 공유 문제 존재

3.2.8 copy

• copy() 내장 함수
• copy의 첫 번째 인자는 슬라이스이어야 함

3.3 문자열과 룬 그리고 바이트

• 문자열은 룬으로 이루어진 것은 아니다.
• 문자열은 바이트의 시퀀스이다.
• 문자열의 길이는 바이트 수
• 문자열에 슬라이스 연산 사용 가능

• 문자열은 수정불가(immutable)이므로 슬라이스의 메모리 공유 문제가 없음
• 유니코드로 구성되므로 슬라이스를 했을 때 문자가 깨지는 우려가 있음

• 문자열은 바이트 슬라이스 또는 룬 슬라이스로 변환 가능

3.4 맵

• 순서 없는 데이터 처리 유용
• (Key, Value) Pair
  [SYNTAX]
  var 변수명 map[키타입]값타입
• 값: 어느 타입도 가능
• 키: 몇 가지 제약

• 생성
  1) nil 맵(제로 값 할당): map의 제로 값은 nil
  • nil 맵은 길이 0
  • nil 맵의 값을 읽으면 맵 값이 되는 타입의 제로 값
  • nil 맵에 값을 쓰려고 하면 패닉 발생
    2) 비어 있는 맵 리터럴: 비어 있는 맵 생성
  • nil 맵과 다르다
  • 길이는 0
  • 비어 있는 맵 리터럴이 할당된 맵을 읽고 쓸 수 있다.
    3) 값이 있는 맵 리터럴
  • 키와 값을 콜론으로 구분
  • 마지막 요소(키, 값)의 끝에 콤마(,)를 붙인다.

4) make() 함수로 생성

• 맵의 요소 개수를 안다면
• 길이는 0 (make()로 슬라이스 만드는 것과 다름)
• 초기 지정 개수 이상으로 커질 수 있다.
• 맵의 제로 값은 nil
• 맵은 비교 불가능, 단 nil과 같은지 다른지는 비교 가능

3.4.1 맵 읽고 쓰기

• := 연산자는 사용 불가
• 아직 설정되지 않은 키에 할당된 값을 읽으면 값 타입의 제로 값이 반환된다.

3.4.2 콤마 OK 관용구(idiom)

• 맵의 키에 대응되는 값이 없어도 제로 값이 리턴되지만
• 맵에 키가 존재하는지 확인할 필요가 있을 때 주로 사용하는 패턴

• 맵에 키가 없어서 제로 값이 반환되는 건지
• 실제로 키가 있는데 해당 값이 제로인 건지

3.4.3 맵 (요소) 삭제

• delete() 내장 함수 사용
• 키가 존재하지 않거나 nil 맵인 경우 아무것도 일어나지 않음
• delete() 함수는 반환값이 없음

3.4.4 맵을 셋(집합)으로 이용

• 집합(셋)

• Uniqueness, 순서 없음

• Go는 집합형을 직접 지원하지 않고 맵을 통해 간접적으로 지원

• 집합의 원소로 쓰고 싶은 타입을 맵의 키 타입으로
• 맵의 값을 불리언으로 설정

3.5 구조체

• 여러 데이터 타입을 한데 묶어서 다루고 싶을 때 사용
• struct 키워드, type 키워드
• 구조체는 사용자 정의 타입
• 따라서 바로 사용할 순 없고
• 1) 구조체 정의 -> 2) 구조체를 타입으로 하는 변수 선언
• 구조체 항목들은 콤마로 구분하지 않는다
• 구조체는 어떤 블록 레벨에서도 정의 가능
• 구조체의 제로 값

• 구조체를 구성하는 항목들의 제로 값

• 구조체 리터럴

• 첫 번째 방법
• 구조체 항목 값은 구조체 정의한 순서대로 나열
• 구조체 항목 값은 콤마로 구분하고 마지막 항목에서 콤마를 붙여야 함
• 두 번째 방법
• 맵 리터럴과 유사
• 순서 무관
• 생략할 경우 제로 값으로 설정

• 위 두 방법을 혼용할 수 없음
• 제로 구조체와 비어 있는 구조체는 차이점이 없다
• 구조체의 멤버(항목)을 접근할 때는 인덱싱이 아니라 점 표기법을 사용

3.5.1 익명 구조체

• 한 번만 사용할 구조체
• type 생략 -> 구조체 이름이 없다.
• 구조체 변수만 존재
• 주요 용도

• 마샬링, 언마샬링
• 테스트 작성

3.5.2 구조체 비교와 변환

• 구조체 비교는 항목에 따라 다름
• 두 개의 구조체가 같은 이름, 순서, 타입으로 구성되어 있으면 구조체 간에 타입 변환 가능

---

chap. 04

블록, 섀도, 제어 구조

4.1 블록(block)

• 선언문이 있는 각각의 공간
• 관련 있는 문장을 묶은 것
• 식별자의 스코프(scope)

• 식별자의 Lifecycle(생명주기)
  : 블록 내에서 선언/정의될 때 식별자가 생성
  : 블록이 끝날때 식별자가 제거
• 즉, 블록 내에서만 해당 식별자를 사용할 수 있고
  블록 밖에서는 해당 식별자를 접근할 수 없다

• 패키지 블록

• 함수 외부에 선언된 것들이 속함
• :=은 사용 불가
• 대문자로 시작하는 식별자는 패키지 외부에 노출(expose)됨
• 노출된 식별자는 점 연산자를 통해 접근
• .go 파일이 여러 개더라도 package 이름이 같으면 같은 패키지 블록에 포함된다

• 파일 블록

• .go 파일에 선언된 것들
• import 문이 포함된 파일

• 함수 블록

• 로컬 변수: 매개변수(파라미터), 반환 변수도 포함
• 모든 중괄호는 새로운(다른) 블록을 정의
• 제어 구조도 자체의 블록을 가진다.

• 유니버스 블록

• 기본 타입, 내장 함수, true/false와 같은 미리 선언된 식별자가 정의된 블록
• 다른 모든 블록을 포함하는 블록
• 따라서 다른 블록에 의해 섀도잉될 가능성이 높다

• 식별자 접근

• 외부 블록에서는 내부 블록의 요소(식별자)에 접근 불가
• 내부 블록에서는 자신과 외부 블록의 요소에 접근 가능

4.1.1 섀도잉 변수

• 섀도잉(Shadowing)

• 외부 블록과 내부 블록의 식별자가 같은 경우 내부 블록의 식별자로 처리
• 내부 식별자에 의해 외부 식별자가 그림자에 가려 보이지 않음

• := 연산자

• 여러 변수를 := 연산자로 초기화할 때
  : 현재 블록에서 선언된 변수들만 재사용된다

• 임포트된 패키지가 섀도잉되지 않도록 주의

• 임포트한 패키지 이름과 같은 식별자를 선언하지 말 것

4.2 if 문

• 조건을 괄호로 감쌀 순 있지만 감싸지 않는 것이 일반적
• if 블록이나 else 블록내에서만 사용가능한 변수를 if 또는 else에서 바로 선언하는 방법

4.3 for 문

• for 문의 4 가지 패턴
  1) C 언어와 동일한 방식의 for

• 변수 초기화는 반드시 := 사용
• for 에서 선언된 변수도 if 처럼 섀도잉 문제 발생 가능

4.3.1 완전한 for 구문
1) 선언부는 한 번만 실행
2) 조건부가 참일 경우에만 for 블록 실행, 거짓이면 for 문 종료
3) 증감부는 for 블록 실행이 끝나고 다시 2)으로 가기전에 실행

4.3.2 조건식만 사용하는 for 문

• for 문을 while 문처럼 사용

4.3.3 for 문을 이용한 무한루프

• for 문의 조건식을 생략한 형태

4.3.4 break와 continue

• 파이썬과 같은 개념
• 코드를 간결하게 보기좋게 만드는데 기여

4.3.5 for-range 문

• 내장 타입의 요소(문자열, 배열, 슬라이스, 맵)를 순회하며 루프 수행
• range가 두 개의 값을 반환

• (index, value) 쌍

  cf.) Go에서는 반환되는 값을 사용할 의도나 필요가 없다면 _(underscore)로 받는다. (Python과 같은 개념)

• 키 값만 순회하는 대표적인 예

• 맵 타입을 집합 타입으로 사용한 경우
• 맵의 값보다는 유니크한 키 값이 중요 ⇒ 집합(셋)

• 맵을 for-range로 순회

• 요소를 처리하는 순서가 일정하지 않다 (보안 이슈)

• 문자열을 for-range 순회

• 룬을 순회, 바이트 순회 아님

• for-range의 값은 복사본

• for-range 값으로 원본을 수정할 수 없다

• 레이블링(labeling)

• 레이블: 프로그램 코드 위치에 이름 붙인 것
• break, continue, goto 문의 대상이 됨

4.3.7 4 가지 중 알맞은 for 문 선택

4.4 switch 문

• switch, case, default, [break]
• 다른 언어의 switch

• fallthrough 기능 존재

• Go는 fallthrough가 기본적으로 금지, fallthrough 키워드로 활성화
  [SYNTAX]
  switch [selector] {
  case value|condition:
  문장1
  문장2
  ...
  case

case

}

• switch의 fallthrough

• break 문을 만날때 까지 다른 case의 내용도 실행

4.5 공백 스위치

• case에 불리언 결과(조건식, 불값을 반환하는 함수)를 사용합니다. selector 없음

4.6 if 문과 switch 문 중 선택

4.7 goto 문

• Go에서 지원은 하지만 없다고 생각하세요

---

chap. 05

함수

5.1 함수 선언과 호출

• 1급 객체
• main 함수

• 프로그램 진입점
• 실행 파일을 만들려면 필요
• 인자 X
• 반환값 X

• 함수 선언 = 함수 헤더(시그니처) + 함수 몸체(바디)
  1) func 키워드
  2) 함수 이름
  3) 입력 파라미터: 반드시 타입 명시 (Go는 정적 언어)
  4) 반환값의 타입
  ⇒ 함수의 시그니처

• return 키워드

• 여러 입력 파라미터가 같은 타입이라면 콤마로 파라미터를 구별하고 타입은 마지막에 기술할 수 있다.

5.1.1 이름이 지정된 파라미터(named paramters)와 선택적 파라미터 대응

• Go는 키워드 파라미터(=named paramter)를 지원하지 않음
• 선택적 파라미터: 파라미터 기본값 X
• Go는 함수를 호출할 때 함수에서 정의한 파라미터를 생략할 수 없음

• 구조체를 사용하면 named parameter 및 선택적 파라미터 방식을 간접적으로 실현

5.1.2 가변 입력 파라미터와 슬라이스

• 임의 개수의 입력 파라미터 처리

• 가변 파라미터는 반드시 함수의 입력 파라미터 목록에서 마지막에 위치

• 타입 이름 앞에 ...

• 가변 파라미터는 함수 내에서는 해당 타입의 슬라이스이다

• 슬라이스를 파라미터로 Unpack하려면 슬라이스뒤에 ...을 붙여준다

5.1.3 다중 반환값

• 함수 정의시 반환값의 타입을 콤마로 구분하고 괄호로 묶어준다

• return 시 반환값을 괄호로 묶지 않는다

• 일반적으로 다중 반환값을 받을 때는 := 사용

5.1.4 다중 반환값은 다중값

• 다중 반환값은 개별 변수로 받아야 함
• 하나의 변수로 받으면 에러

5.1.5 반환되는 값 무시

• 함수의 반환값 개수와 받는 변수 개수가 다르면 컴파일 에러
• 일부만 무시하려면 _(unserscore) 사용
• 모든 반환값을 무시할 수 있다

5.1.6 이름이 지정된 반환값(naked return)

• 함수 정의 시 반환값 타입뿐만 아니라 반환값 파라미터 선언
• 해당 함수의 로컬 변수로 간주
• 코너 케이스
  1) 섀도잉 문제
  2) 해당 변수들을 반환할 필요가 없다.

5.1.7 빈 반환(blank return)

• return 문에 반환값을 사용하지 않은 것
  1) 반환값이 없는 함수
  2) 이름 지정된 반환값을 반환하고자 할 때
  – 이때 return을 생략하면 컴파일 에러

5.2 함수는 값이다

• 함수는 일급 객체다

5.2.1 함수 타입 선언

• Go는 강타입 정적 타입 언어이므로

• 함수를 저장하는 변수는 해당 함수의 타입으로 선언되어야 함
• 함수 타입: type 키워드로 정의
  [SYNTAX]
  type 함수타입명 함수시그니처(함수 이름과 파라미터 이름 제외)

5.2.2 익명 함수

• 이름 없는 함수 ⇒ 재사용 하지 않겠다 = 한 번만 쓴다
• 변수에 저장할 용도가 아니므로 인라인으로 작성한다.
• 익명 함수를 호출해야 하므로 인라인 작성에서 함수 몸체 정의가 끝나고나서 괄호를 사용하여 인자를 넘겨줘야 한다

5.3 클로저(Closure)

• 함수 내부에 선언된 함수 = 내부 함수(inner function)
• 외부 함수에 의해 반환되는 내부 함수, 이 내부 함수는 외부 변수를 참조함

package main
 
func nextValue() func() int {
    i := 0
    return func() int {
        i++
        return i
    }
}
 
func main() {
    next := nextValue()
 
    println(next())  // 1
    println(next())  // 2
    println(next())  // 3
 
    anotherNext := nextValue()
    println(anotherNext()) // 1 다시 시작
    println(anotherNext()) // 2
}

5.3.1 파라미터로 함수를 전달

5.3.2 함수에서 함수 반환

5.4 defer

• 정리작업을 수행하는 함수 지정
• 현재 코드 블록이 끝날 때 자동으로 실행
• defer는 여러번 사용될 수 있다 -> 나중에 defer된 함수가 먼저 실행됨(LIFO)
• defer가 적용된 함수 중 반환값이 있는 함수의 반환값은 따로 읽을 방도가 없다.
• defer와 이름 지정된 반환값

package main
 
import "os"
 
func main() {
    f, err := os.Open("1.txt")
    if err != nil {
        panic(err)
    }
 
    // main 마지막에 파일 close 실행
    defer f.Close()
 
    // 파일 읽기
    bytes := make([]byte, 1024)
    f.Read(bytes)
    println(len(bytes))
}

5.5 값에 의한 호출을 사용하는 Go

• Call by Value: 인자나 반환값은 복사된다
• cf.) Call by Reference: 주소가 복사된다
• 기본 타입, 구조체는 call by value
• 맵

• 파라미터로 넘어온 맵에 대한 변경은 원본에도 적용

• 슬라이스

• 길이 조정 외의 모든 조작이 원본에도 적용

• 맵과 슬라이스는 포인터로 구현이 되었기 때문에 원본도 변경되는 것

---

chap. 06

포인터

6.1 빠른 포인터 입문

• 포인터란?

• 값이 저장된 메모리의 위치 값(주소)를 저장하는 변수

• 주소 연산자(&)

• 간접 연산자(*, dereferencing operator)

• 모든 포인터는 어떤 타입을 가리키던간에 항상 같은 크기

• 포인터의 제로 값: nil

  • 슬라이스, 맵, 함수, 채널, 인터페이스의 제로 값: nil

• nil은 숫자 0이 아닙니다.

  • nil을 숫자로 변경/변환하거니 숫자를 반대로 변환할 수는 없다.

• 포인터 dereferencing 전에 nil인지 확인할 필요 있다.

• 포인터 타입

• 포인터가 가리키는 값의 타입
• 포인터가 어떤 타입의 값을 가리키는지 나타냄
• 포인터 변수를 선언할 때 주로 사용
• 타입 이름 앞에 *
• cf.) 포인터 역참조: 변수 이름 앞에
  x := 10
  var pointerToX int
  pointerToX = &x

• 내장 함수 new()

• 포인터 변수 생성
• 해당 타입의 제로 값을 가리키는 포인터 반환

• 기본 타입의 리터럴이나 상수는 주소가 없으므로 주소연산자를 사용할 수 없다.

• 헬퍼 함수를 사용하여 이 문제를 해결하자

6.2 포인터를 두려워 말라

• Java의 데이터 타입

• 원시 타입(Primitive Type): 8개
  : byte, short, int, long, float, double, bool, char: 값 그 자체, 객체가 아님, call by value
• 클래스: 객체를 참조 변수로 참조해서 작업, call by reference
  : 원시 타입의 클래스: Byte, Short, Integer, Long, Float, Double, Boolean, Character

• Go는 변수를 1)call by value로 할지 2)call by reference로 할지 선택할 수 있다.

• 1) 함수에 변수를 그냥 넘기는 것
• 2) 함수에 변수의 포인터를 넘기는 것

6.3 포인터는 변경 가능한 파라미터를 가리킨다

• 비 포인터 타입: 기본타입, 배열, 구조체 => 원본의 불변성
• 포인터: 함수로 전달되면 포인터의 복사본이 생성 => 원본에 닿을 수 있다. 수정할 수 있다.

6.4 포인터는 최후의 수단

• 포인터

• 데이터 흐름 이해를 어렵게 한다
• GC에게 추가 작업 부하를 건다 (포인터를 이용하면 주로 힙을 이용)
  : 가비지는 힙에 생성

6.5 포인터로 성능 개선

• 포인터는 모든 데이터 타입을 함수로 전달할 때 상수 시간이 걸린다.

• 주소를 함수에 전달하므로, 모든 데이터 타입의 주소 길이는 같다.

• 대략 1메가 바이트 전달 기준으로

• 이상이면 포인터로 전달
• 이하면 값 전달

6.6 제로 값과 값없음의 차이

• 0, ‘ ‘ vs. NULL, ‘’ ⇒ Go: nil
  값이 있음 vs. 값이 없음

• 포인터를 이용하여 변수나 구조체의 항목의 값이 제로 값인지 없는 값인지 구분하는데 사용

• 할당되지 않은 변수나 구조체 항목에 nil 포인터를 사용

• 또한, 포인터는 변경가능함을 나타내므로 함수에서 nil 포인터를 직접 반환하는 것보다 콤마 OK 관용구를 사용하자

• nil 포인터를 함수의 파라미터나 구조체의 항목의 값으로 담아서 함수의 인자로 넘기면 nil 포인터를 통해서는 값을 저장할 수 없으므로 함수 안에서 값을 설정(간접 연산자 *를 사용하는 것)할 수가 없음을 명심

6.7 맵과 슬라이스의 차이

6.8 버퍼 슬라이스

• 메모리 용도에 따른 구분

• 버퍼(buffer)
• 캐시(cache)
• 풀(pool)

6.9 가비지 컬렉션 작업량 줄이기

• 버퍼를 이용하면 GC의 부하를 줄일 수 있다
• 가비지(Garbage)

• 더 이상 어떤 포인터도 가리키지 않는 데이터

---

chap. 07

타입, 메서드, 인터페이스

7.1 Go의 타입

• 내장 타입

• 기본 타입, 복합 타입

• 구조체를 이용한 사용자 정의 타입
• 구체적인 타입(구체 타입, concrete type)
  • cf.) abstract type
    : abstract = general, super, 미완성(상속)
    <-> concrete = specific, sub, 완성(상속)

7.2 메서드

• 타입(type)을 위한 메서드

• 반드시 패키지 블록 레벨에서 정의해야 함

• 리시버(receiver)

• func 키워드와 메서드 이름 사이에 리시버_이름 타입을 괄호 감싸서 정의
• 리시버 식별자는 관례적으로 타입 이름의 짧은 약어인 첫 문자를 사용

package main
 
//Rect - struct 정의
type Rect struct {
    width, height int
}
 
//Rect의 area() 메소드
func (r Rect) area() int {
    return r.width * r.height   
}
 
func main() {
    rect := Rect{10, 20}
    area := rect.area() //메서드 호출
    println(area)
}

7.2.1 포인터 리시버와 값 리시버

• 포인터 리시버: 리시버의 타입 앞에 *을 붙인다

package main

import (
	"fmt"
	"time"
)

type Counter struct {
	total       int
	lastUpdated time.Time
}

func (c *Counter) Increment() {
	c.total++
	c.lastUpdated = time.Now()
}

func (c Counter) String() string {
	return fmt.Sprintf("total: %d, last updated: %v", c.total, c.lastUpdated)
}

func main() {
	var c Counter
	fmt.Println(c.String())
	c.Increment()
	fmt.Println(c.String())
}

• 결정하는 규칙 (p.183)

• 메서드가 리시버를 수정 => 반드시 포인터 리시버 사용
• 메서드가 nil 인스턴스를 처리할 필요 => 반드시 포인터 리시버 사용
• 메서드가 리시버를 수정하지 않음 => 값 리시버 사용 가능

package main
import (
	"fmt"
	"time"
)
type Counter struct {
	total       int
	lastUpdated time.Time
}
func (c *Counter) Increment() {
	c.total++
	c.lastUpdated = time.Now()
}
func (c Counter) String() string {
	return fmt.Sprintf("total: %d, last updated: %v", c.total, c.lastUpdated)
}
func doUpdateWrong(c Counter) {
	c.Increment()
	fmt.Println("in doUpdateWrong:", c.String())
}
func doUpdateRight(c *Counter) {
	c.Increment()
	fmt.Println("in doUpdateRight:", c.String())
}
func main() {
	var c Counter
	doUpdateWrong(c)
	fmt.Println("in main:", c.String())
	doUpdateRight(&c)
	fmt.Println("in main:", c.String())
}

• 이것은 타입에 선언된 다른 메서드에 따라 결정
• 같은 타입에 다른 리시버가 포인터 리시버라면 리시버를 수정하지 않는 메서드라도 포인터 리시버 사용 <= 일관성을 위해

// 포인터 Receiver
func (r *Rect) area2() int {
    r.width++
    return r.width * r.height
}
 
func main() {
    rect := Rect{10, 20}
    area := rect.area2() //메서드 호출
    println(rect.width, area) // 11 220 출력
}

7.2.2 nil 인스턴스를 위한 메서드 작성

• 포인터 메서드 사용
• nil 인스턴스: 슬라이스, 맵, 포인터 등

• 위 타입의 제로 값이 nil

package main

import (
	"fmt"
)

type IntTree struct {
	val         int
	left, right *IntTree
}

func (it *IntTree) Insert(val int) *IntTree {
	if it == nil {
		return &IntTree{val: val}
	}
	if val < it.val {
		it.left = it.left.Insert(val)
	} else if val > it.val {
		it.right = it.right.Insert(val)
	}
	return it
}

func (it *IntTree) Contains(val int) bool {
	switch {
	case it == nil:
		return false
	case val < it.val:
		return it.left.Contains(val)
	case val > it.val:
		return it.right.Contains(val)
	default:
		return true
	}
}

func main() {
	var it *IntTree
	it = it.Insert(5)
	it = it.Insert(3)
	it = it.Insert(10)
	it = it.Insert(2)
	fmt.Println(it.Contains(2))
	fmt.Println(it.Contains(12))
}

7.2.3 메서드도 함수이다

• 메서드를 변수에 할당하거나 함수의 입력으로 반환값으로 사용 가능
  ⇒ 메서드 값(method value)
• 메서드 (표현)식
  ⇒ 타입 자체로 함수 생성

• 메서드 표현식을 이용하여 메서드를 호출할 때는 첫 번째 인자로 메서드 리시버를 사용

public class Sample {
    int sum(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int a = 3;
        int b = 4;

        Sample sample = new Sample();
        int c = sample.sum(a, b);

        System.out.println(c);  // 7 출력
    }
}

7.2.4 함수와 메서드 비교

7.2.5 타입 선언은 상속되지 않는다

• 다른 타입 기반으로 (사용자 정의) 타입 선언

• 상속이 아니다.
• 계층이라는 개념이 없다.
• 타입들은 서로 동등한 레벨이다.

• 기본 타입이 내장 타입인 사용자 정의 타입의 경우 해당 기본 타입의 연산자와 함께 사용할 수 있다.
• 또한 기본 타입과 호환되는 리터럴 및 상수를 대입할 수 있다.

7.2.6 타입은 실행가능한 문서

• 사용자 타입을 선언하는 시점
  1) 구조체의 경우 우리가 필요한 시점
  2) 기존 타입을 기반으로 사용자 정의 타입을 선언하는 것은
  • “타입은 문서이다”를 기준으로 삼자
  • 개념을 위한 이름을 타입 이름으로 지정하여 코드를 더 명확하게 하고 기대되는 데이터의 종류를 기술할 목적으로

7.2.7 열거형을 위한 iota

• 열거형(enumeration, enum)

• 카테고리성 데이터, 명목형 데이터를 나타내기 위함
  : 도시 - 서울, 부산, 인천, ...
  이메일 종류 - 미분류, 스팸, 소셜, 비즈니스, ...

package main

import "fmt"

type State uint

const (
	StateCreated State = iota  // 0
	StateInitialized           // 1
	StateRunning               // 2
	StateStopped               // 3
)

func main() {
	var state = StateRunning
	fmt.Printf("State: %v\n", state) // prints State: 2
}

• 기본 값은 정수이지만 그리고 정수를 사용(연산)할 수는 있지만 권장하지 않음

package main

import "a"

// func from the outside that handles a.base via a.Baser
// since a.base is not exported, only exported bases that are created within package a may be used, like a.A, a.C, a.T. and a.G
func HandleBasers(b a.Baser) {
    base := b.Base()
    base.OtherMethod()
}


// func from the outside that returns a.A or a.C, depending of condition
func AorC(condition bool) a.Baser {
    if condition {
       return a.A
    }
    return a.C
}

• Go에서 열거형 만들기
  1) 모든 유효한 값을 나타내는 정수 기반의 타입 정의
  2) 값의 집합을 만들기 위해 const 블록 사용
  3) const 블록에서 1)에서 선언한 타입의 첫 번째 상수에 iota 지정

7.3 구성(composition)을 위한 임베딩 사용

• composition over inheritance
  : 클래스 상속보다는 객체 구성 선호

7.4 임베딩은 상속이 아니다

• 명시적으로 접근

package main

import (
	"fmt"
)

type Employee struct {
	Name string
	ID   string
}

func (e Employee) Description() string {
	return fmt.Sprintf("%s (%s)", e.Name, e.ID)
}

type Manager struct {
	Employee
	Reports []Employee
}

func (m Manager) FindNewEmployees() []Employee {
	// do business logic
	return nil
}

func main() {
	m := Manager{
		Employee: Employee{
			Name: "Bob Bobson",
			ID:   "12345",
		},
		Reports: []Employee{},
	}
	var eFail Employee = m        // compilation error!
	var eOK Employee = m.Employee // ok!
}

• 동적 디스패치

package main

import "fmt"

type Inner struct {
	A int
}

func (i Inner) IntPrinter(val int) string {
	return fmt.Sprintf("Inner: %d", val)
}

func (i Inner) Double() string {
	result := i.A * 2
	return i.IntPrinter(result)
}

type Outer struct {
	Inner
	S string
}

func (o Outer) IntPrinter(val int) string {
	return fmt.Sprintf("Outer: %d", val)
}

func main() {
	o := Outer{
		Inner: Inner{
			A: 10,
		},
		S: "Hello",
	}
	fmt.Println(o.Double())
}

7.5 인터페이스

• 암묵적 인터페이스
  : Go의 유일한 추상 타입

• 인터페이스의 목적/용도

• 스펙을 정의
• 인터페이스를 사용하려면 인터페이스의 요소를 완성/구현(implement)해야 함
• 이를 통해 타입의 안정성을 높이고 디커플링을 가능(솔로천국 커플지옥)

• interface 키워드

• 인터페이스 리터럴

• interface {
  ...
  }

• 위 ...에는 인터페이스를 만족시키기 위한 구체적 타입에서 반드시 구현(implement)해야 할 메서드 시그니처 나열

• Go에서 관례적으로 인터페이스 이름은 끝에 ‘er’을 붙인다

• 인터페이스는 모든 블록에서 선언 가능

7.6 인터페이스는 타입에 안정적인 덕 타이핑이다.

• 덕 타이핑

• 컴퓨터 프로그래밍 분야에서 덕 타이핑(duck typing)은 동적 타이핑의 한 종류
• 객체의 변수 및 메소드의 집합이 객체의 타입을 결정하는 것
• 클래스 상속이나 인터페이스 구현으로 타입을 구분하는 대신, 덕 타이핑은 객체가 어떤 타입에 걸맞은 변수와 메소드를 지니면 객체를 해당 타입에 속하는 것으로 간주

function calculate(a, b, c) => return (a+b)*c
a = calculate (1, 2, 3)
b = calculate ([1, 2, 3], [4, 5, 6], 2)
c = calculate ('apples ', 'and oranges, ', 3)
print to_string a
print to_string b
print to_string c

7.7 임베딩과 인터페이스

7.8 인터페이스를 받고 구조체 반환하기

• 디자인 패턴: program to interface not to implementation(함수)
• Go: 인터페이스를 받고 구조체를 반환해라
  => 함수로 실행되는 비즈니스 로직은 인터페이스를 통해 실행
  => 함수의 출력은 구체 타입이어야 함

7.9 인터페이스와 nil

7.11 타입 단언과 타입 스위치

• 인터페이스 변수에 할당된 구체 타입 확인

• 구체 타입이 다른 인터페이스를 구현했는지 확인

• 타입 단언(Type Assertion)

• 인터페이스 변수.(타입)

• 타입 스위치 = 인터페이스.(type) + switch 문

---

chap. 10

Go의 동시성(Concurrency)

10.1 동시성 사용 시점

• 동시성은 병렬성이 아니다

• 동시성 코드가 병렬적(동시에)으로 실행되는지는 하드웨어와 알고리즘에 의해 결정된다

• 동시성은 동시에 실행되는 것이 시간이 얼마 걸리지 않을 때 사용하는 것은 좋지 않다.
• 동시성은 공짜가 아니다

10.2 고루틴

• 프로세스
• 스레드
• OS의 스케줄러 및 Go 런타임의 스케줄러

• Go 런타임 스케줄러의 장점(p.279~280)

• 고루틴: go 키워드

• Go 런타임에서 관리하는 가벼운 프로세스
• 비즈니스 로직을 구현한 클로저를 고루틴으로 실행하는 것이 관례

cf) 동기(synchronous) vs. 비동기(asynchronous)
ex) 동기 통신 vs 비동기 통신

10.3 채널

• 고루틴(스레드)은 채널을 통해 통신한다.
• make 함수로 생성
• 내장 타입
• 채널의 제로 값은 슬라이스, 맵, 포인터 처럼 nil