Go 키워드 정리

참고 : https://golang.org/ref/spec#Keywords

go 소스 test 사이트 : https://play.golang.org

 

 

Go 언어에서 지원하는 Keyword를 확인하자

break     default      func    interface  select
case      defer        go      map        struct
chan      else         goto    package    switch
const     fallthrough  if      range      type
continue  for          import  return     var

조건문/반복문/분기문 keywords
1.if
2.else
3.switch
4.case
5.default
6.break
7.continue
8.for
9.goto
10.range

선언/변수 keywords

11.var
12.defer
13.chan
14.failthrough
15.func
16.import
17.interface
18.map
19.package
20.return
21.struct
22.const
23.type

모르는거
24.go
25.select

현재 25개의 keyword가 제공된다.

하나씩 확인해 보자

 

1.if

 - 일반적으로 알고 있는 분기문이다.

 - 특이한 점은 조건문 에서 지역 변수를 선언하여 사용할 수 있다.

if x := f(); x < y {
  return x
} else if x > z {
  return z
} else {
  return y
}

 

2.else

 - if문과 함께 사용되는 키워드 이다.

 - 사용방법은 1.if 에서 확인할 수 있다.

 

 

 

3.switch

4.case

5.default

 -  switch 분기문에서 사용되는 keywords

 - case에 해당하는 조건이 없을때 default문이 실행된다.

 - 검사 조건에 상태값 혹은 타입 검사문이 들어갈 수 있다.

 - 사용 예제 (상태값 검사)

switch tag {
  default: s3()
  case 0, 1, 2, 3: s1()
  case 4, 5, 6, 7: s2()
}

switch x := f(); {  // missing switch expression means "true"
  case x < 0: return -x
  default: return x
}

switch {
  case x < y: f1()
  case x < z: f2()
  case x == 4: f3()
}

- 사용 예제 (타입 검사)

switch i := x.(type) {
case nil:
	printString("x is nil")                // type of i is type of x (interface{})
case int:
	printInt(i)                            // type of i is int
case float64:
	printFloat64(i)                        // type of i is float64
case func(int) float64:
	printFunction(i)                       // type of i is func(int) float64
case bool, string:
	printString("type is bool or string")  // type of i is type of x (interface{})
default:
	printString("don't know the type")     // type of i is type of x (interface{})
}

 

6. break ( https://golang.org/ref/spec#Break_statements )

 -  for, switch, select 문에서 사용 가능한 실행 중단 키워드

 

7.for ( https://golang.org/ref/spec#For_statements )

 - 소스의 반복 실행시 사용되는 키워드

 - 세가지 방법으로 소스를 반복할 수 있다.

 

   7.1 단일 조건문

for a < b {
	a *= 2
}

   7.2 선언문, 조건문, 반복문 사용 

for i := 0; i < 10; i++ {
	f(i)
}

   7.3 범위 조건문

    - 배열, 문자열, map, channel 의 변수들을 탐색할 때 사용한다.

    - 아래는 각 타입 탐색시 얻어지는 값들이다.

Range expression                          1st value          2nd value

array or slice  a  [n]E, *[n]E, or []E    index    i  int    a[i]       E
string          s  string type            index    i  int    see below  rune
map             m  map[K]V                key      k  K      m[k]       V
channel         c  chan E, <-chan E       element  e  E

    - 사용 예

    - "_" 문자열은 탐색 값을 사용하지 않을때 선언해준다.

var testdata *struct {
	a *[7]int
}
for i, _ := range testdata.a {
	// testdata.a is never evaluated; len(testdata.a) is constant
	// i ranges from 0 to 6
	f(i)
}

var a [10]string
for i, s := range a {
	// type of i is int
	// type of s is string
	// s == a[i]
	g(i, s)
}

var key string
var val interface {}  // element type of m is assignable to val
m := map[string]int{"mon":0, "tue":1, "wed":2, "thu":3, "fri":4, "sat":5, "sun":6}
for key, val = range m {
	h(key, val)
}
// key == last map key encountered in iteration
// val == map[key]

var ch chan Work = producer()
for w := range ch {
	doWork(w)
}

// empty a channel
for range ch {}

 

 

 

8.range

 - 7.3 범위 조건문에서 사용되는 키워드

 

9.continue

 - for 문에서 실행문을 건너뛸때 사용된다.

10.goto (https://golang.org/ref/spec#Goto_statements)

 - 라벨을 사용하여 실행 순서를 건너 뛸 수 있다.

 - 라벨이 return 뒤에 있더라도 상관없다.

	n := 10
	
	if n%2 == 1 {
		goto L1
	}
	
	return;
	
	L1:

 - Syntax error goto문

//1.goto 문은 선언문을 건너뛸 수 없다.
goto L  // BAD
	v := 3
L:


//2. 다른 Scope로 이동이 불가 하다 (상위로는 가능)
if n%2 == 1 {
	goto L1
}
for n > 0 {
	f()
	n--
L1:
	f()
	n--
}

 

11.var

 - 변수 할당 키워드

var i int
var U, V, W float64
var k = 0
var x, y float32 = -1, -2
var (
	i       int
	u, v, s = 2.0, 3.0, "bar"
)
var re, im = complexSqrt(-1)
var _, found = entries[name]  // map lookup; only interested in "found"

 

12.defer

 - 지연 함수로 return 문이 실행되거나 함수 끝에서 해당 키워드로 설정된 함수가 호출된다.

 - 지연된 함수들은 역순으로 실행된다.

package main

import (
	"fmt"
)

func main() {

	defer fmt.Println("test")  // unlocking happens before surrounding function returns

	for i := 0; i <= 3; i++ {
		defer fmt.Println(i)
	}
	
	defer fmt.Println("__",f())
	
	return
	
}


func f() (result int) {
	defer func() {
		// result is accessed after it was set to 6 by the return statement
		result *= 7
	}()
	return 6
}

결과값

__ 42
3
2
1
0
test

 

 

 

13.go

 - 함수 호출을 비동기적으로 실행(goroutine)할 시 사용되는 키워드

 - OS 쓰레드에 비해 자원을 덜먹고 Go런타임으로 관리되기 때문에 1개의 OS 쓰레드로 여러개의 Goroutine이

   적은 자원을 점유하며 관리된다.

package main
 
import (
    "fmt"
    "sync"
)
 
func main() {
        
    var wait sync.WaitGroup // 진행 시점 관리 객체
    wait.Add(2)				// 2개의 대기 상태가 있다고 명시해준다.
 
    go func() {
        defer wait.Done() //함수 종료시 호출
        fmt.Println("go end1")
    }()
 
    go func(msg str) {
        defer wait.Done() //함수 종료시 호출
        fmt.Println(msg)
    }("go end2")
 
    wait.Wait() //2개의 go루틴에 대해 대기를 유지한다.
}

 

 

14.chan

 - 데이터를 송수신하며 통신할 수 있는 기능

 - 내용이 많기 때문에 URL 참고 (http://golang.site/go/article/22-Go-%EC%B1%84%EB%84%90)

 

15.failthrough

 - switch 문에서 case를 타더라도 종료되지 않게 하는 키워드

    switch val {
    case 1:
        fmt.Println("1 이하")
        fallthrough
    case 2:
        fmt.Println("2 이하")
        fallthrough
    case 3:
        fmt.Println("3 이하")
        fallthrough
    default:
        fmt.Println("default 도달")
    }

16.func

 - 함수 선언 키워드 

func()
func(x int) int
func(a, _ int, z float32) bool
func(a, b int, z float32) (bool)
func(prefix string, values ...int)
func(a, b int, z float64, opt ...interface{}) (success bool)
func(int, int, float64) (float64, *[]int)
func(n int) func(p *T)

17.import

 - 패키지 호출 키워드 

 - 같은 패키지라도 alias 로 다르게 사용할 수 있다.

Import declaration          Local name of Sin

import   "lib/math"         math.Sin
import m "lib/math"         m.Sin
import . "lib/math"         Sin

18.interface

 - interface 선언 키워드

 - interface 의 타입을 지정할 수 있다.

type ReadWriter interface {
	Read(b Buffer) bool
	Write(b Buffer) bool
}

type File interface {
	ReadWriter  // same as adding the methods of ReadWriter
	Locker      // same as adding the methods of Locker
	Close()
}

type LockedFile interface {
	Locker
	File        // illegal: Lock, Unlock not unique
	Lock()      // illegal: Lock not unique
}

19.map

 - key, value 쌍으로 이어진 자료구조

 - key, value 의 타입을 명시할 수 있다.

map[string]int
map[*T]struct{ x, y float64 }
map[string]interface{}

20.package

 - 패키지에 속한 상수, 유형, 변수 및 함수를 함께 선언하고 동일한 패키지의 모든 파일에서 액세스 할 수있는 하나 이상의 소스 파일로 구성된다 Import 를 통하여 접근가능하다

21.return

 - 함수의 실행을 종료됨을 의미하며 하나 이상의 결과값을 반환한다.

 

 

22.struct

 - 요소(필드)들의 집합체

23.const

 - 상수 선언 키워드

24.type

 - String, Int 와 같은 유형을 사용자 임의의 고유 유형을 지정하여 사용할 수 있다.

type (
	A1 = string
	A2 = A1
)

type (
	B1 string
	B2 B1
	B3 []B1
	B4 B3
)

 

25.select

 - 채널에 대한 동기화 소스에 대해 switch 처럼 각각의 채널에 대한 처리 소스를 지정해준다.

var a []int
var c, c1, c2, c3, c4 chan int
var i1, i2 int
select {
case i1 = <-c1:
	print("received ", i1, " from c1\n")
case c2 <- i2:
	print("sent ", i2, " to c2\n")
case i3, ok := (<-c3):  // same as: i3, ok := <-c3
	if ok {
		print("received ", i3, " from c3\n")
	} else {
		print("c3 is closed\n")
	}
case a[f()] = <-c4:
	// same as:
	// case t := <-c4
	//	a[f()] = t
default:
	print("no communication\n")
}

for {  // send random sequence of bits to c
	select {
	case c <- 0:  // note: no statement, no fallthrough, no folding of cases
	case c <- 1:
	}
}

select {}  // block forever

 

이상으로 Go 언어의 25가지 keyword에 대해 간략히 알아보았다.