Degëzimi (switch)

package main

import "fmt"

func main() {
    x := 20000

    switch x {
    case 10000:
        fmt.Println("Prishtina")
    case 20000:
        fmt.Println("Prizreni")
    case 70000:
        fmt.Println("Ferizaji")
    default:
        fmt.Println("Kod postar i panjohur")
    }
}

https://play.golang.org/p/Je35FFMxj6_-

Rezultati:

Prizreni

Blloku i kodit pas default ekzekutohet nëse nuk është plotësuar asnjë prej kushteve me case. Urdhëri default nuk është i domosdoshëm nëse logjika e kodit nuk e kërkon. Urdhëro default mund të vendoset kudo brenda switch, nuk është e domosdoshme të jetë në fund.

Tipi i vlerës që evaluuar në switch dhe tipi i vlerës në case duhet të përputhen. Nëse nuk përputhen, do të lajmërohet gabim gjatë kompajlimit. Vlerat në case nëse janë numerike, lejohet që në switch ta kemi variablin të tipit qoftë float, qoftë int.

package main

import "fmt"

func main() {
    x := 100.00

    switch x {
    case 100.00:
        fmt.Println("Prishtina")
    case 20000:
        fmt.Println("Prizreni")
    case 70000:
        fmt.Println("Ferizaji")
    default:
        fmt.Println("Kod postar i panjohur")
    }
}

https://play.golang.org/p/lFEFtH7CsbQ

Rezultati:

Prishtina

Kjo “tolerancë” nga ana e Go ndodh për shkak se krahasimin e vlerës së x e bëjmë ndaj vlerave numerike të cilat konsiderohen konstanta. Nëse në vend të atyre numrave vendosim variabla me të deklaruara me tip, atëherë do të kemi problem sepse Go do të kërkojë që variabli x dhe variabli me të cilin krahasohet të jenë të tipit identik, përndryshe do të raportohet gabimi për mospërputhjen e tipeve.

package main

import "fmt"

func main() {
    x := 10000
    var a int16 = 20000

    switch x {
    case 10000:
        fmt.Println("Prishtina")
    case a:
        fmt.Println("Prizreni")
    case 70000:
        fmt.Println("Ferizaji")
    default:
        fmt.Println("Kod postar i panjohur")
    }
}

https://play.golang.org/p/NtmdE9uh652

Rezultati:

invalid case a in switch on x (mismatched types int16 and int)

Secili case është scope në vete, kështu që variablat e deklaruara dhe inicializuara brenda atij blloku, nuk do të jenë të qasshëm jashtë strukturës switch.

Scope i case nuk ndryshon edhe në rastet kur kemi fallthrough nga një case në case-in vijues.

package main

import "fmt"

func main() {
    x := 10000

    switch x {
    case 10000:
        fmt.Println("Prishtina")
        a := 500
        fallthrough
    case 20000:
        fmt.Println(a)
        fmt.Println("Prizreni")
    case 70000:
        fmt.Println("Ferizaji")
    default:
        fmt.Println("Kod postar i panjohur")
    }
}

https://play.golang.org/p/OgGBkdIS3rX

Rezultati:

undefined: a

Pra, secili case është scope në vete dhe variablat e definuara në një case, nuk janë të qasshëm në case tjetër edhe kur bëjmë fallthrough.

Nëse nuk ka fare shprehje pas switch, vlera që evaluohet është boolean, prandaj dhe në case duhet të kemi shprehje boolean, siç janë operatorët e krahasimit.

package main

import "fmt"

func main() {
    i := 1
    switch {
    case i < 5:
        fmt.Println("i me i vogel se 5")
    case i == 5:
        fmt.Println("i baras 5")
    default:
        fmt.Println("i me i madh 5")
    }
}

https://play.golang.org/p/rtdtszn6ZrR

Rezultati:

i me i vogel se 5

Nëse në më tepër se një case plotësohet kushti, ekzekutohet vetëm kodi pas case të parë.

package main

import "fmt"

func main() {
    i := 1
    switch {
    case i < 5:
        fmt.Println("i me i vogel se 5")
    case i < 7:
        fmt.Println("i me i vogel se 7")
    }
}

https://play.golang.org/p/jfczKTCcaSU

Rezultati:

i me i vogel se 5

Switch në Go nuk ka nevojë për break.
Nëse duhet që nga një case të kalohet te tjetri case pa e evaluuar kushtin, përdoret urdhëri fallthrough.

package main

import "fmt"

func main() {
    x := 20000

    switch x {
    case 10000:
        fmt.Println("Prishtina")
    case 20000:
        fmt.Println("Prizreni")
        fallthrough
    case 70000:
        fmt.Println("Ferizaji")
    default:
        fmt.Println("Kod postar i panjohur")
    }
}

https://play.golang.org/p/elGAO1aAXjC

Rezultati:

Prizreni
Ferizaji

Kllapat e mëdha (curly braces) nuk janë të domosdoshëm për definimin e bllokut të kodit pas case.

package main

import "fmt"

func main() {
    i := 1
    switch {
    case i < 5:
        {
            fmt.Println("i me i vogel se 5")
        }
    case i == 5:
        {
            fmt.Println("i baras 5")
        }
    default:
        {
            fmt.Println("i me i madh 5")
        }
    }

    // Njëjtë si

    switch {
    case i < 5:
        fmt.Println("i me i vogel se 5")
    case i == 5:
        fmt.Println("i baras 5")

    default:
        fmt.Println("i me i madh 5")
    }
}

https://play.golang.org/p/qj3X-PyUAME

Rezultati:

i me i vogel se 5
i me i vogel se 5

Shprehjet në case mund të jenë vlera apo shprehje.

package main

import "fmt"

func main() {
    a := 2
    i := 8

    switch i {
    case 5:
        fmt.Println("i baras 5")
    case a + 6:
        fmt.Println("i baras 8")
    }
}

https://play.golang.org/p/Z147M9xT7Co

Rezultati:

i baras 8

Mund të përdorim çfarëdo numri të case.

Brenda case mund të vendosen disa shprehje të përputhjes, të ndarë me presje.

package main

import "fmt"

func main() {
    a := 5

    switch a {
    case 5, 6, 7:
        fmt.Println("a baras me 5, 6 ose 7")
    case 8:
        fmt.Println("a baras me 8")
    }
}

https://play.golang.org/p/WW4022ZHACD

Rezultati:

a baras me 5, 6 ose 7

Switch initializer

package main

import (
    "fmt"
    "time"
)

func main() {
    switch m := time.Now(); {
    case m.Month() >= 12 || m.Month() < 3:
        fmt.Println("Dimër")
    case m.Month() >= 3 && m.Month() < 6:
        fmt.Println("Pranverë")
    case m.Month() >= 6 && m.Month() < 9:
        fmt.Println("Verë")
    case m.Month() >= 9 && m.Month() < 12:
        fmt.Println("Vjeshtë")
    default:
        fmt.Println("Nuk di cila stinë është")
    }
}

https://play.golang.org/p/ZvvHIkLzc6p

Rezultati:

Vjeshtë

Shembulli në vijim ka të bëjë me ditët e javës. Lexohet dita e javës nga sistemi nëpërmes pakos time dhe pastaj bëhet degëzimi në varësi prej vlerës së kthyer. Për vlerat time.Saturday dhe time.Sunday do të raportohet “Fundjavë”, ndërsa për vlerat tjera do të raportohet “Ditë pune”.

package main

import (
    "fmt"
    "time"
)

func main() {
    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("Fundjavë")
    default:
        fmt.Println("Ditë pune")
    }
}

https://play.golang.org/p/U3Yu8KGbY6-

Rezultati:

Ditë pune

Switch mund të përdoret edhe për determinimin e tipeve të variablave, në rastet kur funksioni pranon si parametër një interfejs të zbrazët. Interfejsat e zbrazët përdoren për pranimin e vlerave tipeve të ndryshme. Pas pranimit të vlerës, analizojmë me switch v := i.(type) cilit tip konkret i përket variabli i bartur në funksion.

package main

import "fmt"

func main() {
    printo("Tung")
    printo(67)
    printo(true)
}

func printo(i interface{}) {
    switch v := i.(type) {
    case int:
        fmt.Printf("Tipi është integer për %v\n", v)
    case string:
        fmt.Printf("Tipi është string për %v\n", v)
    case bool:
        fmt.Printf("Tipi është bool për %v\n", v)
    default:
        fmt.Printf("Nuk di çfarë tipi është %v \n", v)
    }
}

https://play.golang.org/p/flsKeobzBA2

Rezultati:

Tipi është string për Tung
Tipi është integer për 67
Tipi është bool për true