Apa yang setara idiomatik Go dari operator ternary C?

Dalam C / C ++ (dan banyak bahasa dari keluarga itu), idiom umum untuk menyatakan dan menginisialisasi variabel tergantung pada suatu kondisi menggunakan operator kondisional ternary:

int index = val > 0 ? val : -val

Go tidak memiliki operator kondisional. Apa cara paling idiomatis untuk mengimplementasikan kode yang sama seperti di atas? Saya datang ke solusi berikut, tetapi sepertinya cukup bertele-tele

var index int

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

Apakah ada sesuatu yang lebih baik?

Seperti yang ditunjukkan (dan mudah-mudahan tidak mengejutkan), menggunakan if+elsememang cara idiomatis untuk melakukan persyaratan di Go.

Selain var+if+elseblok kode yang penuh, ejaan ini juga sering digunakan:

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

dan jika Anda memiliki blok kode yang cukup berulang, seperti yang setara int value = a <= b ? a : b, Anda dapat membuat fungsi untuk menahannya:

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

...

value := min(a, b)

Kompiler akan menampilkan fungsi-fungsi sederhana seperti itu, sehingga cepat, lebih jelas, dan lebih pendek.

No Go tidak memiliki operator ternary, menggunakan sintaks if / else adalah cara idiomatis.

Mengapa Go tidak memiliki operator:?

Tidak ada operasi pengujian ternary di Go. Anda dapat menggunakan yang berikut ini untuk mencapai hasil yang sama:

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

Alasannya ?:absen dari Go adalah bahwa perancang bahasa telah melihat operasi yang digunakan terlalu sering untuk membuat ekspresi rumit yang tak dapat ditembus. The if-elsebentuk, meskipun lagi, tidak diragukan lagi lebih jelas. Bahasa hanya membutuhkan satu konstruksi aliran kontrol bersyarat.

- Pertanyaan yang Sering Diajukan (FAQ) - Bahasa Pemrograman Go

Misalkan Anda memiliki ekspresi ternary berikut (dalam C):

int a = test ? 1 : 2;

Pendekatan idiomatis di Go adalah dengan menggunakan ifblok:

var a int

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

Namun, itu mungkin tidak sesuai dengan kebutuhan Anda. Dalam kasus saya, saya membutuhkan ekspresi sebaris untuk templat pembuatan kode.

Saya menggunakan fungsi anonim yang langsung dievaluasi:

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

Ini memastikan bahwa kedua cabang tidak dievaluasi juga.

Peta ternary mudah dibaca tanpa tanda kurung:

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)
}

Ini tidak akan mengungguli jika / else dan membutuhkan pemain tetapi berfungsi. FYI:

BenchmarkAbsTernary-8 100000000 18,8 ns / op

BenchmarkAbsIfElse-8 2000000000 0,27 ns / op

Jika semua cabang Anda membuat efek samping atau mahal secara komputasi , berikut ini akan menjadi refactoring yang melestarikan secara semantik :

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

dengan biasanya tidak ada overhead (sebaris) dan, yang paling penting, tanpa mengacaukan namespace Anda dengan fungsi pembantu yang hanya digunakan sekali (yang menghambat keterbacaan dan pemeliharaan). Contoh Langsung

Perhatikan jika Anda secara naif menerapkan pendekatan Gustavo :

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

Anda akan mendapatkan program dengan perilaku yang berbeda ; dalam hal val <= 0program akan mencetak nilai non-positif sedangkan seharusnya tidak! (Secara analogi, jika Anda membalikkan cabang, Anda akan memperkenalkan overhead dengan memanggil fungsi yang lambat tidak perlu.)

Kata Pengantar: Tanpa berdebat bahwa if elseini adalah jalan yang harus ditempuh, kita masih dapat bermain dan menemukan kesenangan dalam konstruksi yang didukung bahasa.

IfKonstruk berikut tersedia di github.com/icza/goxperpustakaan saya dengan banyak metode lain, sebagai builtinx.Iftipenya.

Go memungkinkan untuk melampirkan metode ke tipe yang ditentukan pengguna , termasuk tipe primitif seperti bool. Kita dapat membuat tipe kustom yang memiliki boolsebagai tipe yang mendasarinya , dan kemudian dengan konversi tipe sederhana pada kondisi tersebut, kita memiliki akses ke metode-metodenya. Metode yang menerima dan memilih dari operan.

Sesuatu seperti ini:

type If bool

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

Bagaimana kita bisa menggunakannya?

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

Misalnya seorang ternary melakukan max():

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

Seorang ternary melakukan abs():

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

Ini terlihat keren, sederhana, elegan, dan efisien (ini juga memenuhi syarat untuk inlining ).

Satu kelemahan dibandingkan dengan operator ternary "nyata": selalu mengevaluasi semua operan.

Untuk mencapai evaluasi yang ditangguhkan dan hanya-jika-diperlukan, satu-satunya pilihan adalah menggunakan fungsi (baik fungsi atau metode yang dideklarasikan , atau fungsi literal ), yang hanya dipanggil ketika / jika diperlukan:

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

Menggunakannya: Mari kita asumsikan kita memiliki fungsi-fungsi ini untuk menghitung adan b:

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

Kemudian:

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

Misalnya, kondisi menjadi tahun berjalan> 2020:

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

Jika kita ingin menggunakan fungsi literal:

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

Catatan akhir: jika Anda akan memiliki fungsi dengan tanda tangan yang berbeda, Anda tidak dapat menggunakannya di sini. Dalam hal ini Anda dapat menggunakan fungsi literal dengan tanda tangan yang cocok untuk membuatnya masih berlaku.

Misalnya jika calca()dan calcb()akan memiliki parameter juga (selain nilai balik):

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

Ini adalah bagaimana Anda dapat menggunakannya:

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

Cobalah contoh-contoh ini di Go Playground .

jawaban eold menarik dan kreatif, bahkan mungkin pintar.

Namun, disarankan untuk melakukan:

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

Ya, keduanya mengkompilasi pada dasarnya rakitan yang sama, namun kode ini jauh lebih mudah dibaca daripada memanggil fungsi anonim hanya untuk mengembalikan nilai yang bisa ditulis ke variabel di tempat pertama.

Pada dasarnya, kode sederhana dan jelas lebih baik daripada kode kreatif.

Selain itu, kode apa pun yang menggunakan peta literal bukan ide yang baik, karena peta tidak ringan sama sekali di Go. Sejak Go 1.3, urutan iterasi acak untuk peta kecil dijamin, dan untuk menegakkan ini, memori yang didapat agak kurang efisien untuk peta kecil.

Akibatnya, membuat dan menghapus banyak peta kecil memakan banyak ruang dan waktu. Saya memiliki sepotong kode yang menggunakan peta kecil (dua atau tiga kunci, mungkin, tetapi kasus penggunaan umum hanya satu entri) Tetapi kode itu lambat anjing. Kita berbicara setidaknya 3 urutan besarnya lebih lambat dari kode yang sama ditulis ulang untuk menggunakan kunci slice ganda [indeks] => data peta [indeks]. Dan kemungkinan lebih banyak. Karena beberapa operasi yang sebelumnya membutuhkan waktu beberapa menit untuk dijalankan, mulai menyelesaikan dalam milidetik. \

One-liner, meskipun dijauhi oleh pencipta, memiliki tempat mereka.

Yang ini menyelesaikan masalah evaluasi malas dengan membiarkan Anda, secara opsional, melewati fungsi yang akan dievaluasi jika perlu:

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)())
}

Keluaran

hello
hello world
hello world
hello
bye

• Fungsi yang dilewati harus mengembalikan suatu interface{}untuk memenuhi operasi pemeran internal.
• Bergantung pada konteksnya, Anda dapat memilih untuk menampilkan output ke tipe tertentu.
• Jika Anda ingin mengembalikan fungsi dari ini, Anda harus membungkusnya seperti yang ditunjukkan pada c.

Solusi mandiri di sini juga bagus, tetapi bisa jadi kurang jelas untuk beberapa kegunaan.