Cの三項演算子に対応する慣用的なGoとは何ですか？

C / C ++（およびそのファミリーの多くの言語）では、条件に応じて変数を宣言および初期化する一般的なイディオムは、3項条件演算子を使用します。

int index = val > 0 ? val : -val

Goには条件演算子がありません。上記と同じコードを実装する最も慣用的な方法は何ですか？私は次の解決策に行きましたが、それはかなり冗長に思われます

var index int

if val > 0 {
    index = val
} else {
    index = -val
}

もっと良いものはありますか？

指摘されているように（そして、できれば当然のことですが）、if+else実際に使用することは、Goで条件文を実行する慣用的な方法です。

ただし、完全なvar+if+elseコードブロックに加えて、このスペルはよく使用されます。

index := val
if val <= 0 {
    index = -val
}

また、と同等の繰り返しの多いコードブロックがある場合は、int value = a <= b ? a : bそれを保持する関数を作成できます。

func min(a, b int) int {
    if a <= b {
        return a
    }
    return b
}

...

value := min(a, b)

コンパイラーはそのような単純な関数をインライン化するため、高速で、明確で、短くなります。

ノーゴーは他の構文は次の場合/使用して、三項演算子を持っていないです慣用的な方法。

Goに？：演算子がないのはなぜですか？

Goには3値テスト操作はありません。以下を使用して同じ結果を得ることができます。

if expr {
    n = trueVal
} else {
    n = falseVal
}

?:Goが欠落している理由は、言語の設計者が操作をあまりにも頻繁に使用して、不可解なほど複雑な式を作成するのを見たことがあるためです。if-elseフォームは、長いものの、紛れもなく明確です。言語に必要な条件付き制御フロー構造は1つだけです。

—よくある質問（FAQ）-Goプログラミング言語

次の3項式（C）があるとします。

int a = test ? 1 : 2;

Goの慣用的なアプローチは、単にifブロックを使用することです。

var a int

if test {
  a = 1
} else {
  a = 2
}

ただし、要件に合わない場合があります。私の場合、コード生成テンプレート用のインライン式が必要でした。

私はすぐに評価される無名関数を使用しました：

a := func() int { if test { return 1 } else { return 2 } }()

これにより、両方のブランチも評価されなくなります。

マップの三項は括弧なしで読みやすいです：

c := map[bool]int{true: 1, false: 0} [5 > 4]

func Ternary(statement bool, a, b interface{}) interface{} {
    if statement {
        return a
    }
    return b
}

func Abs(n int) int {
    return Ternary(n >= 0, n, -n).(int)
}

これはif / elseよりもパフォーマンスが高くなく、キャストが必要ですが機能します。ご参考までに：

BenchmarkAbsTernary-8 100000000 18.8 ns / op

BenchmarkAbsIfElse-8 2000000000 0.27 ns / op

場合は、すべてあなたのブランチが副作用を作るか、ある計算コストが高く、次が考え、意味的に保存リファクタリング：

index := func() int {
    if val > 0 {
        return printPositiveAndReturn(val)
    } else {
        return slowlyReturn(-val)  // or slowlyNegate(val)
    }
}();  # exactly one branch will be evaluated

通常、オーバーヘッドはありません（インライン化）。最も重要なのは、名前空間が1回だけ使用されるヘルパー関数で乱雑にならないことです（読みやすさとメンテナンスが妨げられます）。実例

グスタボのアプローチを単純に適用する場合は注意してください。

    index := printPositiveAndReturn(val);
    if val <= 0 {
        index = slowlyReturn(-val);  // or slowlyNegate(val)
    }

異なる動作のプログラムを取得します。場合にはval <= 0プログラムが非正の値を印刷するだろうが、それはいけません！（同様に、ブランチを逆にすると、スローな関数を不必要に呼び出すことによってオーバーヘッドが発生します。）

序文：それif elseが進むべき道であると主張することなく、言語対応の構成要素をいじって楽しみを見つけることができます。

次のIf構成はgithub.com/icza/gox、builtinx.Ifタイプである他の多くのメソッドとともに私のライブラリで利用できます。

Goを使用すると、などのプリミティブ型を含む、任意のユーザー定義型にメソッドをアタッチできますbool。基になる型boolとして持つカスタム型を作成し、条件に対する単純な型変換を使用して、そのメソッドにアクセスできます。オペランドを受け取って選択するメソッド。

このようなもの：

type If bool

func (c If) Int(a, b int) int {
    if c {
        return a
    }
    return b
}

どうすれば使用できますか？

i := If(condition).Int(val1, val2)  // Short variable declaration, i is of type int
     |-----------|  \
   type conversion   \---method call

たとえば、三進法を行うmax()：

i := If(a > b).Int(a, b)

三元的なことabs()：

i := If(a >= 0).Int(a, -a)

これはクールに見え、シンプルでエレガント、そして効率的です（インライン化にも適しています）。

「実際の」三項演算子と比較した1つの欠点：常にすべてのオペランドを評価します。

延期された場合にのみ必要な評価を実現するための唯一のオプションは、関数（宣言された関数またはメソッド、または関数リテラル）を使用することです。

func (c If) Fint(fa, fb func() int) int {
    if c {
        return fa()
    }
    return fb()
}

それを使用する：レッツは、私たちが計算するには、これらの機能を持っていると仮定aしてb：

func calca() int { return 3 }
func calcb() int { return 4 }

次に：

i := If(someCondition).Fint(calca, calcb)

たとえば、条件が現在の年> 2020である場合：

i := If(time.Now().Year() > 2020).Fint(calca, calcb)

関数リテラルを使用したい場合：

i := If(time.Now().Year() > 2020).Fint(
    func() int { return 3 },
    func() int { return 4 },
)

最後の注意：異なるシグネチャを持つ関数がある場合、ここではそれらを使用できません。その場合、シグネチャが一致する関数リテラルを使用して、それらを引き続き適用できます。

たとえばcalca()とcalcb()（戻り値以外に）あまりにものパラメータを持っているでしょう。

func calca2(x int) int { return 3 }
func calcb2(x int) int { return 4 }

これはあなたがそれらを使うことができる方法です：

i := If(time.Now().Year() > 2020).Fint(
    func() int { return calca2(0) },
    func() int { return calcb2(0) },
)

Go Playgroundでこれらの例を試してください。

eoldの答えは興味深く、創造的で、おそらく賢いです。

ただし、代わりに以下を実行することをお勧めします。

var index int
if val > 0 {
    index = printPositiveAndReturn(val)
} else {
    index = slowlyReturn(-val)  // or slowlyNegate(val)
}

はい、どちらも基本的に同じアセンブリにコンパイルされますが、このコードは、最初に変数に書き込まれた可能性のある値を返すために無名関数を呼び出すよりもはるかに読みやすくなっています。

基本的に、シンプルで明確なコードはクリエイティブコードよりも優れています。

また、Goではマップはまったく軽量ではないため、マップリテラルを使用するコードはお勧めできません。Go 1.3以降では、小さなマップのランダムな反復順序が保証されており、これを強制するために、小さなマップではメモリの面で効率がかなり低くなっています。

その結果、多数の小さなマップの作成と削除は、スペースと時間の両方を消費します。小さなマップを使用するコードがありました（2つまたは3つのキーが考えられますが、一般的な使用例は1つのエントリのみでした）。しかし、コードは非常に低速でした。デュアルスライスキー[インデックス] =>データ[インデックス]マップを使用するように書き直された同じコードよりも少なくとも3桁遅いことを話している。おそらくもっと多かった。以前は実行に数分かかっていた一部の操作がミリ秒で完了し始めました。\

ワンライナーは、クリエーターから敬遠されましたが、彼らの立場にあります。

これは、必要に応じて、評価する関数をオプションで渡せるようにすることで、遅延評価の問題を解決します。

func FullTernary(e bool, a, b interface{}) interface{} {
    if e {
        if reflect.TypeOf(a).Kind() == reflect.Func {
            return a.(func() interface{})()
        }
        return a
    }
    if reflect.TypeOf(b).Kind() == reflect.Func {
        return b.(func() interface{})()
    }
    return b
}

func demo() {
    a := "hello"
    b := func() interface{} { return a + " world" }
    c := func() interface{} { return func() string { return "bye" } }
    fmt.Println(FullTernary(true, a, b).(string)) // cast shown, but not required
    fmt.Println(FullTernary(false, a, b))
    fmt.Println(FullTernary(true, b, a))
    fmt.Println(FullTernary(false, b, a))
    fmt.Println(FullTernary(true, c, nil).(func() string)())
}

出力

hello
hello world
hello world
hello
bye

• 渡された関数はinterface{}、内部キャスト操作を満たすためにを返す必要があります。
• コンテキストによっては、出力を特定のタイプにキャストすることを選択できます。
• これから関数を返したい場合は、で示すように関数をラップする必要がありますc。

ここでのスタンドアロンソリューションも優れていますが、用途によっては不明確になる場合があります。