Go
가지

스위치 문

간단한 switch 문 :

switch a + b {
case c:
    // do something
case d:
    // do something else
default:
    // do something entirely different
}

위의 예제는 다음과 같습니다.

if a + b == c {
    // do something
} else if a + b == d {
    // do something else
} else {
    // do something entirely different
}

default 절은 선택 사항이며, 마지막에 나타나지 않더라도 허용되는 경우에도 true를 비교하는 경우가없는 경우에만 실행됩니다. 다음은 첫 번째 예제와 의미 상 동일합니다.

switch a + b {
default:
    // do something entirely different
case c:
    // do something
case d:
    // do something else
}

이것은 default 절에서 fallthrough 문을 사용하려는 경우에 유용 할 수 있습니다.이 절은 대 / 소문자의 마지막 문이어야하며 프로그램 실행을 다음 사례로 진행시킵니다.

switch a + b {
default:
    // do something entirely different, but then also do something
    fallthrough
case c:
    // do something
case d:
    // do something else
}

빈 스위치 식은 암시 적으로 true .

switch {
case a + b == c:
    // do something
case a + b == d:
    // do something else
}

switch 문은 if 문과 비슷한 간단한 문을 지원합니다.

switch n := getNumber(); n {
case 1:
    // do something
case 2:
    // do something else
}

동일한 논리를 공유하는 경우 쉼표로 구분 된 목록에 사례를 결합 할 수 있습니다.

switch a + b {
case c, d:
    // do something
default:
    // do something entirely different
}

If 문

간단한 if 문 :

if a == b {
    // do something
}

조건을 감싸는 괄호는 없으며 여는 중괄호 { 는 같은 줄에 있어야합니다. 다음은 컴파일 되지 않습니다 .

if a == b
{
    // do something
}

else 를 사용하는 if 문 :

if a == b {
    // do something
} else if a == c {
    // do something else
} else {
    // do something entirely different
}

golang.org의 설명서에 따르면 "표현식은 표현식이 평가되기 전에 실행되는 간단한 문장으로 시작될 수 있습니다." 이 간단한 문에서 선언 된 변수는 if 문으로 범위가 지정되며 변수 외부에서 액세스 할 수 없습니다.

if err := attemptSomething(); err != nil {
    // attemptSomething() was successful!
} else {
    // attemptSomething() returned an error; handle it
}
fmt.Println(err) // compiler error, 'undefined: err'

유형 스위치 명령문

간단한 유형 스위치 :

// assuming x is an expression of type interface{}
switch t := x.(type) {
case nil:
    // x is nil
    // t will be type interface{}
case int: 
    // underlying type of x is int
    // t will be int in this case as well
case string:
    // underlying type of x is string
    // t will be string in this case as well
case float, bool:
    // underlying type of x is either float or bool
    // since we don't know which, t is of type interface{} in this case
default:
    // underlying type of x was not any of the types tested for
    // t is interface{} in this type
}

error , 사용자 정의 유형, 인터페이스 유형 및 함수 유형을 포함하여 모든 유형을 테스트 할 수 있습니다.

switch t := x.(type) {
case error:
    log.Fatal(t)
case myType:
    fmt.Println(myType.message)
case myInterface:
    t.MyInterfaceMethod()
case func(string) bool:
    if t("Hello world?") {
        fmt.Println("Hello world!")
    }
}

문으로 이동

goto 문은 동일한 함수 내에서 해당 레이블이있는 명령문으로 제어를 전송합니다. 실행중인 goto 문은 모든 변수는 시점에서 범위에 이미되지 않은 범위로 오게해서는 안 goto .

예를 들어 표준 라이브러리 소스 코드를 참조하십시오 : https://golang.org/src/math/gamma.go :

    for x < 0 {
        if x > -1e-09 {
            goto small
        }
        z = z / x
        x = x + 1
    }
    for x < 2 {
        if x < 1e-09 {
            goto small
        }
        z = z / x
        x = x + 1
    }

    if x == 2 {
        return z
    }

    x = x - 2
    p = (((((x*_gamP[0]+_gamP[1])*x+_gamP[2])*x+_gamP[3])*x+_gamP[4])*x+_gamP[5])*x + _gamP[6]
    q = ((((((x*_gamQ[0]+_gamQ[1])*x+_gamQ[2])*x+_gamQ[3])*x+_gamQ[4])*x+_gamQ[5])*x+_gamQ[6])*x + _gamQ[7]
    return z * p / q

small:
    if x == 0 {
        return Inf(1)
    }
    return z / ((1 + Euler*x) * x) 

중단 계속 명령문

실행시 break 문은 현재 루프를 강제로 종료시킵니다.

패키지 메인

import "fmt"

func main() {
    i:=0
    for true {
      if i>2 {
        break
        }
    fmt.Println("Iteration : ",i)
    i++
    }
}

실행시 continue 문은 컨트롤을 루프 시작으로 이동합니다.

import "fmt"

func main() {
    j:=100
    for j<110 {
     j++
     if j%2==0 {
        continue
        } 
    fmt.Println("Var : ",j)        
    }
}

스위치 내부에서 중단 / 계속 루프

import "fmt"

func main() {
    j := 100

loop:
    for j < 110 {
        j++

        switch j % 3 {
        case 0:
            continue loop
        case 1:
            break loop
        }

        fmt.Println("Var : ", j)
    }
}