주니어 개발자도 이해 할 수 있는 go - scope 편

39
주니어 개발자도 이해 있는 Go - Scope - 2015. 2 Darion Kim

Upload: darion-kim

Post on 16-Jul-2015

1.162 views

Category:

Software


2 download

TRANSCRIPT

주니어 개발자도 이해 할 수 있는 Go

- Scope 편 -2015. 2

Darion Kim

나는����������� ������������������  누구?

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����������� ������������������  

이상����������� ������������������  율이아빠����������� ������������������  였습니다.����������� ������������������  ^^