Céard iad na constructs rialú-sreafa atá ag Go?

Question

Accepted Answer

Tá rialú sreafa Go **íosta** go fúill — níl ann ach **focal eochair amháin lúibe (`for`)**, gan lúibíní timpeall ar choinníollacha, agus braces éigeantach. Is beartaithe an simplíochta seo — tugann sé bealach amháin soiléir a dhéanamh gach rud. ## if — gan lúibíní, le ráiteas tosaigh roghnach ```go if x > 10 { // no parentheses around the condition; braces required fmt.Println("big") } else if x > 5 { fmt.Println("medium") } else { fmt.Println("small") } // if with an INIT statement — variable scoped to the if/else (very idiomatic) if err := doSomething(); err != nil { return err // `err` exists only within this if/else } ``` Tá an fhoirm `if init; condition` (athróg a dhearbhú scópaithe go dtí an if) an-choitianta i Go — go háirithe an patrún seiceála earráid `if err := ...; err != nil`. ## for — an AONÚR lúibe, i roinnt foirmeacha ```go // 1. classic three-part for for i := 0; i < 10; i++ { ... } // 2. while-style (just a condition) for x < 100 { x *= 2 } // 3. infinite loop for { ... break ... } // loop forever until break // 4. range — iterate slices, maps, strings, channels for index, value := range mySlice { ... } for key, value := range myMap { ... } for i, char := range "héllo" { ... } // i is byte index, char is a rune for range channel { ... } ``` Níl `while` ná `do-while` ag Go — fúiltíonn `for` do gach riachtanas lúibe. Is an bealach idiomatic í an fhoirm `range` chun bailiúchán a fhrasúil. ## switch — níos geal ná C (gan titim tríd) ```go switch day { case "Sat", "Sun": // multiple values per case fmt.Println("weekend") case "Mon": fmt.Println("monday") // NO break needed — Go does NOT fall through by default! default: fmt.Println("weekday") } // switch with no condition = clean if/else chain switch { case score >= 90: grade = "A" case score >= 80: grade = "B" default: grade = "F" } ``` Murab ionann agus C/Java, ní thitíonn `switch` Go **tríd** de réir réamhshocrú (níl gá le `break`) — ag foluain an bhug clasaiceach sin. Úsáid an focal eochair `fallthrough` sa chás neamhghnách go bhfuil sé uait. ## defer — socrú glanúchán ```go func readFile() { f, _ := os.Open("file.txt") defer f.Close() // runs when the function RETURNS — guaranteed cleanup // ... use f ... } ``` Socrú `defer` a thabhairt ar shiúl nuair a fhilleann an fheidhm thimpeallach — idiomatic do ghlantachán (comhaid a dhúnadh, mutexes a dhíghlasáil). ## Cén fáth a bhíonn tábhacht ann Tá rialú sreafa Go go fúill íosta arna dhéanamh ar intinn ag léiriú a fealsunamh simplíochta agus tá impleáchtaí praiticiúla ann ar fhiú a bheith ar an eolas. Bheith **amháin `for`** ann (clúdaithe clasaiceach, fad-stíl, gan teorainn, agus raonanna lúibe) ciallaíonn sé go bhfuil construct lúibe comhsheasmhach amháin — `range` an bealach idiomatic a bheith ann. An **gan-lúibíní, braces éigeantach** comhréir agus an fhoirm **`if init; cond`** (go háirithe `if err := ...; err != nil`) an cruth ar Go idiomatic. **gan titim tríd de réir réamhshocrú** a dhíchealladh `switch` a chealadh bhug coitianta C-teanga, agus tá an `switch` gan choinníoll a bheith ina rogha soiléir if/else. Agus is meicníocht glanúcháin ar leith, riachtanach `defer`. Tuigint ar na rudaí seo — agus conas a fhéadann siad difríochtach ó theangacha eile (aon lúibe, gan titim tríd, defer) — is bunúsach do léamh agus scríobh Go idiomatic.