주니어 개발자도 이해 할 수 있는 go - scope 편
TRANSCRIPT
나는����������� ������������������ 누구?
Darion����������� ������������������ Kim����������� ������������������ (김헌기)����������� ������������������
디에스멘토링����������� ������������������ 연구소����������� ������������������ 수석보����������� ������������������
자칭����������� ������������������ 통신(통합의����������� ������������������ 신,����������� ������������������ God����������� ������������������ of����������� ������������������ Integration)����������� ������������������
[email protected]����������� ������������������
https://www.facebook.com/groups/golangko����������� ������������������ (율이아빠)����������� ������������������
https://www.facebook.com/groups/serverside����������� ������������������ (율이아빠)
이����������� ������������������ 문서는����������� ������������������ Yong����������� ������������������ Joon����������� ������������������ Moon����������� ������������������ (http://blog.naver.com/zerosum99)님과����������� ������������������ 함께����������� ������������������ 작성하였습니다.
약속드립니다.����������� ������������������ ^^����������� ������������������ 절대����������� ������������������ 어렵게����������� ������������������ ����������� ������������������ 얘기하지����������� ������������������ 않겠습니다.
하지만����������� ������������������ Java에����������� ������������������ 대한����������� ������������������ 기초지식은����������� ������������������ ����������� ������������������ 있으셔야����������� ������������������ 합니다
Go����������� ������������������ -����������� ������������������ Namespace����������� ������������������ -����������� ������������������ 편����������� ������������������ 에서����������� ������������������ (http://www.slideshare.net/hnki0104/go-f)네임스페이스(Namespace)를����������� ������������������ 사용하여����������� ������������������ ����������� ������������������ ����������� ������������������ 프로그램시����������� ������������������ 중복을����������� ������������������ 피할����������� ������������������ 수����������� ������������������ 있는����������� ������������������ ����������� ������������������ 컨테이너����������� ������������������ 구성����������� ������������������ 문법에����������� ������������������ 대하여����������� ������������������ 얘기����������� ������������������ 하였습니다.
지금부터는����������� ������������������
네임스페이스����������� ������������������ 안쪽에서����������� ������������������ 사용되는����������� ������������������ ����������� ������������������
변수(Variable)[=필드(Field)]와����������� ������������������ 함수(Function)[=메서드(Method)]의����������� ������������������ ����������� ������������������
유효범위(Scope)에����������� ������������������ 대해서����������� ������������������ ����������� ������������������
얘기를����������� ������������������ 하겠습니다.
예제로����������� ������������������ 시작일과����������� ������������������ 종료일을����������� ������������������ 기입하여����������� ������������������ 두����������� ������������������ 날짜����������� ������������������ 사이의����������� ������������������ 일수를����������� ������������������ 계산하는����������� ������������������ 일수산출(Julian����������� ������������������ Day����������� ������������������ Calculations)����������� ������������������ 을����������� ������������������ 구현해보겠습니다. *����������� ������������������ 설명의����������� ������������������ 목적으로����������� ������������������ 구현됨을����������� ������������������ 미리����������� ������������������ 말씀드립니다.
먼저����������� ������������������
Java����������� ������������������ 를����������� ������������������ 예로����������� ������������������ 들어보겠습니다.����������� ������������������ ^^����������� ������������������
기본문법����������� ������������������ 정도는����������� ������������������ 이해하고����������� ������������������ 있다는����������� ������������������ 가정하에����������� ������������������ 말씀드립니다.
결과는����������� ������������������ 같아도����������� ������������������ 접근하는����������� ������������������ 방법은����������� ������������������ ����������� ������������������ 무수히����������� ������������������ 많습니다.����������� ������������������
주로����������� ������������������ 제가����������� ������������������ 사용하는����������� ������������������ 방법은����������� ������������������ 우선����������� ������������������ 일수산출이라는����������� ������������������ 구현범위를����������� ������������������ 정의하기����������� ������������������ 위해����������� ������������������ ����������� ������������������ 인터페이스(interface)를����������� ������������������ 선언합니다.����������� ������������������
인터페이스에서는����������� ������������������ ����������� ������������������ 객체����������� ������������������ 역할에����������� ������������������ 대한����������� ������������������ 속성과����������� ������������������ ����������� ������������������ 행위의����������� ������������������ 입력값과����������� ������������������ 출력값을����������� ������������������ 정의����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있습니다.
일수산출����������� ������������������ 이라는����������� ������������������ 역할을����������� ������������������ ����������� ������������������ DayCalculator란����������� ������������������ 인터페이스로����������� ������������������ 선언합니다. 1.����������� ������������������ 시작일과����������� ������������������ 종료일을����������� ������������������ 설정하는����������� ������������������ 행위����������� ������������������ 2.����������� ������������������ 계산하고����������� ������������������ 결과값을����������� ������������������ 리턴하는����������� ������������������ 행위로����������� ������������������ 규정하였습니다.����������� ������������������
*����������� ������������������ 리턴값이����������� ������������������ CalculationResult����������� ������������������ 객체����������� ������������������ 입니다.
리턴����������� ������������������ 값에����������� ������������������ 대한����������� ������������������ 유형을����������� ������������������ 단일값에����������� ������������������ 대해서는����������� ������������������ ����������� ������������������ 프리미티브����������� ������������������ 타입(primitive����������� ������������������ type)으로����������� ������������������ 하고����������� ������������������ ����������� ������������������ 다중값에����������� ������������������ 대해서는����������� ������������������ 객체(Object)로����������� ������������������ 합니다.����������� ������������������
객체로����������� ������������������ 하면����������� ������������������ 여러개의����������� ������������������ 프리미티브����������� ������������������ 타입이나����������� ������������������ 또����������� ������������������ 다른����������� ������������������ 객체들을����������� ������������������ 선언하여����������� ������������������ 사용����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있습니다.
인터페이스를����������� ������������������ 구현한����������� ������������������ 구현����������� ������������������ 클래스는����������� ������������������ ����������� ������������������ 클래스����������� ������������������ 영역과����������� ������������������ 메소드����������� ������������������ 영역으로����������� ������������������ ����������� ������������������ 나눌����������� ������������������ 수����������� ������������������ 있습니다.����������� ������������������
클래스����������� ������������������ 영역에는����������� ������������������ ����������� ������������������ 클래스����������� ������������������ 변수(Class����������� ������������������ Variable)와����������� ������������������ 인스턴스����������� ������������������ 변수(Instance����������� ������������������ Variable)����������� ������������������ 를����������� ������������������ 선언합니다.����������� ������������������
메서드����������� ������������������ 영역에는����������� ������������������ 지역����������� ������������������ 변수(Local����������� ������������������ Variable)를����������� ������������������ ����������� ������������������ 선언합니다.����������� ������������������
인스턴스����������� ������������������ 생성시����������� ������������������ 인스턴스����������� ������������������ 변수가,����������� ������������������
클래스가����������� ������������������ 메모리에����������� ������������������ 올라갈����������� ������������������ 때는����������� ������������������ ����������� ������������������ 클래스����������� ������������������ 변수가,����������� ������������������ ����������� ������������������
변수����������� ������������������ 선언문����������� ������������������ 수행시����������� ������������������ 지역����������� ������������������ 변수가����������� ������������������ 생성됩니다.����������� ������������������
인스턴스����������� ������������������ 변수
클래스����������� ������������������ 변수지역����������� ������������������ 변수
멤버����������� ������������������ 변수����������� ������������������ 중����������� ������������������ 모든����������� ������������������ 인스턴스에����������� ������������������ 공통적으로����������� ������������������ 사용하는����������� ������������������ 것이����������� ������������������ 인스턴스����������� ������������������ 메서드입니다.����������� ������������������
*����������� ������������������ 멤버����������� ������������������ 변수����������� ������������������ ����������� ������������������ (클래스����������� ������������������ 변수,����������� ������������������ 인스턴스����������� ������������������ 변수,����������� ������������������ 지역����������� ������������������ 변수)����������� ������������������
인스턴스를����������� ������������������ 생성하지����������� ������������������ 않아도����������� ������������������ ����������� ������������������ 사용����������� ������������������ 가능한����������� ������������������ 메서드가����������� ������������������ 클래스����������� ������������������ 메서드입니다. 클래스����������� ������������������ 메서드는����������� ������������������ 인스턴스����������� ������������������ 멤버만����������� ������������������ 사용����������� ������������������ 할����������� ������������������ 수����������� ������������������ 없습니다.*����������� ������������������ 인스턴스����������� ������������������ 멤버����������� ������������������ ����������� ������������������ (인스턴스����������� ������������������ 변수,����������� ������������������ 인스턴스����������� ������������������ 메서드)
2005년01월01일부터����������� ������������������ 2015년12월31일까지����������� ������������������ ����������� ������������������ 전체����������� ������������������ 일수를����������� ������������������ 출력하였습니다. 전체����������� ������������������ 4016일이고,����������� ������������������ 단위����������� ������������������ 검증을����������� ������������������ 위해����������� ������������������ 각각의����������� ������������������ 차를����������� ������������������ 표현하면����������� ������������������ ����������� ������������������ 10년,����������� ������������������ 11개월,����������� ������������������ 364일로����������� ������������������ 표현����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있습니다.
인터페이스 구현����������� ������������������ 클래스
Java����������� ������������������ 의����������� ������������������ src����������� ������������������ 디렉토리����������� ������������������ 구조입니다.����������� ������������������
실행����������� ������������������ 클래스인����������� ������������������ Scope와����������� ������������������ ����������� ������������������
일수산출����������� ������������������ 인터페이스인����������� ������������������ DayCalculator����������� ������������������ 구현����������� ������������������ 클래스인����������� ������������������ DayCalculatorImpl����������� ������������������ ����������� ������������������ ����������� ������������������ 결과값을����������� ������������������ 담는����������� ������������������ 클래스인����������� ������������������ CalculationResult����������� ������������������ ����������� ������������������ 로����������� ������������������ 구성되어����������� ������������������ 있습니다.
Java를����������� ������������������ 먼저����������� ������������������ 말씀드린����������� ������������������ 것은 Go����������� ������������������ 와����������� ������������������ 비교하기����������� ������������������ 위함입니다.
다시����������� ������������������ 정리하면 1.����������� ������������������ 인터페이스를����������� ������������������ 선언하고����������� ������������������ 2.����������� ������������������ 리턴����������� ������������������ 클래스를����������� ������������������ 작성하고����������� ������������������ 3.����������� ������������������ 구현����������� ������������������ 클래스를����������� ������������������ 작성하였습니다.����������� ������������������ 4.����������� ������������������ 그리고����������� ������������������ 실행한����������� ������������������ 결과를����������� ������������������ 확인했습니다.
다음은����������� ������������������
Go����������� ������������������ 를����������� ������������������ 예로����������� ������������������ 들어보겠습니다.����������� ������������������ ^^����������� ������������������
Java와����������� ������������������ 표현방식이����������� ������������������ 다르므로����������� ������������������ ����������� ������������������ 문법을����������� ������������������ 세세하게����������� ������������������ 설명하는����������� ������������������ 것보다����������� ������������������ 우선은����������� ������������������ 이렇게����������� ������������������ 되는구나����������� ������������������ 하고����������� ������������������ ����������� ������������������ 이해하셨으면����������� ������������������ 합니다.
Go는����������� ������������������ 패키지����������� ������������������ 단위����������� ������������������ 영역밖에����������� ������������������ 없습니다. 그래서����������� ������������������ date란����������� ������������������ 패키지(package)를����������� ������������������ 선언하였습니다.Java와����������� ������������������ 마찬가지로����������� ������������������ 인터페이스(interface)도����������� ������������������ 선언����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있습니다.����������� ������������������ 그래서����������� ������������������ Calculator란����������� ������������������ 인터페이스를����������� ������������������ 선언하였습니다.
패키지����������� ������������������ 영역
인터페이스에서����������� ������������������ CountForStruct와����������� ������������������ CountForMultipleValues의����������� ������������������ 두개의����������� ������������������ 함수를����������� ������������������ 선언했습니다.����������� ������������������
왜����������� ������������������ 두개의����������� ������������������ 함수를����������� ������������������ 선언했을까요?����������� ������������������
Java와����������� ������������������ 달리����������� ������������������ 다중값(MultipleValues)으로����������� ������������������ 리턴할����������� ������������������ 수����������� ������������������ 있음을����������� ������������������ 보여����������� ������������������ 드릴려고����������� ������������������ 합니다.구조체(Struct)����������� ������������������ 리턴은����������� ������������������ 다음페이지에서…⋯����������� ������������������
다중값으로����������� ������������������ 리턴
소
구조체로����������� ������������������ 리턴
Java에서����������� ������������������ 리턴����������� ������������������ 값의����������� ������������������ 유형을����������� ������������������ 객체로����������� ������������������ 하듯이����������� ������������������ Go����������� ������������������ 에서
는����������� ������������������ 리턴����������� ������������������ 값의����������� ������������������ 유형으로����������� ������������������ 구조체(Struct)로����������� ������������������ 선언����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있습니다.����������� ������������������
*����������� ������������������ 구조체와����������� ������������������ 다중값으로����������� ������������������ 리턴����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있음을����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ 기억합시다.
구조체
Java에서는����������� ������������������ ����������� ������������������ 인터페이스(interface)를����������� ������������������ 선언하고����������� ������������������ ����������� ������������������ 클래스(class)로����������� ������������������ 구현합니다.����������� ������������������
하지만����������� ������������������ Go는����������� ������������������ Java와����������� ������������������ 다릅니다.����������� ������������������
***����������� ������������������ 지금부터����������� ������������������ 관심있게����������� ������������������ 보셔야����������� ������������������ 합니다.
소
인터페이스
클래스
인터페이스
클래스
Go는����������� ������������������ 인터페이스(interface)로����������� ������������������ 선언
된����������� ������������������ 부분을����������� ������������������ 구조체(struct)와����������� ������������������ 함수(func)로����������� ������������������ 구현합니다.����������� ������������������ *����������� ������������������ 현재����������� ������������������ 작성한����������� ������������������ 예제기준으로����������� ������������������ 먼저����������� ������������������ 이해하셨����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ 으면����������� ������������������ 합니다.
인터페이스
구조체+함수
인터페이스����������� ������������������ 정의����������� ������������������ 부분
구조체+함수����������� ������������������ 구현����������� ������������������ 부분
Java에서는����������� ������������������ 인터페이스에����������� ������������������ 대한����������� ������������������ 구현����������� ������������������ 단위가����������� ������������������ 클래스(class)입니다.����������� ������������������
하지만����������� ������������������ Go는����������� ������������������ 인터페이스의����������� ������������������ 구현����������� ������������������ 단위가����������� ������������������ 함수(func)입니다.
클래스����������� ������������������ 구현
함수����������� ������������������ 구현
Java에서는����������� ������������������ private,����������� ������������������ protected,����������� ������������������ public,����������� ������������������ default의����������� ������������������ 접근����������� ������������������ 제어자(Access����������� ������������������ Modifier)가����������� ������������������ 있습니다.����������� ������������������
Go에서는����������� ������������������ 대문자(Upper����������� ������������������ Case)로����������� ������������������ public을����������� ������������������ 소문자(Lower����������� ������������������ Case)로����������� ������������������ private을����������� ������������������ 간단히����������� ������������������ 구분합니다.
접근����������� ������������������ 제어자
Java와����������� ������������������ 마찬가지로����������� ������������������ 2005년01월01일부터����������� ������������������ 2015년12월31일까지����������� ������������������ 전체����������� ������������������ 일수를����������� ������������������ 출력하였습니다.����������� ������������������ 전체����������� ������������������ 4016일이고,����������� ������������������ 단위����������� ������������������ 검증을����������� ������������������ 위해����������� ������������������ ����������� ������������������ 각각의����������� ������������������ 차를����������� ������������������ 표현하면����������� ������������������ 10년,����������� ������������������ 11개월,����������� ������������������ 364일로����������� ������������������ 표현����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있습니다.
fromStr,����������� ������������������ toStr을����������� ������������������ 입력하여����������� ������������������ DueDate란����������� ������������������ 구조체를����������� ������������������ 생성하였습니다.����������� ������������������ 출력로그에����������� ������������������ 해당����������� ������������������ 시간대로����������� ������������������ 변환된����������� ������������������ 것을����������� ������������������ 확인할����������� ������������������ 수����������� ������������������ 있습니다.����������� ������������������
*����������� ������������������ 변수명을����������� ������������������ dueDate로����������� ������������������ 하지않고����������� ������������������ 왜����������� ������������������ calculator로����������� ������������������ 했을까요?����������� ������������������ *����������� ������������������ 과연����������� ������������������ DueDate란����������� ������������������ 구조체����������� ������������������ 역할만����������� ������������������ 할까요?����������� ������������������ 해답은����������� ������������������ 다음����������� ������������������ 페이지에����������� ������������������ 있습니다.
CountForStruct는����������� ������������������ DueDate����������� ������������������ 구조체를����������� ������������������ 받는����������� ������������������ 메소드����������� ������������������ 리시버(Method����������� ������������������ Receiver)를����������� ������������������ 사용하였기����������� ������������������ 때문에����������� ������������������ DueDate구조체에서����������� ������������������ Calculator����������� ������������������ 인터페이스를����������� ������������������ 자동으로����������� ������������������ 구현한����������� ������������������ 셈이됩니다. 함수����������� ������������������ 사용에����������� ������������������ 있어서는����������� ������������������ 구조체(struct)로����������� ������������������ 리턴한����������� ������������������ 부분입니다.����������� ������������������ 함수내에서����������� ������������������ :=����������� ������������������ 를����������� ������������������ 사용하면����������� ������������������ var과����������� ������������������ 명시적인����������� ������������������ 타입을����������� ������������������ 생략할����������� ������������������ 수����������� ������������������ 있습니다.����������� ������������������ 앞서����������� ������������������ Java에서는����������� ������������������ 객체를����������� ������������������ 리턴하였지만����������� ������������������ Go에서는����������� ������������������ 구조체로����������� ������������������ 리턴합니다.
메소드����������� ������������������ 리시버 구조체����������� ������������������ 리턴
이����������� ������������������ 부분이����������� ������������������ Java와는����������� ������������������ 다른����������� ������������������ 다소����������� ������������������ 생소한����������� ������������������ 부분입니다. 다중값(Multiple����������� ������������������ Values)으로����������� ������������������ 리턴하였습니다.����������� ������������������ 그것도����������� ������������������ 알아서����������� ������������������ 리턴해줍니다.����������� ������������������
_(blank����������� ������������������ indentifier)를����������� ������������������ 사용하여����������� ������������������ dayOfYearDiff란����������� ������������������ 변수를����������� ������������������ 할당받지����������� ������������������ 않았습니다.
메소드����������� ������������������ 리시버
다중값����������� ������������������ 리턴
결과의����������� ������������������ 현재����������� ������������������ 값을����������� ������������������ 알아서����������� ������������������ 리턴합니다.
blank����������� ������������������ indetifier
Go����������� ������������������ 의����������� ������������������ src����������� ������������������ 디렉토리����������� ������������������ 구조입니다.����������� ������������������
실행����������� ������������������ 메소드가����������� ������������������ 있는����������� ������������������ scope����������� ������������������ 패키지를����������� ������������������ ����������� ������������������ scope.go����������� ������������������ 하나의����������� ������������������ 파일로����������� ������������������ 하고����������� ������������������ ����������� ������������������ ����������� ������������������
일수처리����������� ������������������ 패키지인����������� ������������������ date����������� ������������������ 패키지를����������� ������������������ ����������� ������������������ daycalculator.go����������� ������������������ 하나의����������� ������������������ 파일로����������� ������������������ 작성하였습니다.����������� ������������������ *물론����������� ������������������ 2개����������� ������������������ 이상의����������� ������������������ *.go����������� ������������������ 파일로도����������� ������������������ 작성할����������� ������������������ 수����������� ������������������ 있습니다.
Go를����������� ������������������ 다시����������� ������������������ 정리하면 1.����������� ������������������ 인터페이스를����������� ������������������ 선언하고����������� ������������������ 2.����������� ������������������ 구현����������� ������������������ 및����������� ������������������ 리턴����������� ������������������ 구조체를����������� ������������������ 작성하고����������� ������������������ 3.����������� ������������������ 구현����������� ������������������ 함수를����������� ������������������ 작성하였습니다.����������� ������������������ 4.����������� ������������������ 그리고����������� ������������������ 실행한����������� ������������������ 결과를����������� ������������������ 확인했습니다.
Go����������� ������������������ 에����������� ������������������ 대해서����������� ������������������ 맛만����������� ������������������ 보여드렸습니다.
이����������� ������������������ 문서는����������� ������������������ 기존에����������� ������������������ Java를����������� ������������������ 경험하신����������� ������������������ 분들이����������� ������������������ Go에����������� ������������������ 대해����������� ������������������ 좀더����������� ������������������ 쉽게����������� ������������������ 접근할����������� ������������������ 수����������� ������������������ 있지����������� ������������������ 않을까����������� ������������������ 생각해서����������� ������������������ 작성해본����������� ������������������ 것입니다.����������� ������������������
앞으로����������� ������������������ 접근해야����������� ������������������ 될����������� ������������������ 것들이����������� ������������������ 더����������� ������������������ 많이����������� ������������������ 남아있습니다����������� ������������������ 기회되는����������� ������������������ 대로����������� ������������������ 공유할����������� ������������������ 계획입니다.����������� ������������������
맛만����������� ������������������ 보는����������� ������������������ 것을����������� ������������������ 원치����������� ������������������ 않으시는����������� ������������������ 분들은����������� ������������������
EffectiveGo를����������� ������������������ 강력히����������� ������������������ 추천합니다.����������� ������������������
https://code.google.com/p/golang-korea/wiki/EffectiveGo����������� ������������������