{Go} 1. 기본구조 / 2. 선언키워드 / 3.반복문 / 4.조건문

1. 기본구조

package

• 함수들을 그룹화 하는 방법. 동일 package 내의 모든 파일은 하나의 모듈로 생성됨
• 패키지 이름 = 디렉토리 이름
• 패키지 내 함수 네이밍 규칙
  소문자 -> private 접근, 대문자 : public 접근
• main 패키지는 특별하게 인식하여 프로그램 시작점(start pointer)이 된다.
  main 패키지를 실행할 때, 기본으로 main function이 실행된다.

package main 

import "fmt" // 모듈화된 라이브러리 참조

func main() { // 실행 진입 구간 main 함수 선언
	fmt.Println("Hello world!!")
}

import

• 다른 패키지의 모듈을 참조하는 방법
• 단일선언

import "fmt"

• 다중선언

import (
"fmt"
"os"
)

-alias 선언

import (
"fmt"
testmodule "jerry/lib"
)

2. 선언 키워드

const

• 상수 선언
• 컴파일 타임에 값이 정해져야하기 때문에 런타임에 동적으로 값을 초기화 하는 방식 불가함

  const a string = "Test1"
  const b int32 = 10 * 10
    // const d =getHeight()  // 함수 할당 불가
    
  const a,b int = 10, 99
  const c, d, e = true, 0.84, "test"

  const (
    x, y int16 = 50, 90
    i, k  = "Data", 7776
  )  

var

• 변수
• 초기화 때 정해진 타입내에서만 변경 가능

var c, d, e int
var f, g, h int = 1, 2, 3
var i float32 = 11.4
var j string = "Hi! Golang!"
var k = 4.74 // 선언 동시 초기화

enum

• 상수를 사용하는 일정한 규칙에 따라 숫자를 계산 및 증가시키는 묶음
• iota 예약어를 사용하면 초기값 설정과 값의 증가를 조정할 수 있음

	const (
		Jan = 1 // 1
		Feb = 2 // 2
		Mar = 3 // 3
	)
    
    const (
		Jan = 1 // 1
		Feb = 2 // 2
		Mar // 2
	)
    
    const (
		a = iota + 10   //10
		b              // 11
		c = iota * 2  // 22
		d              //23
	)

    const (
		_ = iota // 밑줄에 사용하여 값 스킵
		A // 1
		_
		C // 3
		_
		B // 5
	)

짧은변수(short variable)

• 선언-초기화 동시에 수행. 편리함에 많이 사용함
• := 연산자로 선언

var t=10 // O
a=10 // X
b:=10 // O

• 함수 내의 지역변수로만 사용 가능(값 반환엔 문제 없음)

func CheckReturnShortValue() int {
	shortVal := 350
	return shortVal
}

nil

zero value란?

• Go 언어에서 변수 선언시 초기값을 할당하지 않은 경우에 기본으로 할당되는 값
• nil : 함수, 포인터, 인터페이스, slice, 채널, 맵
  (string : "", boolean : false, 숫자(int,double..):0)

3. 반복문

for

• go에서 유일하게 제공하는 반복문(while이 없다.)

	for i := 0; i < 5; i++ {
		fmt.Println(i)
	}

	loc := []string{"Seoul", "Busan", "Incheon"}
	for index, name := range loc {
		fmt.Println(index, name)
	}

Loop 키워드

• Loop 키워드 다음엔 반드시 for문이 와야함
• 중첩 for문에서 흐름 제어에 사용

Loop1:
	for i := 0; i < 5; i++ {
		for j := 0; j < 5; j++ {
			if i == 2 && j == 4 {
				break Loop1
			}
			fmt.Println(i, j)
		}
	}

Loop2: //loop 문 안에는 반드시 for문이 와야함
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			if i == 1 && j == 2 {
				continue Loop2
			}
			fmt.Println(i, j)
		}
	}

[참고사항] - 후취연산자

• go에는 선취연산이 없다. (++i 형태)
• go에서 후취연산은 반환값이 없기 때문에 변수에 할당하는 방식으로 사용 불가

	sum2, i := 0, 0
	for i <= 100 {
    	// sum2+=i++ // 후취연산 반환값이 없기 때문에 
		sum2 += i // 별도로 선언
		i++
		
	}

4. 조건문

if

if a >= 10 {
		fmt.Println("10 이상")
} else {
		fmt.Println("10 미만")
}

switch

• java, C# 등과 달리 break를 명시해주지 않아도 케이스에 해당하는 것만 실행되고 나머지는 실행되지 않음 (자동break)
• 만족하는 case가 나타난 뒤 나머지를 모두 실행하게 하고싶으면(다른언어의 기본 셋팅) fallthrough 예약어 사용

// 예제1. switch문 바깥에서 선언한 변수에 대해 체크. switch문 표현식에 조건 생략 가능
a := -7
switch {
case a < 0:
	fmt.Println(a, "는 음수")
case a == 0:
	fmt.Println(a, "는 0")
case a > 0:
	fmt.Println(a, "는 양수")
}
// 예제2 : 스위치문 조건절에서 case에서 체크할 대상 변수 사용
switch c := "go"; c + "lang" {
case "golang":
	fmt.Println("Golang")
case "java":
	fmt.Println("java")
default:
	fmt.Println("none")
}
// 예제3
switch i, j := rand.Intn(100), 30; {
case i < j:
	fmt.Println("i는 j보다 작다")
case i == j:
	fmt.Println("i는 j보다 같다")
case i > j:
	fmt.Println("i는 j보다 크다")
}

// 예제4
a := 30 / 15
switch a {
case 2, 4, 6: // case 조건절에 여러개 값 선언 가능
	fmt.Println(" a는 짝수")
case 1, 3, 5:
	fmt.Println(" a는 홀수")
}

// 예제 5 : fallthrough 예약어  => 조건에 맞는 문장에 해당 예약어가 있다면 그 이후에는 조건에 맞지 않더라도 실행됨 
switch e := "go"; e {
case "java":
	fmt.Println("java다")
	fallthrough
case "go":
	fmt.Println("go")
	fallthrough
case "ruby":
	fmt.Println("ruby")
}

참고자료

[학습 자료] 인프런 - 쉽고 빠르게 끝내는 GO언어 프로그래밍 핵심 기초 입문 과정
[공식사이트] https://golang.org/tutorial