Go'da iç içe geçmiş işlev bildirimlerine izin vermeyerek hafifletilen sorunlar nelerdir?

Lambdalar beklendiği gibi çalışır:

func main() {
    inc := func(x int) int { return x+1; }
}

Ancak, bir beyannamenin içinde aşağıdaki beyana izin verilmez:

func main() {
    func inc(x int) int { return x+1; }
}

Hangi nedenle iç içe geçmiş işlevlere izin verilmez?

Bu bariz özelliğe izin verilmemesinin 3 nedeni olduğunu düşünüyorum.

1. Derleyiciyi biraz karmaşıklaştırır. Derleyici şu anda tüm işlevlerin en üst düzeyde olduğunu bilir.
2. Bu, yeni bir programcı hatası sınıfına neden olur - bir şeyi yeniden düzenleyebilir ve bazı işlevleri yanlışlıkla iç içe geçirebilirsiniz.
3. İşlevler ve kapanışlar için farklı bir söz dizimine sahip olmak iyi bir şeydir. Kapatma yapmak, potansiyel olarak bir işlev yapmaktan daha pahalıdır, bu yüzden bunu yaptığınızı bilmelisiniz.

Yine de bunlar sadece benim görüşlerim - dil tasarımcılarından resmi bir açıklama görmedim.

Elbette öyleler. Bunları bir değişkene atamanız yeterlidir:

func main() {
    inc := func(x int) int { return x+1; }
}

Sıkça Sorulan Sorular (SSS)

Go neden X özelliğine sahip değil?

Her dil yeni özellikler içerir ve birinin en sevdiği özelliği atlar. Go, programlamanın mutluluğu, derleme hızı, kavramların ortogonalitesi ve eşzamanlılık ve çöp toplama gibi özellikleri destekleme ihtiyacı göz önünde bulundurularak tasarlandı. En sevdiğiniz özellik, uymadığından, derleme hızını veya tasarımın netliğini etkilediği veya temel sistem modelini çok zorlaştıracağı için eksik olabilir.

Go'nun X özelliğinin eksik olması sizi rahatsız ediyorsa, lütfen bizi affedin ve Go'nun sahip olduğu özellikleri araştırın. X'in eksikliğini ilginç yollarla telafi ettiklerini görebilirsiniz.

İç içe geçmiş işlevler eklemenin karmaşıklığını ve masrafını ne haklı çıkarır? İç içe geçmiş işlevler olmadan yapamayacağınız ne yapmak istiyorsunuz? Ve benzeri.

İç içe geçmiş işlevler ve işlevler içinde yuvalanmış işlevler uygulamanın bir yolu

package main

    import "fmt"

    func main() {
        nested := func() {
            fmt.Println("I am nested")

            deeplyNested := func() {
                fmt.Println("I am deeply nested")
            }

            deeplyNested()
        }

        nested()
    }

Go'da iç içe geçmiş işlevlere izin verilir. Bunları dış işlevdeki yerel değişkenlere atamanız ve bu değişkenleri kullanarak çağırmanız yeterlidir.

Misal:

func outerFunction(iterations int, s1, s2 string) int {
    someState := 0
    innerFunction := func(param string) int {
        // Could have another nested function here!
        totalLength := 0
        // Note that the iterations parameter is available
        // in the inner function (closure)
        for i := 0; i < iterations; i++) {
            totalLength += len(param)
        }
        return totalLength
    }
    // Now we can call innerFunction() freely
    someState = innerFunction(s1)
    someState += innerFunction(s2)
    return someState
}
myVar := outerFunction(100, "blah", "meh")

İç işlevler genellikle yerel gorutinler için kullanışlıdır:

func outerFunction(...) {
    innerFunction := func(...) {
        ...
    }
    go innerFunction(...)
}

Hemen ()sonuna ekleyerek aramanız yeterlidir.

func main() {
    func inc(x int) int { return x+1; }()
}

Düzenleme: işlev adı olamaz ... bu yüzden hemen çağrılan bir lambda işlevi:

func main() {
    func(x int) int { return x+1; }()
}