C'nin üçlü operatörünün deyimsel Go eşdeğeri nedir?

C / C ++ 'da (ve bu ailenin birçok dilinde), bir koşula bağlı olarak bir değişkeni bildirmek ve başlatmak için ortak bir deyim üçlü koşullu işleci kullanır:

int index = val > 0 ? val : -val

Go'nun koşullu operatörü yok. Yukarıdaki ile aynı kod parçasını uygulamanın en deyimsel yolu nedir? Aşağıdaki çözüme geldim, ama oldukça ayrıntılı görünüyor

var index int

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

Daha iyi bir şey var mı?

Belirtildiği gibi (ve umarım şaşırtıcı olmayan bir şekilde), kullanmak if+elsegerçekten Go'da koşullu olmanın deyimsel yoludur .

Bununla birlikte, tam var+if+elsekod bloğuna ek olarak , bu yazım sıklıkla kullanılır:

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

ve eşdeğeri gibi yeterince tekrarlayan bir kod bloğunuz varsa int value = a <= b ? a : b, bunu tutacak bir işlev oluşturabilirsiniz:

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

...

value := min(a, b)

Derleyici bu gibi basit işlevleri satır içi yapar, bu nedenle hızlı, daha net ve daha kısa olur.

Hayır Git başka sözdizimi eğer / kullanarak, üçlü operatörü yok olduğunu deyimsel yol.

Go neden?: Operatörüne sahip değil?

Go'da üçlü test işlemi yoktur. Aynı sonucu elde etmek için aşağıdakileri kullanabilirsiniz:

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

?:Go'nun yok olmasının nedeni , dil tasarımcılarının operasyonu geçilmez karmaşık ifadeler oluşturmak için çok sık kullandığını görmesidir. if-elseBir şekilde, daha uzun olsa da, kuşkusuz daha nettir. Bir dilin yalnızca bir koşullu kontrol akış yapısına ihtiyacı vardır.

- Sık Sorulan Sorular (SSS) - Go Programlama Dili

Aşağıdaki üçlü ifadeye sahip olduğunuzu varsayalım (C cinsinden):

int a = test ? 1 : 2;

Go'daki deyimsel yaklaşım sadece bir ifblok kullanmak olacaktır :

var a int

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

Ancak, bu gereksinimlerinize uygun olmayabilir. Benim durumumda, bir kod oluşturma şablonu için satır içi bir ifade gerekiyordu.

Hemen değerlendirilen anonim bir işlev kullandım:

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

Bu, her iki dalın da değerlendirilmemesini sağlar.

Harita üçlüsü parantez olmadan kolayca okunabilir:

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

Bu, / else durumunda daha iyi performans göstermez ve cast gerektirir ancak çalışır. Bilginize:

KarşılaştırmaAbsTernary-8 100000000 18,8 ns / op

BenchmarkAbsIfElse-8 2000000000 0,27 ns / op

Eğer tüm senin dalları yan etkileri yapmak veya olan hesaplama pahalı şu bir olur anlamsal koruyarak üstlenmeden:

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

normalde ek yük olmadan (satır içi) ve en önemlisi, ad alanınızı yalnızca bir kez kullanılan bir yardımcı işlevle (okunabilirliği ve bakımı engelleyen) engellemeden. Canlı Örnek

Gustavo'nın yaklaşımını saf bir şekilde uygulayacak olsaydınız :

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

farklı bir davranışa sahip bir program alırsınız ; val <= 0Programın pozitif olmamalı bir değer yazdırması durumunda ! (Benzer şekilde, dalları tersine çevirirseniz, gereksiz bir şekilde yavaş bir işlevi çağırarak ek yük getirebilirsiniz.)

Önsöz: Bunu tartışmadanif else yolun , dil etkin yapılarda hala oynayabilir ve zevk bulabiliriz.

Aşağıdaki Ifyapı, github.com/icza/goxkütüphanemde tür olan birçok başka yöntemle kullanılabilir builtinx.If.

Go, ilkel türler de dahil olmak üzere kullanıcı tanımlı türlere yöntem eklenmesine izin verir bool. Biz sahip özel bir türü oluşturabilir boolonun kadar altta yatan tip ve sonra basit bir tip olan dönüşüm şartıyla, biz onun yöntemlerine erişim hakkına sahiptir. İşlenenlerden alma ve seçim yöntemleri.

Bunun gibi bir şey:

type If bool

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

Nasıl Kullanabiliriz?

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

Örneğin bir üçlü max():

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

Üçlü abs():

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

Bu harika görünüyor, basit, zarif ve verimli (aynı zamanda satır içi için de uygun ).

"Gerçek" üçlü operatörle karşılaştırıldığında bir dezavantaj: her zaman tüm işlenenleri değerlendirir.

Ertelenmiş ve yalnızca gerekirse değerlendirme yapmak için tek seçenek, yalnızca gerektiğinde / gerekirse çağrılan işlevleri ( bildirilen işlevler veya yöntemler veya işlev değişmezleri ) kullanmaktır:

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

Kullanmak: Diyelim ki hesaplamak için bu fonksiyonlara sahibiz ave b:

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

Sonra:

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

Örneğin, mevcut yıl> 2020 olan koşul:

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

İşlev değişmezlerini kullanmak istiyorsak:

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

Son not: Farklı imzalara sahip işlevleriniz varsa, burada kullanamazsınız. Bu durumda, hala uygulanabilir hale getirmek için eşleşen imzalı bir işlev değişmezi kullanabilirsiniz.

Örneğin , parametrelerde de calca()ve varsa calcb()(dönüş değerinin yanı sıra):

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

Bunları şu şekilde kullanabilirsiniz:

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

Go Playground'da bu örnekleri deneyin .

eold'un cevabı ilginç ve yaratıcı, belki de akıllı.

Ancak bunun yerine şunları yapmanız önerilir:

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

Evet, her ikisi de esasen aynı derlemeye derler, ancak bu kod, ilk etapta değişkene yazılmış olabilecek bir değeri döndürmek için anonim bir işlevi çağırmaktan çok daha okunaklıdır.

Temel olarak, basit ve net kod, reklam kodundan daha iyidir.

Ayrıca, harita hazır bilgisi kullanan herhangi bir kod iyi bir fikir değildir, çünkü Go'da haritalar hiç hafif değildir. Go 1.3'ten beri, küçük haritalar için rastgele yineleme sırası garanti edilir ve bunu uygulamak için küçük haritalar için bellek açısından biraz daha az verimli bir şekilde kazanılır.

Sonuç olarak, çok sayıda küçük harita oluşturmak ve kaldırmak hem alan hem de zaman alıcıdır. Küçük bir harita (iki ya da üç anahtar, büyük olasılıkla, ancak ortak kullanım durumu sadece bir giriş oldu) kullanılan bir kod parçası vardı Ama kod köpek yavaş oldu. İkili dilim anahtarı [index] => data [index] haritasını kullanmak için yeniden yazılan aynı koddan en az 3 büyüklükte daha az bahsediyoruz. Ve muhtemelen daha fazlaydı. Daha önce çalışması birkaç dakika süren bazı işlemler milisaniyeler içinde tamamlanmaya başladı. \

Tek gömlekler, içerik oluşturucular tarafından kapatılsa da yerlerini alır.

Bu, isteğe bağlı olarak, gerekirse değerlendirilecek işlevleri geçmenize izin vererek tembel değerlendirme sorununu çözer:

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

Çıktı

hello
hello world
hello world
hello
bye

• Aktarılan işlevler bir interface{} dahili döküm işlemini tatmin etmek için a .
• Bağlama bağlı olarak, çıktıyı belirli bir türe atamayı seçebilirsiniz.
• Bundan bir işlev döndürmek isterseniz, işlevini gösterildiği gibi sarmanız gerekir c.

Tek başına çözüm burada da güzel, ama bazı kullanımlar için daha az açık olabilir.