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