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を比較するケースが1つもない場合にのみ実行されます。以下は意味的には最初の例と同じです：

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

これは、 default句でfallthroughステートメントを使用する場合に便利です。これは、caseの最後のステートメントでなければならず、プログラムの実行が次のケースに進むことになります。

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文では、任意の変数はの時点でスコープ内にすでにありませんでしたスコープに来させてはならない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)
    }
}